1 // SPDX-License-Identifier: LGPL-2.1
5 * Copyright (C) International Business Machines Corp., 2002,2011
6 * Author(s): Steve French (sfrench@us.ibm.com)
10 #include <linux/net.h>
11 #include <linux/string.h>
12 #include <linux/sched/mm.h>
13 #include <linux/sched/signal.h>
14 #include <linux/list.h>
15 #include <linux/wait.h>
16 #include <linux/slab.h>
17 #include <linux/pagemap.h>
18 #include <linux/ctype.h>
19 #include <linux/utsname.h>
20 #include <linux/mempool.h>
21 #include <linux/delay.h>
22 #include <linux/completion.h>
23 #include <linux/kthread.h>
24 #include <linux/pagevec.h>
25 #include <linux/freezer.h>
26 #include <linux/namei.h>
27 #include <linux/uuid.h>
28 #include <linux/uaccess.h>
29 #include <asm/processor.h>
30 #include <linux/inet.h>
31 #include <linux/module.h>
32 #include <keys/user-type.h>
34 #include <linux/parser.h>
35 #include <linux/bvec.h>
38 #include "cifsproto.h"
39 #include "cifs_unicode.h"
40 #include "cifs_debug.h"
41 #include "cifs_fs_sb.h"
44 #include "rfc1002pdu.h"
46 #include "smb2proto.h"
47 #include "smbdirect.h"
48 #include "dns_resolve.h"
49 #ifdef CONFIG_CIFS_DFS_UPCALL
50 #include "dfs_cache.h"
52 #include "fs_context.h"
55 extern mempool_t *cifs_req_poolp;
56 extern bool disable_legacy_dialects;
58 /* FIXME: should these be tunable? */
59 #define TLINK_ERROR_EXPIRE (1 * HZ)
60 #define TLINK_IDLE_EXPIRE (600 * HZ)
62 /* Drop the connection to not overload the server */
63 #define NUM_STATUS_IO_TIMEOUT 5
65 static int ip_connect(struct TCP_Server_Info *server);
66 static int generic_ip_connect(struct TCP_Server_Info *server);
67 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
68 static void cifs_prune_tlinks(struct work_struct *work);
71 * Resolve hostname and set ip addr in tcp ses. Useful for hostnames that may
72 * get their ip addresses changed at some point.
74 * This should be called with server->srv_mutex held.
76 static int reconn_set_ipaddr_from_hostname(struct TCP_Server_Info *server)
80 char *unc, *ipaddr = NULL;
82 if (!server->hostname)
85 len = strlen(server->hostname) + 3;
87 unc = kmalloc(len, GFP_KERNEL);
89 cifs_dbg(FYI, "%s: failed to create UNC path\n", __func__);
92 scnprintf(unc, len, "\\\\%s", server->hostname);
94 rc = dns_resolve_server_name_to_ip(unc, &ipaddr);
98 cifs_dbg(FYI, "%s: failed to resolve server part of %s to IP: %d\n",
99 __func__, server->hostname, rc);
103 spin_lock(&cifs_tcp_ses_lock);
104 rc = cifs_convert_address((struct sockaddr *)&server->dstaddr, ipaddr,
106 spin_unlock(&cifs_tcp_ses_lock);
112 #ifdef CONFIG_CIFS_DFS_UPCALL
113 /* These functions must be called with server->srv_mutex held */
114 static void reconn_set_next_dfs_target(struct TCP_Server_Info *server,
115 struct cifs_sb_info *cifs_sb,
116 struct dfs_cache_tgt_list *tgt_list,
117 struct dfs_cache_tgt_iterator **tgt_it)
122 if (!cifs_sb || !cifs_sb->origin_fullpath)
126 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
128 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
130 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
133 cifs_dbg(FYI, "%s: UNC: %s\n", __func__, cifs_sb->origin_fullpath);
135 name = dfs_cache_get_tgt_name(*tgt_it);
137 kfree(server->hostname);
139 server->hostname = extract_hostname(name);
140 if (IS_ERR(server->hostname)) {
142 "%s: failed to extract hostname from target: %ld\n",
143 __func__, PTR_ERR(server->hostname));
147 rc = reconn_set_ipaddr_from_hostname(server);
149 cifs_dbg(FYI, "%s: failed to resolve hostname: %d\n",
154 static inline int reconn_setup_dfs_targets(struct cifs_sb_info *cifs_sb,
155 struct dfs_cache_tgt_list *tl)
157 if (!cifs_sb->origin_fullpath)
159 return dfs_cache_noreq_find(cifs_sb->origin_fullpath + 1, NULL, tl);
164 * cifs tcp session reconnection
166 * mark tcp session as reconnecting so temporarily locked
167 * mark all smb sessions as reconnecting for tcp session
168 * reconnect tcp session
169 * wake up waiters on reconnection? - (not needed currently)
172 cifs_reconnect(struct TCP_Server_Info *server)
175 struct list_head *tmp, *tmp2;
176 struct cifs_ses *ses;
177 struct cifs_tcon *tcon;
178 struct mid_q_entry *mid_entry;
179 struct list_head retry_list;
180 #ifdef CONFIG_CIFS_DFS_UPCALL
181 struct super_block *sb = NULL;
182 struct cifs_sb_info *cifs_sb = NULL;
183 struct dfs_cache_tgt_list tgt_list = {0};
184 struct dfs_cache_tgt_iterator *tgt_it = NULL;
187 spin_lock(&GlobalMid_Lock);
188 server->nr_targets = 1;
189 #ifdef CONFIG_CIFS_DFS_UPCALL
190 spin_unlock(&GlobalMid_Lock);
191 sb = cifs_get_tcp_super(server);
194 cifs_dbg(FYI, "%s: will not do DFS failover: rc = %d\n",
198 cifs_sb = CIFS_SB(sb);
199 rc = reconn_setup_dfs_targets(cifs_sb, &tgt_list);
202 if (rc != -EOPNOTSUPP) {
203 cifs_server_dbg(VFS, "%s: no target servers for DFS failover\n",
207 server->nr_targets = dfs_cache_get_nr_tgts(&tgt_list);
210 cifs_dbg(FYI, "%s: will retry %d target(s)\n", __func__,
212 spin_lock(&GlobalMid_Lock);
214 if (server->tcpStatus == CifsExiting) {
215 /* the demux thread will exit normally
216 next time through the loop */
217 spin_unlock(&GlobalMid_Lock);
218 #ifdef CONFIG_CIFS_DFS_UPCALL
219 dfs_cache_free_tgts(&tgt_list);
220 cifs_put_tcp_super(sb);
222 wake_up(&server->response_q);
225 server->tcpStatus = CifsNeedReconnect;
226 spin_unlock(&GlobalMid_Lock);
228 server->max_read = 0;
230 cifs_dbg(FYI, "Mark tcp session as need reconnect\n");
231 trace_smb3_reconnect(server->CurrentMid, server->conn_id, server->hostname);
233 /* before reconnecting the tcp session, mark the smb session (uid)
234 and the tid bad so they are not used until reconnected */
235 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
237 spin_lock(&cifs_tcp_ses_lock);
238 list_for_each(tmp, &server->smb_ses_list) {
239 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
240 ses->need_reconnect = true;
241 list_for_each(tmp2, &ses->tcon_list) {
242 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
243 tcon->need_reconnect = true;
246 ses->tcon_ipc->need_reconnect = true;
248 spin_unlock(&cifs_tcp_ses_lock);
250 /* do not want to be sending data on a socket we are freeing */
251 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
252 mutex_lock(&server->srv_mutex);
253 if (server->ssocket) {
254 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
255 server->ssocket->state, server->ssocket->flags);
256 kernel_sock_shutdown(server->ssocket, SHUT_WR);
257 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
258 server->ssocket->state, server->ssocket->flags);
259 sock_release(server->ssocket);
260 server->ssocket = NULL;
262 server->sequence_number = 0;
263 server->session_estab = false;
264 kfree(server->session_key.response);
265 server->session_key.response = NULL;
266 server->session_key.len = 0;
267 server->lstrp = jiffies;
269 /* mark submitted MIDs for retry and issue callback */
270 INIT_LIST_HEAD(&retry_list);
271 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
272 spin_lock(&GlobalMid_Lock);
273 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
274 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
275 kref_get(&mid_entry->refcount);
276 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
277 mid_entry->mid_state = MID_RETRY_NEEDED;
278 list_move(&mid_entry->qhead, &retry_list);
279 mid_entry->mid_flags |= MID_DELETED;
281 spin_unlock(&GlobalMid_Lock);
282 mutex_unlock(&server->srv_mutex);
284 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
285 list_for_each_safe(tmp, tmp2, &retry_list) {
286 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
287 list_del_init(&mid_entry->qhead);
288 mid_entry->callback(mid_entry);
289 cifs_mid_q_entry_release(mid_entry);
292 if (cifs_rdma_enabled(server)) {
293 mutex_lock(&server->srv_mutex);
294 smbd_destroy(server);
295 mutex_unlock(&server->srv_mutex);
301 mutex_lock(&server->srv_mutex);
304 if (!cifs_swn_set_server_dstaddr(server)) {
305 #ifdef CONFIG_CIFS_DFS_UPCALL
306 if (cifs_sb && cifs_sb->origin_fullpath)
308 * Set up next DFS target server (if any) for reconnect. If DFS
309 * feature is disabled, then we will retry last server we
310 * connected to before.
312 reconn_set_next_dfs_target(server, cifs_sb, &tgt_list, &tgt_it);
316 * Resolve the hostname again to make sure that IP address is up-to-date.
318 rc = reconn_set_ipaddr_from_hostname(server);
320 cifs_dbg(FYI, "%s: failed to resolve hostname: %d\n",
324 #ifdef CONFIG_CIFS_DFS_UPCALL
331 if (cifs_rdma_enabled(server))
332 rc = smbd_reconnect(server);
334 rc = generic_ip_connect(server);
336 cifs_dbg(FYI, "reconnect error %d\n", rc);
337 mutex_unlock(&server->srv_mutex);
340 atomic_inc(&tcpSesReconnectCount);
341 set_credits(server, 1);
342 spin_lock(&GlobalMid_Lock);
343 if (server->tcpStatus != CifsExiting)
344 server->tcpStatus = CifsNeedNegotiate;
345 spin_unlock(&GlobalMid_Lock);
346 cifs_swn_reset_server_dstaddr(server);
347 mutex_unlock(&server->srv_mutex);
349 } while (server->tcpStatus == CifsNeedReconnect);
351 #ifdef CONFIG_CIFS_DFS_UPCALL
353 rc = dfs_cache_noreq_update_tgthint(cifs_sb->origin_fullpath + 1,
356 cifs_server_dbg(VFS, "%s: failed to update DFS target hint: rc = %d\n",
359 dfs_cache_free_tgts(&tgt_list);
362 cifs_put_tcp_super(sb);
364 if (server->tcpStatus == CifsNeedNegotiate)
365 mod_delayed_work(cifsiod_wq, &server->echo, 0);
367 wake_up(&server->response_q);
372 cifs_echo_request(struct work_struct *work)
375 struct TCP_Server_Info *server = container_of(work,
376 struct TCP_Server_Info, echo.work);
379 * We cannot send an echo if it is disabled.
380 * Also, no need to ping if we got a response recently.
383 if (server->tcpStatus == CifsNeedReconnect ||
384 server->tcpStatus == CifsExiting ||
385 server->tcpStatus == CifsNew ||
386 (server->ops->can_echo && !server->ops->can_echo(server)) ||
387 time_before(jiffies, server->lstrp + server->echo_interval - HZ))
390 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
392 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
395 /* Check witness registrations */
399 queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
403 allocate_buffers(struct TCP_Server_Info *server)
405 if (!server->bigbuf) {
406 server->bigbuf = (char *)cifs_buf_get();
407 if (!server->bigbuf) {
408 cifs_server_dbg(VFS, "No memory for large SMB response\n");
410 /* retry will check if exiting */
413 } else if (server->large_buf) {
414 /* we are reusing a dirty large buf, clear its start */
415 memset(server->bigbuf, 0, HEADER_SIZE(server));
418 if (!server->smallbuf) {
419 server->smallbuf = (char *)cifs_small_buf_get();
420 if (!server->smallbuf) {
421 cifs_server_dbg(VFS, "No memory for SMB response\n");
423 /* retry will check if exiting */
426 /* beginning of smb buffer is cleared in our buf_get */
428 /* if existing small buf clear beginning */
429 memset(server->smallbuf, 0, HEADER_SIZE(server));
436 server_unresponsive(struct TCP_Server_Info *server)
439 * We need to wait 3 echo intervals to make sure we handle such
441 * 1s client sends a normal SMB request
442 * 2s client gets a response
443 * 30s echo workqueue job pops, and decides we got a response recently
444 * and don't need to send another
446 * 65s kernel_recvmsg times out, and we see that we haven't gotten
447 * a response in >60s.
449 if ((server->tcpStatus == CifsGood ||
450 server->tcpStatus == CifsNeedNegotiate) &&
451 (!server->ops->can_echo || server->ops->can_echo(server)) &&
452 time_after(jiffies, server->lstrp + 3 * server->echo_interval)) {
453 cifs_server_dbg(VFS, "has not responded in %lu seconds. Reconnecting...\n",
454 (3 * server->echo_interval) / HZ);
455 cifs_reconnect(server);
463 zero_credits(struct TCP_Server_Info *server)
467 spin_lock(&server->req_lock);
468 val = server->credits + server->echo_credits + server->oplock_credits;
469 if (server->in_flight == 0 && val == 0) {
470 spin_unlock(&server->req_lock);
473 spin_unlock(&server->req_lock);
478 cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
483 smb_msg->msg_control = NULL;
484 smb_msg->msg_controllen = 0;
486 for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
489 /* reconnect if no credits and no requests in flight */
490 if (zero_credits(server)) {
491 cifs_reconnect(server);
492 return -ECONNABORTED;
495 if (server_unresponsive(server))
496 return -ECONNABORTED;
497 if (cifs_rdma_enabled(server) && server->smbd_conn)
498 length = smbd_recv(server->smbd_conn, smb_msg);
500 length = sock_recvmsg(server->ssocket, smb_msg, 0);
502 if (server->tcpStatus == CifsExiting)
505 if (server->tcpStatus == CifsNeedReconnect) {
506 cifs_reconnect(server);
507 return -ECONNABORTED;
510 if (length == -ERESTARTSYS ||
514 * Minimum sleep to prevent looping, allowing socket
515 * to clear and app threads to set tcpStatus
516 * CifsNeedReconnect if server hung.
518 usleep_range(1000, 2000);
524 cifs_dbg(FYI, "Received no data or error: %d\n", length);
525 cifs_reconnect(server);
526 return -ECONNABORTED;
533 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
534 unsigned int to_read)
536 struct msghdr smb_msg;
537 struct kvec iov = {.iov_base = buf, .iov_len = to_read};
538 iov_iter_kvec(&smb_msg.msg_iter, READ, &iov, 1, to_read);
540 return cifs_readv_from_socket(server, &smb_msg);
544 cifs_discard_from_socket(struct TCP_Server_Info *server, size_t to_read)
546 struct msghdr smb_msg;
549 * iov_iter_discard already sets smb_msg.type and count and iov_offset
550 * and cifs_readv_from_socket sets msg_control and msg_controllen
551 * so little to initialize in struct msghdr
553 smb_msg.msg_name = NULL;
554 smb_msg.msg_namelen = 0;
555 iov_iter_discard(&smb_msg.msg_iter, READ, to_read);
557 return cifs_readv_from_socket(server, &smb_msg);
561 cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
562 unsigned int page_offset, unsigned int to_read)
564 struct msghdr smb_msg;
565 struct bio_vec bv = {
566 .bv_page = page, .bv_len = to_read, .bv_offset = page_offset};
567 iov_iter_bvec(&smb_msg.msg_iter, READ, &bv, 1, to_read);
568 return cifs_readv_from_socket(server, &smb_msg);
572 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
575 * The first byte big endian of the length field,
576 * is actually not part of the length but the type
577 * with the most common, zero, as regular data.
580 case RFC1002_SESSION_MESSAGE:
581 /* Regular SMB response */
583 case RFC1002_SESSION_KEEP_ALIVE:
584 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
586 case RFC1002_POSITIVE_SESSION_RESPONSE:
587 cifs_dbg(FYI, "RFC 1002 positive session response\n");
589 case RFC1002_NEGATIVE_SESSION_RESPONSE:
591 * We get this from Windows 98 instead of an error on
592 * SMB negprot response.
594 cifs_dbg(FYI, "RFC 1002 negative session response\n");
595 /* give server a second to clean up */
598 * Always try 445 first on reconnect since we get NACK
599 * on some if we ever connected to port 139 (the NACK
600 * is since we do not begin with RFC1001 session
603 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
604 cifs_reconnect(server);
607 cifs_server_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
608 cifs_reconnect(server);
615 dequeue_mid(struct mid_q_entry *mid, bool malformed)
617 #ifdef CONFIG_CIFS_STATS2
618 mid->when_received = jiffies;
620 spin_lock(&GlobalMid_Lock);
622 mid->mid_state = MID_RESPONSE_RECEIVED;
624 mid->mid_state = MID_RESPONSE_MALFORMED;
626 * Trying to handle/dequeue a mid after the send_recv()
627 * function has finished processing it is a bug.
629 if (mid->mid_flags & MID_DELETED)
630 pr_warn_once("trying to dequeue a deleted mid\n");
632 list_del_init(&mid->qhead);
633 mid->mid_flags |= MID_DELETED;
635 spin_unlock(&GlobalMid_Lock);
639 smb2_get_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
641 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
644 * SMB1 does not use credits.
646 if (server->vals->header_preamble_size)
649 return le16_to_cpu(shdr->CreditRequest);
653 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
654 char *buf, int malformed)
656 if (server->ops->check_trans2 &&
657 server->ops->check_trans2(mid, server, buf, malformed))
659 mid->credits_received = smb2_get_credits_from_hdr(buf, server);
661 mid->large_buf = server->large_buf;
662 /* Was previous buf put in mpx struct for multi-rsp? */
663 if (!mid->multiRsp) {
664 /* smb buffer will be freed by user thread */
665 if (server->large_buf)
666 server->bigbuf = NULL;
668 server->smallbuf = NULL;
670 dequeue_mid(mid, malformed);
673 static void clean_demultiplex_info(struct TCP_Server_Info *server)
677 /* take it off the list, if it's not already */
678 spin_lock(&cifs_tcp_ses_lock);
679 list_del_init(&server->tcp_ses_list);
680 spin_unlock(&cifs_tcp_ses_lock);
682 cancel_delayed_work_sync(&server->echo);
684 spin_lock(&GlobalMid_Lock);
685 server->tcpStatus = CifsExiting;
686 spin_unlock(&GlobalMid_Lock);
687 wake_up_all(&server->response_q);
689 /* check if we have blocked requests that need to free */
690 spin_lock(&server->req_lock);
691 if (server->credits <= 0)
693 spin_unlock(&server->req_lock);
695 * Although there should not be any requests blocked on this queue it
696 * can not hurt to be paranoid and try to wake up requests that may
697 * haven been blocked when more than 50 at time were on the wire to the
698 * same server - they now will see the session is in exit state and get
699 * out of SendReceive.
701 wake_up_all(&server->request_q);
702 /* give those requests time to exit */
704 if (cifs_rdma_enabled(server))
705 smbd_destroy(server);
706 if (server->ssocket) {
707 sock_release(server->ssocket);
708 server->ssocket = NULL;
711 if (!list_empty(&server->pending_mid_q)) {
712 struct list_head dispose_list;
713 struct mid_q_entry *mid_entry;
714 struct list_head *tmp, *tmp2;
716 INIT_LIST_HEAD(&dispose_list);
717 spin_lock(&GlobalMid_Lock);
718 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
719 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
720 cifs_dbg(FYI, "Clearing mid %llu\n", mid_entry->mid);
721 kref_get(&mid_entry->refcount);
722 mid_entry->mid_state = MID_SHUTDOWN;
723 list_move(&mid_entry->qhead, &dispose_list);
724 mid_entry->mid_flags |= MID_DELETED;
726 spin_unlock(&GlobalMid_Lock);
728 /* now walk dispose list and issue callbacks */
729 list_for_each_safe(tmp, tmp2, &dispose_list) {
730 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
731 cifs_dbg(FYI, "Callback mid %llu\n", mid_entry->mid);
732 list_del_init(&mid_entry->qhead);
733 mid_entry->callback(mid_entry);
734 cifs_mid_q_entry_release(mid_entry);
736 /* 1/8th of sec is more than enough time for them to exit */
740 if (!list_empty(&server->pending_mid_q)) {
742 * mpx threads have not exited yet give them at least the smb
743 * send timeout time for long ops.
745 * Due to delays on oplock break requests, we need to wait at
746 * least 45 seconds before giving up on a request getting a
747 * response and going ahead and killing cifsd.
749 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
752 * If threads still have not exited they are probably never
753 * coming home not much else we can do but free the memory.
757 kfree(server->hostname);
760 length = atomic_dec_return(&tcpSesAllocCount);
762 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
766 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
769 char *buf = server->smallbuf;
770 unsigned int pdu_length = server->pdu_size;
772 /* make sure this will fit in a large buffer */
773 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) -
774 server->vals->header_preamble_size) {
775 cifs_server_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
776 cifs_reconnect(server);
777 return -ECONNABORTED;
780 /* switch to large buffer if too big for a small one */
781 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
782 server->large_buf = true;
783 memcpy(server->bigbuf, buf, server->total_read);
784 buf = server->bigbuf;
787 /* now read the rest */
788 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
789 pdu_length - HEADER_SIZE(server) + 1
790 + server->vals->header_preamble_size);
794 server->total_read += length;
796 dump_smb(buf, server->total_read);
798 return cifs_handle_standard(server, mid);
802 cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
804 char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
808 * We know that we received enough to get to the MID as we
809 * checked the pdu_length earlier. Now check to see
810 * if the rest of the header is OK. We borrow the length
811 * var for the rest of the loop to avoid a new stack var.
813 * 48 bytes is enough to display the header and a little bit
814 * into the payload for debugging purposes.
816 length = server->ops->check_message(buf, server->total_read, server);
818 cifs_dump_mem("Bad SMB: ", buf,
819 min_t(unsigned int, server->total_read, 48));
821 if (server->ops->is_session_expired &&
822 server->ops->is_session_expired(buf)) {
823 cifs_reconnect(server);
827 if (server->ops->is_status_pending &&
828 server->ops->is_status_pending(buf, server))
834 handle_mid(mid, server, buf, length);
839 smb2_add_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
841 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
842 int scredits, in_flight;
845 * SMB1 does not use credits.
847 if (server->vals->header_preamble_size)
850 if (shdr->CreditRequest) {
851 spin_lock(&server->req_lock);
852 server->credits += le16_to_cpu(shdr->CreditRequest);
853 scredits = server->credits;
854 in_flight = server->in_flight;
855 spin_unlock(&server->req_lock);
856 wake_up(&server->request_q);
858 trace_smb3_add_credits(server->CurrentMid,
859 server->conn_id, server->hostname, scredits,
860 le16_to_cpu(shdr->CreditRequest), in_flight);
861 cifs_server_dbg(FYI, "%s: added %u credits total=%d\n",
862 __func__, le16_to_cpu(shdr->CreditRequest),
869 cifs_demultiplex_thread(void *p)
871 int i, num_mids, length;
872 struct TCP_Server_Info *server = p;
873 unsigned int pdu_length;
874 unsigned int next_offset;
876 struct task_struct *task_to_wake = NULL;
877 struct mid_q_entry *mids[MAX_COMPOUND];
878 char *bufs[MAX_COMPOUND];
879 unsigned int noreclaim_flag, num_io_timeout = 0;
881 noreclaim_flag = memalloc_noreclaim_save();
882 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
884 length = atomic_inc_return(&tcpSesAllocCount);
886 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
889 allow_kernel_signal(SIGKILL);
890 while (server->tcpStatus != CifsExiting) {
894 if (!allocate_buffers(server))
897 server->large_buf = false;
898 buf = server->smallbuf;
899 pdu_length = 4; /* enough to get RFC1001 header */
901 length = cifs_read_from_socket(server, buf, pdu_length);
905 if (server->vals->header_preamble_size == 0)
906 server->total_read = 0;
908 server->total_read = length;
911 * The right amount was read from socket - 4 bytes,
912 * so we can now interpret the length field.
914 pdu_length = get_rfc1002_length(buf);
916 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
917 if (!is_smb_response(server, buf[0]))
920 server->pdu_size = pdu_length;
922 /* make sure we have enough to get to the MID */
923 if (server->pdu_size < HEADER_SIZE(server) - 1 -
924 server->vals->header_preamble_size) {
925 cifs_server_dbg(VFS, "SMB response too short (%u bytes)\n",
927 cifs_reconnect(server);
931 /* read down to the MID */
932 length = cifs_read_from_socket(server,
933 buf + server->vals->header_preamble_size,
934 HEADER_SIZE(server) - 1
935 - server->vals->header_preamble_size);
938 server->total_read += length;
940 if (server->ops->next_header) {
941 next_offset = server->ops->next_header(buf);
943 server->pdu_size = next_offset;
946 memset(mids, 0, sizeof(mids));
947 memset(bufs, 0, sizeof(bufs));
950 if (server->ops->is_transform_hdr &&
951 server->ops->receive_transform &&
952 server->ops->is_transform_hdr(buf)) {
953 length = server->ops->receive_transform(server,
958 mids[0] = server->ops->find_mid(server, buf);
962 if (!mids[0] || !mids[0]->receive)
963 length = standard_receive3(server, mids[0]);
965 length = mids[0]->receive(server, mids[0]);
969 for (i = 0; i < num_mids; i++)
971 cifs_mid_q_entry_release(mids[i]);
975 if (server->ops->is_status_io_timeout &&
976 server->ops->is_status_io_timeout(buf)) {
978 if (num_io_timeout > NUM_STATUS_IO_TIMEOUT) {
979 cifs_reconnect(server);
985 server->lstrp = jiffies;
987 for (i = 0; i < num_mids; i++) {
988 if (mids[i] != NULL) {
989 mids[i]->resp_buf_size = server->pdu_size;
991 if (bufs[i] && server->ops->is_network_name_deleted)
992 server->ops->is_network_name_deleted(bufs[i],
995 if (!mids[i]->multiRsp || mids[i]->multiEnd)
996 mids[i]->callback(mids[i]);
998 cifs_mid_q_entry_release(mids[i]);
999 } else if (server->ops->is_oplock_break &&
1000 server->ops->is_oplock_break(bufs[i],
1002 smb2_add_credits_from_hdr(bufs[i], server);
1003 cifs_dbg(FYI, "Received oplock break\n");
1005 cifs_server_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
1006 atomic_read(&midCount));
1007 cifs_dump_mem("Received Data is: ", bufs[i],
1008 HEADER_SIZE(server));
1009 smb2_add_credits_from_hdr(bufs[i], server);
1010 #ifdef CONFIG_CIFS_DEBUG2
1011 if (server->ops->dump_detail)
1012 server->ops->dump_detail(bufs[i],
1014 cifs_dump_mids(server);
1015 #endif /* CIFS_DEBUG2 */
1019 if (pdu_length > server->pdu_size) {
1020 if (!allocate_buffers(server))
1022 pdu_length -= server->pdu_size;
1023 server->total_read = 0;
1024 server->large_buf = false;
1025 buf = server->smallbuf;
1028 } /* end while !EXITING */
1030 /* buffer usually freed in free_mid - need to free it here on exit */
1031 cifs_buf_release(server->bigbuf);
1032 if (server->smallbuf) /* no sense logging a debug message if NULL */
1033 cifs_small_buf_release(server->smallbuf);
1035 task_to_wake = xchg(&server->tsk, NULL);
1036 clean_demultiplex_info(server);
1038 /* if server->tsk was NULL then wait for a signal before exiting */
1039 if (!task_to_wake) {
1040 set_current_state(TASK_INTERRUPTIBLE);
1041 while (!signal_pending(current)) {
1043 set_current_state(TASK_INTERRUPTIBLE);
1045 set_current_state(TASK_RUNNING);
1048 memalloc_noreclaim_restore(noreclaim_flag);
1049 module_put_and_exit(0);
1053 * Returns true if srcaddr isn't specified and rhs isn't specified, or
1054 * if srcaddr is specified and matches the IP address of the rhs argument
1057 cifs_match_ipaddr(struct sockaddr *srcaddr, struct sockaddr *rhs)
1059 switch (srcaddr->sa_family) {
1061 return (rhs->sa_family == AF_UNSPEC);
1063 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1064 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1065 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1068 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1069 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1070 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1074 return false; /* don't expect to be here */
1079 * If no port is specified in addr structure, we try to match with 445 port
1080 * and if it fails - with 139 ports. It should be called only if address
1081 * families of server and addr are equal.
1084 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1086 __be16 port, *sport;
1088 /* SMBDirect manages its own ports, don't match it here */
1092 switch (addr->sa_family) {
1094 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1095 port = ((struct sockaddr_in *) addr)->sin_port;
1098 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1099 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1107 port = htons(CIFS_PORT);
1111 port = htons(RFC1001_PORT);
1114 return port == *sport;
1118 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1119 struct sockaddr *srcaddr)
1121 switch (addr->sa_family) {
1123 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1124 struct sockaddr_in *srv_addr4 =
1125 (struct sockaddr_in *)&server->dstaddr;
1127 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1132 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1133 struct sockaddr_in6 *srv_addr6 =
1134 (struct sockaddr_in6 *)&server->dstaddr;
1136 if (!ipv6_addr_equal(&addr6->sin6_addr,
1137 &srv_addr6->sin6_addr))
1139 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1145 return false; /* don't expect to be here */
1148 if (!cifs_match_ipaddr(srcaddr, (struct sockaddr *)&server->srcaddr))
1155 match_security(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
1158 * The select_sectype function should either return the ctx->sectype
1159 * that was specified, or "Unspecified" if that sectype was not
1160 * compatible with the given NEGOTIATE request.
1162 if (server->ops->select_sectype(server, ctx->sectype)
1167 * Now check if signing mode is acceptable. No need to check
1168 * global_secflags at this point since if MUST_SIGN is set then
1169 * the server->sign had better be too.
1171 if (ctx->sign && !server->sign)
1177 static int match_server(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
1179 struct sockaddr *addr = (struct sockaddr *)&ctx->dstaddr;
1181 if (ctx->nosharesock)
1184 /* If multidialect negotiation see if existing sessions match one */
1185 if (strcmp(ctx->vals->version_string, SMB3ANY_VERSION_STRING) == 0) {
1186 if (server->vals->protocol_id < SMB30_PROT_ID)
1188 } else if (strcmp(ctx->vals->version_string,
1189 SMBDEFAULT_VERSION_STRING) == 0) {
1190 if (server->vals->protocol_id < SMB21_PROT_ID)
1192 } else if ((server->vals != ctx->vals) || (server->ops != ctx->ops))
1195 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1198 if (!match_address(server, addr,
1199 (struct sockaddr *)&ctx->srcaddr))
1202 if (!match_port(server, addr))
1205 if (!match_security(server, ctx))
1208 if (server->echo_interval != ctx->echo_interval * HZ)
1211 if (server->rdma != ctx->rdma)
1214 if (server->ignore_signature != ctx->ignore_signature)
1217 if (server->min_offload != ctx->min_offload)
1223 struct TCP_Server_Info *
1224 cifs_find_tcp_session(struct smb3_fs_context *ctx)
1226 struct TCP_Server_Info *server;
1228 spin_lock(&cifs_tcp_ses_lock);
1229 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1231 * Skip ses channels since they're only handled in lower layers
1232 * (e.g. cifs_send_recv).
1234 if (server->is_channel || !match_server(server, ctx))
1237 ++server->srv_count;
1238 spin_unlock(&cifs_tcp_ses_lock);
1239 cifs_dbg(FYI, "Existing tcp session with server found\n");
1242 spin_unlock(&cifs_tcp_ses_lock);
1247 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
1249 struct task_struct *task;
1251 spin_lock(&cifs_tcp_ses_lock);
1252 if (--server->srv_count > 0) {
1253 spin_unlock(&cifs_tcp_ses_lock);
1257 put_net(cifs_net_ns(server));
1259 list_del_init(&server->tcp_ses_list);
1260 spin_unlock(&cifs_tcp_ses_lock);
1262 cancel_delayed_work_sync(&server->echo);
1266 * Avoid deadlock here: reconnect work calls
1267 * cifs_put_tcp_session() at its end. Need to be sure
1268 * that reconnect work does nothing with server pointer after
1271 cancel_delayed_work(&server->reconnect);
1273 cancel_delayed_work_sync(&server->reconnect);
1275 spin_lock(&GlobalMid_Lock);
1276 server->tcpStatus = CifsExiting;
1277 spin_unlock(&GlobalMid_Lock);
1279 cifs_crypto_secmech_release(server);
1280 cifs_fscache_release_client_cookie(server);
1282 kfree(server->session_key.response);
1283 server->session_key.response = NULL;
1284 server->session_key.len = 0;
1286 task = xchg(&server->tsk, NULL);
1288 send_sig(SIGKILL, task, 1);
1291 struct TCP_Server_Info *
1292 cifs_get_tcp_session(struct smb3_fs_context *ctx)
1294 struct TCP_Server_Info *tcp_ses = NULL;
1297 cifs_dbg(FYI, "UNC: %s\n", ctx->UNC);
1299 /* see if we already have a matching tcp_ses */
1300 tcp_ses = cifs_find_tcp_session(ctx);
1304 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1310 tcp_ses->ops = ctx->ops;
1311 tcp_ses->vals = ctx->vals;
1312 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
1313 tcp_ses->hostname = extract_hostname(ctx->UNC);
1314 if (IS_ERR(tcp_ses->hostname)) {
1315 rc = PTR_ERR(tcp_ses->hostname);
1316 goto out_err_crypto_release;
1319 tcp_ses->conn_id = atomic_inc_return(&tcpSesNextId);
1320 tcp_ses->noblockcnt = ctx->rootfs;
1321 tcp_ses->noblocksnd = ctx->noblocksnd || ctx->rootfs;
1322 tcp_ses->noautotune = ctx->noautotune;
1323 tcp_ses->tcp_nodelay = ctx->sockopt_tcp_nodelay;
1324 tcp_ses->rdma = ctx->rdma;
1325 tcp_ses->in_flight = 0;
1326 tcp_ses->max_in_flight = 0;
1327 tcp_ses->credits = 1;
1328 init_waitqueue_head(&tcp_ses->response_q);
1329 init_waitqueue_head(&tcp_ses->request_q);
1330 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1331 mutex_init(&tcp_ses->srv_mutex);
1332 memcpy(tcp_ses->workstation_RFC1001_name,
1333 ctx->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1334 memcpy(tcp_ses->server_RFC1001_name,
1335 ctx->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1336 tcp_ses->session_estab = false;
1337 tcp_ses->sequence_number = 0;
1338 tcp_ses->reconnect_instance = 1;
1339 tcp_ses->lstrp = jiffies;
1340 tcp_ses->compress_algorithm = cpu_to_le16(ctx->compression);
1341 spin_lock_init(&tcp_ses->req_lock);
1342 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1343 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1344 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
1345 INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
1346 mutex_init(&tcp_ses->reconnect_mutex);
1347 memcpy(&tcp_ses->srcaddr, &ctx->srcaddr,
1348 sizeof(tcp_ses->srcaddr));
1349 memcpy(&tcp_ses->dstaddr, &ctx->dstaddr,
1350 sizeof(tcp_ses->dstaddr));
1351 if (ctx->use_client_guid)
1352 memcpy(tcp_ses->client_guid, ctx->client_guid,
1353 SMB2_CLIENT_GUID_SIZE);
1355 generate_random_uuid(tcp_ses->client_guid);
1357 * at this point we are the only ones with the pointer
1358 * to the struct since the kernel thread not created yet
1359 * no need to spinlock this init of tcpStatus or srv_count
1361 tcp_ses->tcpStatus = CifsNew;
1362 ++tcp_ses->srv_count;
1364 if (ctx->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
1365 ctx->echo_interval <= SMB_ECHO_INTERVAL_MAX)
1366 tcp_ses->echo_interval = ctx->echo_interval * HZ;
1368 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
1369 if (tcp_ses->rdma) {
1370 #ifndef CONFIG_CIFS_SMB_DIRECT
1371 cifs_dbg(VFS, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
1373 goto out_err_crypto_release;
1375 tcp_ses->smbd_conn = smbd_get_connection(
1376 tcp_ses, (struct sockaddr *)&ctx->dstaddr);
1377 if (tcp_ses->smbd_conn) {
1378 cifs_dbg(VFS, "RDMA transport established\n");
1380 goto smbd_connected;
1383 goto out_err_crypto_release;
1386 rc = ip_connect(tcp_ses);
1388 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
1389 goto out_err_crypto_release;
1393 * since we're in a cifs function already, we know that
1394 * this will succeed. No need for try_module_get().
1396 __module_get(THIS_MODULE);
1397 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
1399 if (IS_ERR(tcp_ses->tsk)) {
1400 rc = PTR_ERR(tcp_ses->tsk);
1401 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
1402 module_put(THIS_MODULE);
1403 goto out_err_crypto_release;
1405 tcp_ses->min_offload = ctx->min_offload;
1406 tcp_ses->tcpStatus = CifsNeedNegotiate;
1408 if ((ctx->max_credits < 20) || (ctx->max_credits > 60000))
1409 tcp_ses->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
1411 tcp_ses->max_credits = ctx->max_credits;
1413 tcp_ses->nr_targets = 1;
1414 tcp_ses->ignore_signature = ctx->ignore_signature;
1415 /* thread spawned, put it on the list */
1416 spin_lock(&cifs_tcp_ses_lock);
1417 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1418 spin_unlock(&cifs_tcp_ses_lock);
1420 cifs_fscache_get_client_cookie(tcp_ses);
1422 /* queue echo request delayed work */
1423 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
1427 out_err_crypto_release:
1428 cifs_crypto_secmech_release(tcp_ses);
1430 put_net(cifs_net_ns(tcp_ses));
1434 if (!IS_ERR(tcp_ses->hostname))
1435 kfree(tcp_ses->hostname);
1436 if (tcp_ses->ssocket)
1437 sock_release(tcp_ses->ssocket);
1443 static int match_session(struct cifs_ses *ses, struct smb3_fs_context *ctx)
1445 if (ctx->sectype != Unspecified &&
1446 ctx->sectype != ses->sectype)
1450 * If an existing session is limited to less channels than
1451 * requested, it should not be reused
1453 if (ses->chan_max < ctx->max_channels)
1456 switch (ses->sectype) {
1458 if (!uid_eq(ctx->cred_uid, ses->cred_uid))
1462 /* NULL username means anonymous session */
1463 if (ses->user_name == NULL) {
1469 /* anything else takes username/password */
1470 if (strncmp(ses->user_name,
1471 ctx->username ? ctx->username : "",
1472 CIFS_MAX_USERNAME_LEN))
1474 if ((ctx->username && strlen(ctx->username) != 0) &&
1475 ses->password != NULL &&
1476 strncmp(ses->password,
1477 ctx->password ? ctx->password : "",
1478 CIFS_MAX_PASSWORD_LEN))
1485 * cifs_setup_ipc - helper to setup the IPC tcon for the session
1487 * A new IPC connection is made and stored in the session
1488 * tcon_ipc. The IPC tcon has the same lifetime as the session.
1491 cifs_setup_ipc(struct cifs_ses *ses, struct smb3_fs_context *ctx)
1494 struct cifs_tcon *tcon;
1495 char unc[SERVER_NAME_LENGTH + sizeof("//x/IPC$")] = {0};
1497 struct TCP_Server_Info *server = ses->server;
1500 * If the mount request that resulted in the creation of the
1501 * session requires encryption, force IPC to be encrypted too.
1504 if (server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)
1507 cifs_server_dbg(VFS,
1508 "IPC: server doesn't support encryption\n");
1513 tcon = tconInfoAlloc();
1517 scnprintf(unc, sizeof(unc), "\\\\%s\\IPC$", server->hostname);
1523 rc = server->ops->tree_connect(xid, ses, unc, tcon, ctx->local_nls);
1527 cifs_server_dbg(VFS, "failed to connect to IPC (rc=%d)\n", rc);
1532 cifs_dbg(FYI, "IPC tcon rc = %d ipc tid = %d\n", rc, tcon->tid);
1534 ses->tcon_ipc = tcon;
1540 * cifs_free_ipc - helper to release the session IPC tcon
1542 * Needs to be called everytime a session is destroyed.
1544 * On session close, the IPC is closed and the server must release all tcons of the session.
1545 * No need to send a tree disconnect here.
1547 * Besides, it will make the server to not close durable and resilient files on session close, as
1548 * specified in MS-SMB2 3.3.5.6 Receiving an SMB2 LOGOFF Request.
1551 cifs_free_ipc(struct cifs_ses *ses)
1553 struct cifs_tcon *tcon = ses->tcon_ipc;
1559 ses->tcon_ipc = NULL;
1563 static struct cifs_ses *
1564 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
1566 struct cifs_ses *ses;
1568 spin_lock(&cifs_tcp_ses_lock);
1569 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1570 if (ses->status == CifsExiting)
1572 if (!match_session(ses, ctx))
1575 spin_unlock(&cifs_tcp_ses_lock);
1578 spin_unlock(&cifs_tcp_ses_lock);
1582 void cifs_put_smb_ses(struct cifs_ses *ses)
1584 unsigned int rc, xid;
1585 struct TCP_Server_Info *server = ses->server;
1586 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
1588 spin_lock(&cifs_tcp_ses_lock);
1589 if (ses->status == CifsExiting) {
1590 spin_unlock(&cifs_tcp_ses_lock);
1594 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
1595 cifs_dbg(FYI, "%s: ses ipc: %s\n", __func__, ses->tcon_ipc ? ses->tcon_ipc->treeName : "NONE");
1597 if (--ses->ses_count > 0) {
1598 spin_unlock(&cifs_tcp_ses_lock);
1601 if (ses->status == CifsGood)
1602 ses->status = CifsExiting;
1603 spin_unlock(&cifs_tcp_ses_lock);
1607 if (ses->status == CifsExiting && server->ops->logoff) {
1609 rc = server->ops->logoff(xid, ses);
1611 cifs_server_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
1616 spin_lock(&cifs_tcp_ses_lock);
1617 list_del_init(&ses->smb_ses_list);
1618 spin_unlock(&cifs_tcp_ses_lock);
1620 /* close any extra channels */
1621 if (ses->chan_count > 1) {
1624 for (i = 1; i < ses->chan_count; i++)
1625 cifs_put_tcp_session(ses->chans[i].server, 0);
1629 cifs_put_tcp_session(server, 0);
1634 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
1635 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
1637 /* Populate username and pw fields from keyring if possible */
1639 cifs_set_cifscreds(struct smb3_fs_context *ctx, struct cifs_ses *ses)
1643 const char *delim, *payload;
1647 struct TCP_Server_Info *server = ses->server;
1648 struct sockaddr_in *sa;
1649 struct sockaddr_in6 *sa6;
1650 const struct user_key_payload *upayload;
1652 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
1656 /* try to find an address key first */
1657 switch (server->dstaddr.ss_family) {
1659 sa = (struct sockaddr_in *)&server->dstaddr;
1660 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
1663 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
1664 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
1667 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
1668 server->dstaddr.ss_family);
1673 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
1674 key = request_key(&key_type_logon, desc, "");
1676 if (!ses->domainName) {
1677 cifs_dbg(FYI, "domainName is NULL\n");
1682 /* didn't work, try to find a domain key */
1683 sprintf(desc, "cifs:d:%s", ses->domainName);
1684 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
1685 key = request_key(&key_type_logon, desc, "");
1693 down_read(&key->sem);
1694 upayload = user_key_payload_locked(key);
1695 if (IS_ERR_OR_NULL(upayload)) {
1696 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
1700 /* find first : in payload */
1701 payload = upayload->data;
1702 delim = strnchr(payload, upayload->datalen, ':');
1703 cifs_dbg(FYI, "payload=%s\n", payload);
1705 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
1711 len = delim - payload;
1712 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
1713 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
1719 ctx->username = kstrndup(payload, len, GFP_KERNEL);
1720 if (!ctx->username) {
1721 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
1726 cifs_dbg(FYI, "%s: username=%s\n", __func__, ctx->username);
1728 len = key->datalen - (len + 1);
1729 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
1730 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
1732 kfree(ctx->username);
1733 ctx->username = NULL;
1738 ctx->password = kstrndup(delim, len, GFP_KERNEL);
1739 if (!ctx->password) {
1740 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
1743 kfree(ctx->username);
1744 ctx->username = NULL;
1749 * If we have a domain key then we must set the domainName in the
1752 if (is_domain && ses->domainName) {
1753 ctx->domainname = kstrdup(ses->domainName, GFP_KERNEL);
1754 if (!ctx->domainname) {
1755 cifs_dbg(FYI, "Unable to allocate %zd bytes for domain\n",
1758 kfree(ctx->username);
1759 ctx->username = NULL;
1760 kfree_sensitive(ctx->password);
1761 ctx->password = NULL;
1771 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
1774 #else /* ! CONFIG_KEYS */
1776 cifs_set_cifscreds(struct smb3_fs_context *ctx __attribute__((unused)),
1777 struct cifs_ses *ses __attribute__((unused)))
1781 #endif /* CONFIG_KEYS */
1784 * cifs_get_smb_ses - get a session matching @ctx data from @server
1786 * This function assumes it is being called from cifs_mount() where we
1787 * already got a server reference (server refcount +1). See
1788 * cifs_get_tcon() for refcount explanations.
1791 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
1795 struct cifs_ses *ses;
1796 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1797 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
1801 ses = cifs_find_smb_ses(server, ctx);
1803 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
1806 mutex_lock(&ses->session_mutex);
1807 rc = cifs_negotiate_protocol(xid, ses);
1809 mutex_unlock(&ses->session_mutex);
1810 /* problem -- put our ses reference */
1811 cifs_put_smb_ses(ses);
1815 if (ses->need_reconnect) {
1816 cifs_dbg(FYI, "Session needs reconnect\n");
1817 rc = cifs_setup_session(xid, ses,
1820 mutex_unlock(&ses->session_mutex);
1821 /* problem -- put our reference */
1822 cifs_put_smb_ses(ses);
1827 mutex_unlock(&ses->session_mutex);
1829 /* existing SMB ses has a server reference already */
1830 cifs_put_tcp_session(server, 0);
1835 cifs_dbg(FYI, "Existing smb sess not found\n");
1836 ses = sesInfoAlloc();
1840 /* new SMB session uses our server ref */
1841 ses->server = server;
1842 if (server->dstaddr.ss_family == AF_INET6)
1843 sprintf(ses->ip_addr, "%pI6", &addr6->sin6_addr);
1845 sprintf(ses->ip_addr, "%pI4", &addr->sin_addr);
1847 if (ctx->username) {
1848 ses->user_name = kstrdup(ctx->username, GFP_KERNEL);
1849 if (!ses->user_name)
1853 /* ctx->password freed at unmount */
1854 if (ctx->password) {
1855 ses->password = kstrdup(ctx->password, GFP_KERNEL);
1859 if (ctx->domainname) {
1860 ses->domainName = kstrdup(ctx->domainname, GFP_KERNEL);
1861 if (!ses->domainName)
1864 if (ctx->domainauto)
1865 ses->domainAuto = ctx->domainauto;
1866 ses->cred_uid = ctx->cred_uid;
1867 ses->linux_uid = ctx->linux_uid;
1869 ses->sectype = ctx->sectype;
1870 ses->sign = ctx->sign;
1871 mutex_lock(&ses->session_mutex);
1873 /* add server as first channel */
1874 ses->chans[0].server = server;
1875 ses->chan_count = 1;
1876 ses->chan_max = ctx->multichannel ? ctx->max_channels:1;
1878 rc = cifs_negotiate_protocol(xid, ses);
1880 rc = cifs_setup_session(xid, ses, ctx->local_nls);
1882 /* each channel uses a different signing key */
1883 memcpy(ses->chans[0].signkey, ses->smb3signingkey,
1884 sizeof(ses->smb3signingkey));
1886 mutex_unlock(&ses->session_mutex);
1890 /* success, put it on the list and add it as first channel */
1891 spin_lock(&cifs_tcp_ses_lock);
1892 list_add(&ses->smb_ses_list, &server->smb_ses_list);
1893 spin_unlock(&cifs_tcp_ses_lock);
1897 cifs_setup_ipc(ses, ctx);
1907 static int match_tcon(struct cifs_tcon *tcon, struct smb3_fs_context *ctx)
1909 if (tcon->tidStatus == CifsExiting)
1911 if (strncmp(tcon->treeName, ctx->UNC, MAX_TREE_SIZE))
1913 if (tcon->seal != ctx->seal)
1915 if (tcon->snapshot_time != ctx->snapshot_time)
1917 if (tcon->handle_timeout != ctx->handle_timeout)
1919 if (tcon->no_lease != ctx->no_lease)
1921 if (tcon->nodelete != ctx->nodelete)
1926 static struct cifs_tcon *
1927 cifs_find_tcon(struct cifs_ses *ses, struct smb3_fs_context *ctx)
1929 struct list_head *tmp;
1930 struct cifs_tcon *tcon;
1932 spin_lock(&cifs_tcp_ses_lock);
1933 list_for_each(tmp, &ses->tcon_list) {
1934 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
1936 if (!match_tcon(tcon, ctx))
1939 spin_unlock(&cifs_tcp_ses_lock);
1942 spin_unlock(&cifs_tcp_ses_lock);
1947 cifs_put_tcon(struct cifs_tcon *tcon)
1950 struct cifs_ses *ses;
1953 * IPC tcon share the lifetime of their session and are
1954 * destroyed in the session put function
1956 if (tcon == NULL || tcon->ipc)
1960 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
1961 spin_lock(&cifs_tcp_ses_lock);
1962 if (--tcon->tc_count > 0) {
1963 spin_unlock(&cifs_tcp_ses_lock);
1967 if (tcon->use_witness) {
1970 rc = cifs_swn_unregister(tcon);
1972 cifs_dbg(VFS, "%s: Failed to unregister for witness notifications: %d\n",
1977 list_del_init(&tcon->tcon_list);
1978 spin_unlock(&cifs_tcp_ses_lock);
1981 if (ses->server->ops->tree_disconnect)
1982 ses->server->ops->tree_disconnect(xid, tcon);
1985 cifs_fscache_release_super_cookie(tcon);
1987 cifs_put_smb_ses(ses);
1991 * cifs_get_tcon - get a tcon matching @ctx data from @ses
1993 * - tcon refcount is the number of mount points using the tcon.
1994 * - ses refcount is the number of tcon using the session.
1996 * 1. This function assumes it is being called from cifs_mount() where
1997 * we already got a session reference (ses refcount +1).
1999 * 2. Since we're in the context of adding a mount point, the end
2000 * result should be either:
2002 * a) a new tcon already allocated with refcount=1 (1 mount point) and
2003 * its session refcount incremented (1 new tcon). This +1 was
2004 * already done in (1).
2006 * b) an existing tcon with refcount+1 (add a mount point to it) and
2007 * identical ses refcount (no new tcon). Because of (1) we need to
2008 * decrement the ses refcount.
2010 static struct cifs_tcon *
2011 cifs_get_tcon(struct cifs_ses *ses, struct smb3_fs_context *ctx)
2014 struct cifs_tcon *tcon;
2016 tcon = cifs_find_tcon(ses, ctx);
2019 * tcon has refcount already incremented but we need to
2020 * decrement extra ses reference gotten by caller (case b)
2022 cifs_dbg(FYI, "Found match on UNC path\n");
2023 cifs_put_smb_ses(ses);
2027 if (!ses->server->ops->tree_connect) {
2032 tcon = tconInfoAlloc();
2038 if (ctx->snapshot_time) {
2039 if (ses->server->vals->protocol_id == 0) {
2041 "Use SMB2 or later for snapshot mount option\n");
2045 tcon->snapshot_time = ctx->snapshot_time;
2048 if (ctx->handle_timeout) {
2049 if (ses->server->vals->protocol_id == 0) {
2051 "Use SMB2.1 or later for handle timeout option\n");
2055 tcon->handle_timeout = ctx->handle_timeout;
2059 if (ctx->password) {
2060 tcon->password = kstrdup(ctx->password, GFP_KERNEL);
2061 if (!tcon->password) {
2068 if (ses->server->vals->protocol_id == 0) {
2070 "SMB3 or later required for encryption\n");
2073 } else if (tcon->ses->server->capabilities &
2074 SMB2_GLOBAL_CAP_ENCRYPTION)
2077 cifs_dbg(VFS, "Encryption is not supported on share\n");
2083 if (ctx->linux_ext) {
2084 if (ses->server->posix_ext_supported) {
2085 tcon->posix_extensions = true;
2086 pr_warn_once("SMB3.11 POSIX Extensions are experimental\n");
2088 cifs_dbg(VFS, "Server does not support mounting with posix SMB3.11 extensions\n");
2095 * BB Do we need to wrap session_mutex around this TCon call and Unix
2096 * SetFS as we do on SessSetup and reconnect?
2099 rc = ses->server->ops->tree_connect(xid, ses, ctx->UNC, tcon,
2102 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2106 tcon->use_persistent = false;
2107 /* check if SMB2 or later, CIFS does not support persistent handles */
2108 if (ctx->persistent) {
2109 if (ses->server->vals->protocol_id == 0) {
2111 "SMB3 or later required for persistent handles\n");
2114 } else if (ses->server->capabilities &
2115 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2116 tcon->use_persistent = true;
2117 else /* persistent handles requested but not supported */ {
2119 "Persistent handles not supported on share\n");
2123 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2124 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2125 && (ctx->nopersistent == false)) {
2126 cifs_dbg(FYI, "enabling persistent handles\n");
2127 tcon->use_persistent = true;
2128 } else if (ctx->resilient) {
2129 if (ses->server->vals->protocol_id == 0) {
2131 "SMB2.1 or later required for resilient handles\n");
2135 tcon->use_resilient = true;
2138 tcon->use_witness = false;
2139 if (IS_ENABLED(CONFIG_CIFS_SWN_UPCALL) && ctx->witness) {
2140 if (ses->server->vals->protocol_id >= SMB30_PROT_ID) {
2141 if (tcon->capabilities & SMB2_SHARE_CAP_CLUSTER) {
2143 * Set witness in use flag in first place
2144 * to retry registration in the echo task
2146 tcon->use_witness = true;
2147 /* And try to register immediately */
2148 rc = cifs_swn_register(tcon);
2150 cifs_dbg(VFS, "Failed to register for witness notifications: %d\n", rc);
2154 /* TODO: try to extend for non-cluster uses (eg multichannel) */
2155 cifs_dbg(VFS, "witness requested on mount but no CLUSTER capability on share\n");
2160 cifs_dbg(VFS, "SMB3 or later required for witness option\n");
2166 /* If the user really knows what they are doing they can override */
2167 if (tcon->share_flags & SMB2_SHAREFLAG_NO_CACHING) {
2169 cifs_dbg(VFS, "cache=ro requested on mount but NO_CACHING flag set on share\n");
2170 else if (ctx->cache_rw)
2171 cifs_dbg(VFS, "cache=singleclient requested on mount but NO_CACHING flag set on share\n");
2174 if (ctx->no_lease) {
2175 if (ses->server->vals->protocol_id == 0) {
2177 "SMB2 or later required for nolease option\n");
2181 tcon->no_lease = ctx->no_lease;
2185 * We can have only one retry value for a connection to a share so for
2186 * resources mounted more than once to the same server share the last
2187 * value passed in for the retry flag is used.
2189 tcon->retry = ctx->retry;
2190 tcon->nocase = ctx->nocase;
2191 if (ses->server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING)
2192 tcon->nohandlecache = ctx->nohandlecache;
2194 tcon->nohandlecache = true;
2195 tcon->nodelete = ctx->nodelete;
2196 tcon->local_lease = ctx->local_lease;
2197 INIT_LIST_HEAD(&tcon->pending_opens);
2199 spin_lock(&cifs_tcp_ses_lock);
2200 list_add(&tcon->tcon_list, &ses->tcon_list);
2201 spin_unlock(&cifs_tcp_ses_lock);
2203 cifs_fscache_get_super_cookie(tcon);
2213 cifs_put_tlink(struct tcon_link *tlink)
2215 if (!tlink || IS_ERR(tlink))
2218 if (!atomic_dec_and_test(&tlink->tl_count) ||
2219 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2220 tlink->tl_time = jiffies;
2224 if (!IS_ERR(tlink_tcon(tlink)))
2225 cifs_put_tcon(tlink_tcon(tlink));
2231 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2233 struct cifs_sb_info *old = CIFS_SB(sb);
2234 struct cifs_sb_info *new = mnt_data->cifs_sb;
2235 unsigned int oldflags = old->mnt_cifs_flags & CIFS_MOUNT_MASK;
2236 unsigned int newflags = new->mnt_cifs_flags & CIFS_MOUNT_MASK;
2238 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2241 if (old->mnt_cifs_serverino_autodisabled)
2242 newflags &= ~CIFS_MOUNT_SERVER_INUM;
2244 if (oldflags != newflags)
2248 * We want to share sb only if we don't specify an r/wsize or
2249 * specified r/wsize is greater than or equal to existing one.
2251 if (new->ctx->wsize && new->ctx->wsize < old->ctx->wsize)
2254 if (new->ctx->rsize && new->ctx->rsize < old->ctx->rsize)
2257 if (!uid_eq(old->ctx->linux_uid, new->ctx->linux_uid) ||
2258 !gid_eq(old->ctx->linux_gid, new->ctx->linux_gid))
2261 if (old->ctx->file_mode != new->ctx->file_mode ||
2262 old->ctx->dir_mode != new->ctx->dir_mode)
2265 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2268 if (old->ctx->acregmax != new->ctx->acregmax)
2270 if (old->ctx->acdirmax != new->ctx->acdirmax)
2277 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2279 struct cifs_sb_info *old = CIFS_SB(sb);
2280 struct cifs_sb_info *new = mnt_data->cifs_sb;
2281 bool old_set = (old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
2283 bool new_set = (new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
2286 if (old_set && new_set && !strcmp(new->prepath, old->prepath))
2288 else if (!old_set && !new_set)
2295 cifs_match_super(struct super_block *sb, void *data)
2297 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2298 struct smb3_fs_context *ctx;
2299 struct cifs_sb_info *cifs_sb;
2300 struct TCP_Server_Info *tcp_srv;
2301 struct cifs_ses *ses;
2302 struct cifs_tcon *tcon;
2303 struct tcon_link *tlink;
2306 spin_lock(&cifs_tcp_ses_lock);
2307 cifs_sb = CIFS_SB(sb);
2308 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2309 if (IS_ERR(tlink)) {
2310 spin_unlock(&cifs_tcp_ses_lock);
2313 tcon = tlink_tcon(tlink);
2315 tcp_srv = ses->server;
2317 ctx = mnt_data->ctx;
2319 if (!match_server(tcp_srv, ctx) ||
2320 !match_session(ses, ctx) ||
2321 !match_tcon(tcon, ctx) ||
2322 !match_prepath(sb, mnt_data)) {
2327 rc = compare_mount_options(sb, mnt_data);
2329 spin_unlock(&cifs_tcp_ses_lock);
2330 cifs_put_tlink(tlink);
2334 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2335 static struct lock_class_key cifs_key[2];
2336 static struct lock_class_key cifs_slock_key[2];
2339 cifs_reclassify_socket4(struct socket *sock)
2341 struct sock *sk = sock->sk;
2342 BUG_ON(!sock_allow_reclassification(sk));
2343 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2344 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2348 cifs_reclassify_socket6(struct socket *sock)
2350 struct sock *sk = sock->sk;
2351 BUG_ON(!sock_allow_reclassification(sk));
2352 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2353 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2357 cifs_reclassify_socket4(struct socket *sock)
2362 cifs_reclassify_socket6(struct socket *sock)
2367 /* See RFC1001 section 14 on representation of Netbios names */
2368 static void rfc1002mangle(char *target, char *source, unsigned int length)
2372 for (i = 0, j = 0; i < (length); i++) {
2373 /* mask a nibble at a time and encode */
2374 target[j] = 'A' + (0x0F & (source[i] >> 4));
2375 target[j+1] = 'A' + (0x0F & source[i]);
2382 bind_socket(struct TCP_Server_Info *server)
2385 if (server->srcaddr.ss_family != AF_UNSPEC) {
2386 /* Bind to the specified local IP address */
2387 struct socket *socket = server->ssocket;
2388 rc = socket->ops->bind(socket,
2389 (struct sockaddr *) &server->srcaddr,
2390 sizeof(server->srcaddr));
2392 struct sockaddr_in *saddr4;
2393 struct sockaddr_in6 *saddr6;
2394 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2395 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2396 if (saddr6->sin6_family == AF_INET6)
2397 cifs_server_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2398 &saddr6->sin6_addr, rc);
2400 cifs_server_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2401 &saddr4->sin_addr.s_addr, rc);
2408 ip_rfc1001_connect(struct TCP_Server_Info *server)
2412 * some servers require RFC1001 sessinit before sending
2413 * negprot - BB check reconnection in case where second
2414 * sessinit is sent but no second negprot
2416 struct rfc1002_session_packet *ses_init_buf;
2417 struct smb_hdr *smb_buf;
2418 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2421 ses_init_buf->trailer.session_req.called_len = 32;
2423 if (server->server_RFC1001_name[0] != 0)
2424 rfc1002mangle(ses_init_buf->trailer.
2425 session_req.called_name,
2426 server->server_RFC1001_name,
2427 RFC1001_NAME_LEN_WITH_NULL);
2429 rfc1002mangle(ses_init_buf->trailer.
2430 session_req.called_name,
2431 DEFAULT_CIFS_CALLED_NAME,
2432 RFC1001_NAME_LEN_WITH_NULL);
2434 ses_init_buf->trailer.session_req.calling_len = 32;
2437 * calling name ends in null (byte 16) from old smb
2440 if (server->workstation_RFC1001_name[0] != 0)
2441 rfc1002mangle(ses_init_buf->trailer.
2442 session_req.calling_name,
2443 server->workstation_RFC1001_name,
2444 RFC1001_NAME_LEN_WITH_NULL);
2446 rfc1002mangle(ses_init_buf->trailer.
2447 session_req.calling_name,
2449 RFC1001_NAME_LEN_WITH_NULL);
2451 ses_init_buf->trailer.session_req.scope1 = 0;
2452 ses_init_buf->trailer.session_req.scope2 = 0;
2453 smb_buf = (struct smb_hdr *)ses_init_buf;
2455 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2456 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2457 rc = smb_send(server, smb_buf, 0x44);
2458 kfree(ses_init_buf);
2460 * RFC1001 layer in at least one server
2461 * requires very short break before negprot
2462 * presumably because not expecting negprot
2463 * to follow so fast. This is a simple
2464 * solution that works without
2465 * complicating the code and causes no
2466 * significant slowing down on mount
2469 usleep_range(1000, 2000);
2472 * else the negprot may still work without this
2473 * even though malloc failed
2480 generic_ip_connect(struct TCP_Server_Info *server)
2485 struct socket *socket = server->ssocket;
2486 struct sockaddr *saddr;
2488 saddr = (struct sockaddr *) &server->dstaddr;
2490 if (server->dstaddr.ss_family == AF_INET6) {
2491 struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)&server->dstaddr;
2493 sport = ipv6->sin6_port;
2494 slen = sizeof(struct sockaddr_in6);
2496 cifs_dbg(FYI, "%s: connecting to [%pI6]:%d\n", __func__, &ipv6->sin6_addr,
2499 struct sockaddr_in *ipv4 = (struct sockaddr_in *)&server->dstaddr;
2501 sport = ipv4->sin_port;
2502 slen = sizeof(struct sockaddr_in);
2504 cifs_dbg(FYI, "%s: connecting to %pI4:%d\n", __func__, &ipv4->sin_addr,
2508 if (socket == NULL) {
2509 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2510 IPPROTO_TCP, &socket, 1);
2512 cifs_server_dbg(VFS, "Error %d creating socket\n", rc);
2513 server->ssocket = NULL;
2517 /* BB other socket options to set KEEPALIVE, NODELAY? */
2518 cifs_dbg(FYI, "Socket created\n");
2519 server->ssocket = socket;
2520 socket->sk->sk_allocation = GFP_NOFS;
2521 if (sfamily == AF_INET6)
2522 cifs_reclassify_socket6(socket);
2524 cifs_reclassify_socket4(socket);
2527 rc = bind_socket(server);
2532 * Eventually check for other socket options to change from
2533 * the default. sock_setsockopt not used because it expects
2536 socket->sk->sk_rcvtimeo = 7 * HZ;
2537 socket->sk->sk_sndtimeo = 5 * HZ;
2539 /* make the bufsizes depend on wsize/rsize and max requests */
2540 if (server->noautotune) {
2541 if (socket->sk->sk_sndbuf < (200 * 1024))
2542 socket->sk->sk_sndbuf = 200 * 1024;
2543 if (socket->sk->sk_rcvbuf < (140 * 1024))
2544 socket->sk->sk_rcvbuf = 140 * 1024;
2547 if (server->tcp_nodelay)
2548 tcp_sock_set_nodelay(socket->sk);
2550 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
2551 socket->sk->sk_sndbuf,
2552 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2554 rc = socket->ops->connect(socket, saddr, slen,
2555 server->noblockcnt ? O_NONBLOCK : 0);
2557 * When mounting SMB root file systems, we do not want to block in
2558 * connect. Otherwise bail out and then let cifs_reconnect() perform
2559 * reconnect failover - if possible.
2561 if (server->noblockcnt && rc == -EINPROGRESS)
2564 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
2565 sock_release(socket);
2566 server->ssocket = NULL;
2570 if (sport == htons(RFC1001_PORT))
2571 rc = ip_rfc1001_connect(server);
2577 ip_connect(struct TCP_Server_Info *server)
2580 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2581 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2583 if (server->dstaddr.ss_family == AF_INET6)
2584 sport = &addr6->sin6_port;
2586 sport = &addr->sin_port;
2591 /* try with 445 port at first */
2592 *sport = htons(CIFS_PORT);
2594 rc = generic_ip_connect(server);
2598 /* if it failed, try with 139 port */
2599 *sport = htons(RFC1001_PORT);
2602 return generic_ip_connect(server);
2605 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
2606 struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx)
2609 * If we are reconnecting then should we check to see if
2610 * any requested capabilities changed locally e.g. via
2611 * remount but we can not do much about it here
2612 * if they have (even if we could detect it by the following)
2613 * Perhaps we could add a backpointer to array of sb from tcon
2614 * or if we change to make all sb to same share the same
2615 * sb as NFS - then we only have one backpointer to sb.
2616 * What if we wanted to mount the server share twice once with
2617 * and once without posixacls or posix paths?
2619 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2621 if (ctx && ctx->no_linux_ext) {
2622 tcon->fsUnixInfo.Capability = 0;
2623 tcon->unix_ext = 0; /* Unix Extensions disabled */
2624 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
2627 tcon->unix_ext = 1; /* Unix Extensions supported */
2629 if (!tcon->unix_ext) {
2630 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
2634 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2635 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2636 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
2638 * check for reconnect case in which we do not
2639 * want to change the mount behavior if we can avoid it
2643 * turn off POSIX ACL and PATHNAMES if not set
2644 * originally at mount time
2646 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2647 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2648 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2649 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2650 cifs_dbg(VFS, "POSIXPATH support change\n");
2651 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2652 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2653 cifs_dbg(VFS, "possible reconnect error\n");
2654 cifs_dbg(VFS, "server disabled POSIX path support\n");
2658 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2659 cifs_dbg(VFS, "per-share encryption not supported yet\n");
2661 cap &= CIFS_UNIX_CAP_MASK;
2662 if (ctx && ctx->no_psx_acl)
2663 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2664 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2665 cifs_dbg(FYI, "negotiated posix acl support\n");
2667 cifs_sb->mnt_cifs_flags |=
2668 CIFS_MOUNT_POSIXACL;
2671 if (ctx && ctx->posix_paths == 0)
2672 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2673 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2674 cifs_dbg(FYI, "negotiate posix pathnames\n");
2676 cifs_sb->mnt_cifs_flags |=
2677 CIFS_MOUNT_POSIX_PATHS;
2680 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
2681 #ifdef CONFIG_CIFS_DEBUG2
2682 if (cap & CIFS_UNIX_FCNTL_CAP)
2683 cifs_dbg(FYI, "FCNTL cap\n");
2684 if (cap & CIFS_UNIX_EXTATTR_CAP)
2685 cifs_dbg(FYI, "EXTATTR cap\n");
2686 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2687 cifs_dbg(FYI, "POSIX path cap\n");
2688 if (cap & CIFS_UNIX_XATTR_CAP)
2689 cifs_dbg(FYI, "XATTR cap\n");
2690 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2691 cifs_dbg(FYI, "POSIX ACL cap\n");
2692 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2693 cifs_dbg(FYI, "very large read cap\n");
2694 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2695 cifs_dbg(FYI, "very large write cap\n");
2696 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
2697 cifs_dbg(FYI, "transport encryption cap\n");
2698 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2699 cifs_dbg(FYI, "mandatory transport encryption cap\n");
2700 #endif /* CIFS_DEBUG2 */
2701 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2703 cifs_dbg(FYI, "resetting capabilities failed\n");
2705 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");
2711 int cifs_setup_cifs_sb(struct cifs_sb_info *cifs_sb)
2713 struct smb3_fs_context *ctx = cifs_sb->ctx;
2715 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2717 spin_lock_init(&cifs_sb->tlink_tree_lock);
2718 cifs_sb->tlink_tree = RB_ROOT;
2720 cifs_dbg(FYI, "file mode: %04ho dir mode: %04ho\n",
2721 ctx->file_mode, ctx->dir_mode);
2723 /* this is needed for ASCII cp to Unicode converts */
2724 if (ctx->iocharset == NULL) {
2725 /* load_nls_default cannot return null */
2726 cifs_sb->local_nls = load_nls_default();
2728 cifs_sb->local_nls = load_nls(ctx->iocharset);
2729 if (cifs_sb->local_nls == NULL) {
2730 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
2735 ctx->local_nls = cifs_sb->local_nls;
2737 smb3_update_mnt_flags(cifs_sb);
2740 cifs_dbg(FYI, "mounting share using direct i/o\n");
2741 if (ctx->cache_ro) {
2742 cifs_dbg(VFS, "mounting share with read only caching. Ensure that the share will not be modified while in use.\n");
2743 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RO_CACHE;
2744 } else if (ctx->cache_rw) {
2745 cifs_dbg(VFS, "mounting share in single client RW caching mode. Ensure that no other systems will be accessing the share.\n");
2746 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_RO_CACHE |
2747 CIFS_MOUNT_RW_CACHE);
2750 if ((ctx->cifs_acl) && (ctx->dynperm))
2751 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
2754 cifs_sb->prepath = kstrdup(ctx->prepath, GFP_KERNEL);
2755 if (cifs_sb->prepath == NULL)
2757 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
2763 /* Release all succeed connections */
2764 static inline void mount_put_conns(struct cifs_sb_info *cifs_sb,
2766 struct TCP_Server_Info *server,
2767 struct cifs_ses *ses, struct cifs_tcon *tcon)
2772 cifs_put_tcon(tcon);
2774 cifs_put_smb_ses(ses);
2776 cifs_put_tcp_session(server, 0);
2777 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
2781 /* Get connections for tcp, ses and tcon */
2782 static int mount_get_conns(struct smb3_fs_context *ctx, struct cifs_sb_info *cifs_sb,
2784 struct TCP_Server_Info **nserver,
2785 struct cifs_ses **nses, struct cifs_tcon **ntcon)
2788 struct TCP_Server_Info *server;
2789 struct cifs_ses *ses;
2790 struct cifs_tcon *tcon;
2798 /* get a reference to a tcp session */
2799 server = cifs_get_tcp_session(ctx);
2800 if (IS_ERR(server)) {
2801 rc = PTR_ERR(server);
2807 /* get a reference to a SMB session */
2808 ses = cifs_get_smb_ses(server, ctx);
2816 if ((ctx->persistent == true) && (!(ses->server->capabilities &
2817 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES))) {
2818 cifs_server_dbg(VFS, "persistent handles not supported by server\n");
2822 /* search for existing tcon to this server share */
2823 tcon = cifs_get_tcon(ses, ctx);
2831 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
2832 if (tcon->posix_extensions)
2833 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
2835 /* tell server which Unix caps we support */
2836 if (cap_unix(tcon->ses)) {
2838 * reset of caps checks mount to see if unix extensions disabled
2839 * for just this mount.
2841 reset_cifs_unix_caps(*xid, tcon, cifs_sb, ctx);
2842 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
2843 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
2844 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP))
2847 tcon->unix_ext = 0; /* server does not support them */
2849 /* do not care if a following call succeed - informational */
2850 if (!tcon->pipe && server->ops->qfs_tcon) {
2851 server->ops->qfs_tcon(*xid, tcon, cifs_sb);
2852 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE) {
2853 if (tcon->fsDevInfo.DeviceCharacteristics &
2854 cpu_to_le32(FILE_READ_ONLY_DEVICE))
2855 cifs_dbg(VFS, "mounted to read only share\n");
2856 else if ((cifs_sb->mnt_cifs_flags &
2857 CIFS_MOUNT_RW_CACHE) == 0)
2858 cifs_dbg(VFS, "read only mount of RW share\n");
2859 /* no need to log a RW mount of a typical RW share */
2864 * Clamp the rsize/wsize mount arguments if they are too big for the server
2865 * and set the rsize/wsize to the negotiated values if not passed in by
2868 if ((cifs_sb->ctx->wsize == 0) ||
2869 (cifs_sb->ctx->wsize > server->ops->negotiate_wsize(tcon, ctx)))
2870 cifs_sb->ctx->wsize = server->ops->negotiate_wsize(tcon, ctx);
2871 if ((cifs_sb->ctx->rsize == 0) ||
2872 (cifs_sb->ctx->rsize > server->ops->negotiate_rsize(tcon, ctx)))
2873 cifs_sb->ctx->rsize = server->ops->negotiate_rsize(tcon, ctx);
2878 static int mount_setup_tlink(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
2879 struct cifs_tcon *tcon)
2881 struct tcon_link *tlink;
2883 /* hang the tcon off of the superblock */
2884 tlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
2888 tlink->tl_uid = ses->linux_uid;
2889 tlink->tl_tcon = tcon;
2890 tlink->tl_time = jiffies;
2891 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
2892 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
2894 cifs_sb->master_tlink = tlink;
2895 spin_lock(&cifs_sb->tlink_tree_lock);
2896 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
2897 spin_unlock(&cifs_sb->tlink_tree_lock);
2899 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
2904 #ifdef CONFIG_CIFS_DFS_UPCALL
2906 * cifs_build_path_to_root returns full path to root when we do not have an
2907 * existing connection (tcon)
2910 build_unc_path_to_root(const struct smb3_fs_context *ctx,
2911 const struct cifs_sb_info *cifs_sb, bool useppath)
2913 char *full_path, *pos;
2914 unsigned int pplen = useppath && ctx->prepath ?
2915 strlen(ctx->prepath) + 1 : 0;
2916 unsigned int unc_len = strnlen(ctx->UNC, MAX_TREE_SIZE + 1);
2918 if (unc_len > MAX_TREE_SIZE)
2919 return ERR_PTR(-EINVAL);
2921 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
2922 if (full_path == NULL)
2923 return ERR_PTR(-ENOMEM);
2925 memcpy(full_path, ctx->UNC, unc_len);
2926 pos = full_path + unc_len;
2929 *pos = CIFS_DIR_SEP(cifs_sb);
2930 memcpy(pos + 1, ctx->prepath, pplen);
2934 *pos = '\0'; /* add trailing null */
2935 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
2936 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
2941 * expand_dfs_referral - Perform a dfs referral query and update the cifs_sb
2943 * If a referral is found, cifs_sb->ctx->mount_options will be (re-)allocated
2944 * to a string containing updated options for the submount. Otherwise it
2945 * will be left untouched.
2947 * Returns the rc from get_dfs_path to the caller, which can be used to
2948 * determine whether there were referrals.
2951 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
2952 struct smb3_fs_context *ctx, struct cifs_sb_info *cifs_sb,
2956 struct dfs_info3_param referral = {0};
2957 char *full_path = NULL, *mdata = NULL;
2959 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
2962 full_path = build_unc_path_to_root(ctx, cifs_sb, true);
2963 if (IS_ERR(full_path))
2964 return PTR_ERR(full_path);
2966 rc = dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
2967 ref_path, &referral, NULL);
2969 char *fake_devname = NULL;
2971 mdata = cifs_compose_mount_options(cifs_sb->ctx->mount_options,
2972 full_path + 1, &referral,
2974 free_dfs_info_param(&referral);
2976 if (IS_ERR(mdata)) {
2977 rc = PTR_ERR(mdata);
2981 * We can not clear out the whole structure since we
2982 * no longer have an explicit function to parse
2983 * a mount-string. Instead we need to clear out the
2984 * individual fields that are no longer valid.
2986 kfree(ctx->prepath);
2987 ctx->prepath = NULL;
2988 rc = cifs_setup_volume_info(ctx, mdata, fake_devname);
2990 kfree(fake_devname);
2991 kfree(cifs_sb->ctx->mount_options);
2992 cifs_sb->ctx->mount_options = mdata;
2998 static int get_next_dfs_tgt(struct dfs_cache_tgt_list *tgt_list,
2999 struct dfs_cache_tgt_iterator **tgt_it)
3002 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
3004 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
3005 return !*tgt_it ? -EHOSTDOWN : 0;
3008 static int update_vol_info(const struct dfs_cache_tgt_iterator *tgt_it,
3009 struct smb3_fs_context *fake_ctx, struct smb3_fs_context *ctx)
3011 const char *tgt = dfs_cache_get_tgt_name(tgt_it);
3012 int len = strlen(tgt) + 2;
3015 new_unc = kmalloc(len, GFP_KERNEL);
3018 scnprintf(new_unc, len, "\\%s", tgt);
3023 if (fake_ctx->prepath) {
3024 kfree(ctx->prepath);
3025 ctx->prepath = fake_ctx->prepath;
3026 fake_ctx->prepath = NULL;
3028 memcpy(&ctx->dstaddr, &fake_ctx->dstaddr, sizeof(ctx->dstaddr));
3033 static int do_dfs_failover(const char *path, const char *full_path, struct cifs_sb_info *cifs_sb,
3034 struct smb3_fs_context *ctx, struct cifs_ses *root_ses,
3035 unsigned int *xid, struct TCP_Server_Info **server,
3036 struct cifs_ses **ses, struct cifs_tcon **tcon)
3040 struct dfs_cache_tgt_list tgt_list = {0};
3041 struct dfs_cache_tgt_iterator *tgt_it = NULL;
3042 struct smb3_fs_context tmp_ctx = {NULL};
3044 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
3047 npath = dfs_cache_canonical_path(path, cifs_sb->local_nls, cifs_remap(cifs_sb));
3049 return PTR_ERR(npath);
3051 cifs_dbg(FYI, "%s: path=%s full_path=%s\n", __func__, npath, full_path);
3053 rc = dfs_cache_noreq_find(npath, NULL, &tgt_list);
3057 * We use a 'tmp_ctx' here because we need pass it down to the mount_{get,put} functions to
3058 * test connection against new DFS targets.
3060 rc = smb3_fs_context_dup(&tmp_ctx, ctx);
3065 struct dfs_info3_param ref = {0};
3066 char *fake_devname = NULL, *mdata = NULL;
3068 /* Get next DFS target server - if any */
3069 rc = get_next_dfs_tgt(&tgt_list, &tgt_it);
3073 rc = dfs_cache_get_tgt_referral(npath, tgt_it, &ref);
3077 cifs_dbg(FYI, "%s: old ctx: UNC=%s prepath=%s\n", __func__, tmp_ctx.UNC,
3080 mdata = cifs_compose_mount_options(cifs_sb->ctx->mount_options, full_path + 1, &ref,
3082 free_dfs_info_param(&ref);
3084 if (IS_ERR(mdata)) {
3085 rc = PTR_ERR(mdata);
3088 rc = cifs_setup_volume_info(&tmp_ctx, mdata, fake_devname);
3091 kfree(fake_devname);
3096 cifs_dbg(FYI, "%s: new ctx: UNC=%s prepath=%s\n", __func__, tmp_ctx.UNC,
3099 mount_put_conns(cifs_sb, *xid, *server, *ses, *tcon);
3100 rc = mount_get_conns(&tmp_ctx, cifs_sb, xid, server, ses, tcon);
3101 if (!rc || (*server && *ses)) {
3103 * We were able to connect to new target server. Update current context with
3104 * new target server.
3106 rc = update_vol_info(tgt_it, &tmp_ctx, ctx);
3111 cifs_dbg(FYI, "%s: final ctx: UNC=%s prepath=%s\n", __func__, tmp_ctx.UNC,
3114 * Update DFS target hint in DFS referral cache with the target server we
3115 * successfully reconnected to.
3117 rc = dfs_cache_update_tgthint(*xid, root_ses ? root_ses : *ses, cifs_sb->local_nls,
3118 cifs_remap(cifs_sb), path, tgt_it);
3123 smb3_cleanup_fs_context_contents(&tmp_ctx);
3124 dfs_cache_free_tgts(&tgt_list);
3129 /* TODO: all callers to this are broken. We are not parsing mount_options here
3130 * we should pass a clone of the original context?
3133 cifs_setup_volume_info(struct smb3_fs_context *ctx, const char *mntopts, const char *devname)
3138 cifs_dbg(FYI, "%s: devname=%s\n", __func__, devname);
3139 rc = smb3_parse_devname(devname, ctx);
3141 cifs_dbg(VFS, "%s: failed to parse %s: %d\n", __func__, devname, rc);
3149 rc = smb3_parse_opt(mntopts, "ip", &ip);
3151 cifs_dbg(VFS, "%s: failed to parse ip options: %d\n", __func__, rc);
3155 rc = cifs_convert_address((struct sockaddr *)&ctx->dstaddr, ip, strlen(ip));
3158 cifs_dbg(VFS, "%s: failed to convert ip address\n", __func__);
3163 if (ctx->nullauth) {
3164 cifs_dbg(FYI, "Anonymous login\n");
3165 kfree(ctx->username);
3166 ctx->username = NULL;
3167 } else if (ctx->username) {
3168 /* BB fixme parse for domain name here */
3169 cifs_dbg(FYI, "Username: %s\n", ctx->username);
3171 cifs_dbg(VFS, "No username specified\n");
3172 /* In userspace mount helper we can get user name from alternate
3173 locations such as env variables and files on disk */
3181 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3183 struct cifs_tcon *tcon,
3184 struct cifs_sb_info *cifs_sb,
3191 int skip = added_treename ? 1 : 0;
3193 sep = CIFS_DIR_SEP(cifs_sb);
3196 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3198 /* skip separators */
3203 /* next separator */
3204 while (*s && *s != sep)
3207 * if the treename is added, we then have to skip the first
3208 * part within the separators
3215 * temporarily null-terminate the path at the end of
3216 * the current component
3220 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3228 * Check if path is remote (e.g. a DFS share). Return -EREMOTE if it is,
3231 static int is_path_remote(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx,
3232 const unsigned int xid,
3233 struct TCP_Server_Info *server,
3234 struct cifs_tcon *tcon)
3239 if (!server->ops->is_path_accessible)
3243 * cifs_build_path_to_root works only when we have a valid tcon
3245 full_path = cifs_build_path_to_root(ctx, cifs_sb, tcon,
3246 tcon->Flags & SMB_SHARE_IS_IN_DFS);
3247 if (full_path == NULL)
3250 cifs_dbg(FYI, "%s: full_path: %s\n", __func__, full_path);
3252 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3254 if (rc != 0 && rc != -EREMOTE) {
3259 if (rc != -EREMOTE) {
3260 rc = cifs_are_all_path_components_accessible(server, xid, tcon,
3261 cifs_sb, full_path, tcon->Flags & SMB_SHARE_IS_IN_DFS);
3263 cifs_server_dbg(VFS, "cannot query dirs between root and final path, enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3264 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3273 #ifdef CONFIG_CIFS_DFS_UPCALL
3274 static void set_root_ses(struct cifs_sb_info *cifs_sb, const uuid_t *mount_id, struct cifs_ses *ses,
3275 struct cifs_ses **root_ses)
3278 spin_lock(&cifs_tcp_ses_lock);
3280 spin_unlock(&cifs_tcp_ses_lock);
3281 dfs_cache_add_refsrv_session(mount_id, ses);
3286 /* Set up next dfs prefix path in @dfs_path */
3287 static int next_dfs_prepath(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx,
3288 const unsigned int xid, struct TCP_Server_Info *server,
3289 struct cifs_tcon *tcon, char **dfs_path)
3292 int added_treename = is_tcon_dfs(tcon);
3295 path = cifs_build_path_to_root(ctx, cifs_sb, tcon, added_treename);
3299 rc = is_path_remote(cifs_sb, ctx, xid, server, tcon);
3300 if (rc == -EREMOTE) {
3301 struct smb3_fs_context v = {NULL};
3302 /* if @path contains a tree name, skip it in the prefix path */
3303 if (added_treename) {
3304 rc = smb3_parse_devname(path, &v);
3307 npath = build_unc_path_to_root(&v, cifs_sb, true);
3308 smb3_cleanup_fs_context_contents(&v);
3311 v.prepath = path + 1;
3312 npath = build_unc_path_to_root(&v, cifs_sb, true);
3315 if (IS_ERR(npath)) {
3316 rc = PTR_ERR(npath);
3330 /* Check if resolved targets can handle any DFS referrals */
3331 static int is_referral_server(const char *ref_path, struct cifs_sb_info *cifs_sb,
3332 struct cifs_tcon *tcon, bool *ref_server)
3335 struct dfs_info3_param ref = {0};
3337 cifs_dbg(FYI, "%s: ref_path=%s\n", __func__, ref_path);
3339 if (is_tcon_dfs(tcon)) {
3344 npath = dfs_cache_canonical_path(ref_path, cifs_sb->local_nls, cifs_remap(cifs_sb));
3346 return PTR_ERR(npath);
3348 rc = dfs_cache_noreq_find(npath, &ref, NULL);
3351 cifs_dbg(VFS, "%s: dfs_cache_noreq_find: failed (rc=%d)\n", __func__, rc);
3354 cifs_dbg(FYI, "%s: ref.flags=0x%x\n", __func__, ref.flags);
3356 * Check if all targets are capable of handling DFS referrals as per
3357 * MS-DFSC 2.2.4 RESP_GET_DFS_REFERRAL.
3359 *ref_server = !!(ref.flags & DFSREF_REFERRAL_SERVER);
3360 free_dfs_info_param(&ref);
3365 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx)
3369 struct TCP_Server_Info *server = NULL;
3370 struct cifs_ses *ses = NULL, *root_ses = NULL;
3371 struct cifs_tcon *tcon = NULL;
3373 uuid_t mount_id = {0};
3374 char *ref_path = NULL, *full_path = NULL;
3375 char *oldmnt = NULL;
3376 bool ref_server = false;
3378 rc = mount_get_conns(ctx, cifs_sb, &xid, &server, &ses, &tcon);
3380 * If called with 'nodfs' mount option, then skip DFS resolving. Otherwise unconditionally
3381 * try to get an DFS referral (even cached) to determine whether it is an DFS mount.
3383 * Skip prefix path to provide support for DFS referrals from w2k8 servers which don't seem
3384 * to respond with PATH_NOT_COVERED to requests that include the prefix.
3386 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS) ||
3387 dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb), ctx->UNC + 1, NULL,
3391 /* Check if it is fully accessible and then mount it */
3392 rc = is_path_remote(cifs_sb, ctx, xid, server, tcon);
3399 ctx->nosharesock = true;
3401 /* Get path of DFS root */
3402 ref_path = build_unc_path_to_root(ctx, cifs_sb, false);
3403 if (IS_ERR(ref_path)) {
3404 rc = PTR_ERR(ref_path);
3409 uuid_gen(&mount_id);
3410 set_root_ses(cifs_sb, &mount_id, ses, &root_ses);
3412 /* Save full path of last DFS path we used to resolve final target server */
3414 full_path = build_unc_path_to_root(ctx, cifs_sb, !!count);
3415 if (IS_ERR(full_path)) {
3416 rc = PTR_ERR(full_path);
3420 /* Chase referral */
3421 oldmnt = cifs_sb->ctx->mount_options;
3422 rc = expand_dfs_referral(xid, root_ses, ctx, cifs_sb, ref_path + 1);
3425 /* Connect to new DFS target only if we were redirected */
3426 if (oldmnt != cifs_sb->ctx->mount_options) {
3427 mount_put_conns(cifs_sb, xid, server, ses, tcon);
3428 rc = mount_get_conns(ctx, cifs_sb, &xid, &server, &ses, &tcon);
3430 if (rc && !server && !ses) {
3431 /* Failed to connect. Try to connect to other targets in the referral. */
3432 rc = do_dfs_failover(ref_path + 1, full_path, cifs_sb, ctx, root_ses, &xid,
3433 &server, &ses, &tcon);
3435 if (rc == -EACCES || rc == -EOPNOTSUPP || !server || !ses)
3440 /* Make sure that requests go through new root servers */
3441 rc = is_referral_server(ref_path + 1, cifs_sb, tcon, &ref_server);
3445 set_root_ses(cifs_sb, &mount_id, ses, &root_ses);
3447 /* Get next dfs path and then continue chasing them if -EREMOTE */
3448 rc = next_dfs_prepath(cifs_sb, ctx, xid, server, tcon, &ref_path);
3449 /* Prevent recursion on broken link referrals */
3450 if (rc == -EREMOTE && ++count > MAX_NESTED_LINKS)
3452 } while (rc == -EREMOTE);
3459 * Store DFS full path in both superblock and tree connect structures.
3461 * For DFS root mounts, the prefix path (cifs_sb->prepath) is preserved during reconnect so
3462 * only the root path is set in cifs_sb->origin_fullpath and tcon->dfs_path. And for DFS
3463 * links, the prefix path is included in both and may be changed during reconnect. See
3464 * cifs_tree_connect().
3466 ref_path = dfs_cache_canonical_path(full_path, cifs_sb->local_nls, cifs_remap(cifs_sb));
3470 if (IS_ERR(ref_path)) {
3471 rc = PTR_ERR(ref_path);
3475 cifs_sb->origin_fullpath = ref_path;
3477 ref_path = kstrdup(cifs_sb->origin_fullpath, GFP_KERNEL);
3482 spin_lock(&cifs_tcp_ses_lock);
3483 tcon->dfs_path = ref_path;
3485 spin_unlock(&cifs_tcp_ses_lock);
3488 * After reconnecting to a different server, unique ids won't
3489 * match anymore, so we disable serverino. This prevents
3490 * dentry revalidation to think the dentry are stale (ESTALE).
3492 cifs_autodisable_serverino(cifs_sb);
3494 * Force the use of prefix path to support failover on DFS paths that
3495 * resolve to targets that have different prefix paths.
3497 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3498 kfree(cifs_sb->prepath);
3499 cifs_sb->prepath = ctx->prepath;
3500 ctx->prepath = NULL;
3501 uuid_copy(&cifs_sb->dfs_mount_id, &mount_id);
3505 cifs_try_adding_channels(cifs_sb, ses);
3506 return mount_setup_tlink(cifs_sb, ses, tcon);
3511 kfree(cifs_sb->origin_fullpath);
3512 dfs_cache_put_refsrv_sessions(&mount_id);
3513 mount_put_conns(cifs_sb, xid, server, ses, tcon);
3517 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx)
3521 struct cifs_ses *ses;
3522 struct cifs_tcon *tcon;
3523 struct TCP_Server_Info *server;
3525 rc = mount_get_conns(ctx, cifs_sb, &xid, &server, &ses, &tcon);
3530 rc = is_path_remote(cifs_sb, ctx, xid, server, tcon);
3539 return mount_setup_tlink(cifs_sb, ses, tcon);
3542 mount_put_conns(cifs_sb, xid, server, ses, tcon);
3548 * Issue a TREE_CONNECT request.
3551 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3552 const char *tree, struct cifs_tcon *tcon,
3553 const struct nls_table *nls_codepage)
3555 struct smb_hdr *smb_buffer;
3556 struct smb_hdr *smb_buffer_response;
3559 unsigned char *bcc_ptr;
3562 __u16 bytes_left, count;
3567 smb_buffer = cifs_buf_get();
3568 if (smb_buffer == NULL)
3571 smb_buffer_response = smb_buffer;
3573 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3574 NULL /*no tid */ , 4 /*wct */ );
3576 smb_buffer->Mid = get_next_mid(ses->server);
3577 smb_buffer->Uid = ses->Suid;
3578 pSMB = (TCONX_REQ *) smb_buffer;
3579 pSMBr = (TCONX_RSP *) smb_buffer_response;
3581 pSMB->AndXCommand = 0xFF;
3582 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3583 bcc_ptr = &pSMB->Password[0];
3584 if (tcon->pipe || (ses->server->sec_mode & SECMODE_USER)) {
3585 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3586 *bcc_ptr = 0; /* password is null byte */
3587 bcc_ptr++; /* skip password */
3588 /* already aligned so no need to do it below */
3590 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3591 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3592 specified as required (when that support is added to
3593 the vfs in the future) as only NTLM or the much
3594 weaker LANMAN (which we do not send by default) is accepted
3595 by Samba (not sure whether other servers allow
3596 NTLMv2 password here) */
3597 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3598 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3599 (ses->sectype == LANMAN))
3600 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3601 ses->server->sec_mode &
3602 SECMODE_PW_ENCRYPT ? true : false,
3605 #endif /* CIFS_WEAK_PW_HASH */
3606 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3607 bcc_ptr, nls_codepage);
3609 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3611 cifs_buf_release(smb_buffer);
3615 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3616 if (ses->capabilities & CAP_UNICODE) {
3617 /* must align unicode strings */
3618 *bcc_ptr = 0; /* null byte password */
3623 if (ses->server->sign)
3624 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3626 if (ses->capabilities & CAP_STATUS32) {
3627 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3629 if (ses->capabilities & CAP_DFS) {
3630 smb_buffer->Flags2 |= SMBFLG2_DFS;
3632 if (ses->capabilities & CAP_UNICODE) {
3633 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3635 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3636 6 /* max utf8 char length in bytes */ *
3637 (/* server len*/ + 256 /* share len */), nls_codepage);
3638 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3639 bcc_ptr += 2; /* skip trailing null */
3640 } else { /* ASCII */
3641 strcpy(bcc_ptr, tree);
3642 bcc_ptr += strlen(tree) + 1;
3644 strcpy(bcc_ptr, "?????");
3645 bcc_ptr += strlen("?????");
3647 count = bcc_ptr - &pSMB->Password[0];
3648 be32_add_cpu(&pSMB->hdr.smb_buf_length, count);
3649 pSMB->ByteCount = cpu_to_le16(count);
3651 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3654 /* above now done in SendReceive */
3658 tcon->tidStatus = CifsGood;
3659 tcon->need_reconnect = false;
3660 tcon->tid = smb_buffer_response->Tid;
3661 bcc_ptr = pByteArea(smb_buffer_response);
3662 bytes_left = get_bcc(smb_buffer_response);
3663 length = strnlen(bcc_ptr, bytes_left - 2);
3664 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3670 /* skip service field (NB: this field is always ASCII) */
3672 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3673 (bcc_ptr[2] == 'C')) {
3674 cifs_dbg(FYI, "IPC connection\n");
3678 } else if (length == 2) {
3679 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3680 /* the most common case */
3681 cifs_dbg(FYI, "disk share connection\n");
3684 bcc_ptr += length + 1;
3685 bytes_left -= (length + 1);
3686 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
3688 /* mostly informational -- no need to fail on error here */
3689 kfree(tcon->nativeFileSystem);
3690 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3691 bytes_left, is_unicode,
3694 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
3696 if ((smb_buffer_response->WordCount == 3) ||
3697 (smb_buffer_response->WordCount == 7))
3698 /* field is in same location */
3699 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3702 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
3705 cifs_buf_release(smb_buffer);
3709 static void delayed_free(struct rcu_head *p)
3711 struct cifs_sb_info *cifs_sb = container_of(p, struct cifs_sb_info, rcu);
3713 unload_nls(cifs_sb->local_nls);
3714 smb3_cleanup_fs_context(cifs_sb->ctx);
3719 cifs_umount(struct cifs_sb_info *cifs_sb)
3721 struct rb_root *root = &cifs_sb->tlink_tree;
3722 struct rb_node *node;
3723 struct tcon_link *tlink;
3725 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3727 spin_lock(&cifs_sb->tlink_tree_lock);
3728 while ((node = rb_first(root))) {
3729 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3730 cifs_get_tlink(tlink);
3731 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3732 rb_erase(node, root);
3734 spin_unlock(&cifs_sb->tlink_tree_lock);
3735 cifs_put_tlink(tlink);
3736 spin_lock(&cifs_sb->tlink_tree_lock);
3738 spin_unlock(&cifs_sb->tlink_tree_lock);
3740 kfree(cifs_sb->prepath);
3741 #ifdef CONFIG_CIFS_DFS_UPCALL
3742 dfs_cache_put_refsrv_sessions(&cifs_sb->dfs_mount_id);
3743 kfree(cifs_sb->origin_fullpath);
3745 call_rcu(&cifs_sb->rcu, delayed_free);
3749 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3752 struct TCP_Server_Info *server = cifs_ses_server(ses);
3754 if (!server->ops->need_neg || !server->ops->negotiate)
3757 /* only send once per connect */
3758 if (!server->ops->need_neg(server))
3761 rc = server->ops->negotiate(xid, ses);
3763 spin_lock(&GlobalMid_Lock);
3764 if (server->tcpStatus == CifsNeedNegotiate)
3765 server->tcpStatus = CifsGood;
3768 spin_unlock(&GlobalMid_Lock);
3775 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3776 struct nls_table *nls_info)
3779 struct TCP_Server_Info *server = cifs_ses_server(ses);
3781 if (!ses->binding) {
3782 ses->capabilities = server->capabilities;
3783 if (!linuxExtEnabled)
3784 ses->capabilities &= (~server->vals->cap_unix);
3786 if (ses->auth_key.response) {
3787 cifs_dbg(FYI, "Free previous auth_key.response = %p\n",
3788 ses->auth_key.response);
3789 kfree(ses->auth_key.response);
3790 ses->auth_key.response = NULL;
3791 ses->auth_key.len = 0;
3795 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
3796 server->sec_mode, server->capabilities, server->timeAdj);
3798 if (server->ops->sess_setup)
3799 rc = server->ops->sess_setup(xid, ses, nls_info);
3802 cifs_server_dbg(VFS, "Send error in SessSetup = %d\n", rc);
3808 cifs_set_vol_auth(struct smb3_fs_context *ctx, struct cifs_ses *ses)
3810 ctx->sectype = ses->sectype;
3812 /* krb5 is special, since we don't need username or pw */
3813 if (ctx->sectype == Kerberos)
3816 return cifs_set_cifscreds(ctx, ses);
3819 static struct cifs_tcon *
3820 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
3823 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3824 struct cifs_ses *ses;
3825 struct cifs_tcon *tcon = NULL;
3826 struct smb3_fs_context *ctx;
3828 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
3830 return ERR_PTR(-ENOMEM);
3832 ctx->local_nls = cifs_sb->local_nls;
3833 ctx->linux_uid = fsuid;
3834 ctx->cred_uid = fsuid;
3835 ctx->UNC = master_tcon->treeName;
3836 ctx->retry = master_tcon->retry;
3837 ctx->nocase = master_tcon->nocase;
3838 ctx->nohandlecache = master_tcon->nohandlecache;
3839 ctx->local_lease = master_tcon->local_lease;
3840 ctx->no_lease = master_tcon->no_lease;
3841 ctx->resilient = master_tcon->use_resilient;
3842 ctx->persistent = master_tcon->use_persistent;
3843 ctx->handle_timeout = master_tcon->handle_timeout;
3844 ctx->no_linux_ext = !master_tcon->unix_ext;
3845 ctx->linux_ext = master_tcon->posix_extensions;
3846 ctx->sectype = master_tcon->ses->sectype;
3847 ctx->sign = master_tcon->ses->sign;
3848 ctx->seal = master_tcon->seal;
3849 ctx->witness = master_tcon->use_witness;
3851 rc = cifs_set_vol_auth(ctx, master_tcon->ses);
3857 /* get a reference for the same TCP session */
3858 spin_lock(&cifs_tcp_ses_lock);
3859 ++master_tcon->ses->server->srv_count;
3860 spin_unlock(&cifs_tcp_ses_lock);
3862 ses = cifs_get_smb_ses(master_tcon->ses->server, ctx);
3864 tcon = (struct cifs_tcon *)ses;
3865 cifs_put_tcp_session(master_tcon->ses->server, 0);
3869 tcon = cifs_get_tcon(ses, ctx);
3871 cifs_put_smb_ses(ses);
3876 reset_cifs_unix_caps(0, tcon, NULL, ctx);
3879 kfree(ctx->username);
3880 kfree_sensitive(ctx->password);
3887 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3889 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3892 /* find and return a tlink with given uid */
3893 static struct tcon_link *
3894 tlink_rb_search(struct rb_root *root, kuid_t uid)
3896 struct rb_node *node = root->rb_node;
3897 struct tcon_link *tlink;
3900 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3902 if (uid_gt(tlink->tl_uid, uid))
3903 node = node->rb_left;
3904 else if (uid_lt(tlink->tl_uid, uid))
3905 node = node->rb_right;
3912 /* insert a tcon_link into the tree */
3914 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3916 struct rb_node **new = &(root->rb_node), *parent = NULL;
3917 struct tcon_link *tlink;
3920 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3923 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
3924 new = &((*new)->rb_left);
3926 new = &((*new)->rb_right);
3929 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3930 rb_insert_color(&new_tlink->tl_rbnode, root);
3934 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3937 * If the superblock doesn't refer to a multiuser mount, then just return
3938 * the master tcon for the mount.
3940 * First, search the rbtree for an existing tcon for this fsuid. If one
3941 * exists, then check to see if it's pending construction. If it is then wait
3942 * for construction to complete. Once it's no longer pending, check to see if
3943 * it failed and either return an error or retry construction, depending on
3946 * If one doesn't exist then insert a new tcon_link struct into the tree and
3947 * try to construct a new one.
3950 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3953 kuid_t fsuid = current_fsuid();
3954 struct tcon_link *tlink, *newtlink;
3956 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3957 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3959 spin_lock(&cifs_sb->tlink_tree_lock);
3960 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3962 cifs_get_tlink(tlink);
3963 spin_unlock(&cifs_sb->tlink_tree_lock);
3965 if (tlink == NULL) {
3966 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3967 if (newtlink == NULL)
3968 return ERR_PTR(-ENOMEM);
3969 newtlink->tl_uid = fsuid;
3970 newtlink->tl_tcon = ERR_PTR(-EACCES);
3971 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3972 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3973 cifs_get_tlink(newtlink);
3975 spin_lock(&cifs_sb->tlink_tree_lock);
3976 /* was one inserted after previous search? */
3977 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3979 cifs_get_tlink(tlink);
3980 spin_unlock(&cifs_sb->tlink_tree_lock);
3982 goto wait_for_construction;
3985 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3986 spin_unlock(&cifs_sb->tlink_tree_lock);
3988 wait_for_construction:
3989 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3990 TASK_INTERRUPTIBLE);
3992 cifs_put_tlink(tlink);
3993 return ERR_PTR(-ERESTARTSYS);
3996 /* if it's good, return it */
3997 if (!IS_ERR(tlink->tl_tcon))
4000 /* return error if we tried this already recently */
4001 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4002 cifs_put_tlink(tlink);
4003 return ERR_PTR(-EACCES);
4006 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4007 goto wait_for_construction;
4010 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4011 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4012 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4014 if (IS_ERR(tlink->tl_tcon)) {
4015 cifs_put_tlink(tlink);
4016 return ERR_PTR(-EACCES);
4023 * periodic workqueue job that scans tcon_tree for a superblock and closes
4027 cifs_prune_tlinks(struct work_struct *work)
4029 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4031 struct rb_root *root = &cifs_sb->tlink_tree;
4032 struct rb_node *node;
4033 struct rb_node *tmp;
4034 struct tcon_link *tlink;
4037 * Because we drop the spinlock in the loop in order to put the tlink
4038 * it's not guarded against removal of links from the tree. The only
4039 * places that remove entries from the tree are this function and
4040 * umounts. Because this function is non-reentrant and is canceled
4041 * before umount can proceed, this is safe.
4043 spin_lock(&cifs_sb->tlink_tree_lock);
4044 node = rb_first(root);
4045 while (node != NULL) {
4047 node = rb_next(tmp);
4048 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4050 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4051 atomic_read(&tlink->tl_count) != 0 ||
4052 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4055 cifs_get_tlink(tlink);
4056 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4057 rb_erase(tmp, root);
4059 spin_unlock(&cifs_sb->tlink_tree_lock);
4060 cifs_put_tlink(tlink);
4061 spin_lock(&cifs_sb->tlink_tree_lock);
4063 spin_unlock(&cifs_sb->tlink_tree_lock);
4065 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4069 #ifdef CONFIG_CIFS_DFS_UPCALL
4070 int cifs_tree_connect(const unsigned int xid, struct cifs_tcon *tcon, const struct nls_table *nlsc)
4073 struct TCP_Server_Info *server = tcon->ses->server;
4074 const struct smb_version_operations *ops = server->ops;
4075 struct dfs_cache_tgt_list tl;
4076 struct dfs_cache_tgt_iterator *it = NULL;
4078 const char *tcp_host;
4079 size_t tcp_host_len;
4080 const char *dfs_host;
4081 size_t dfs_host_len;
4082 char *share = NULL, *prefix = NULL;
4083 struct dfs_info3_param ref = {0};
4086 tree = kzalloc(MAX_TREE_SIZE, GFP_KERNEL);
4090 if (!tcon->dfs_path) {
4092 scnprintf(tree, MAX_TREE_SIZE, "\\\\%s\\IPC$", server->hostname);
4093 rc = ops->tree_connect(xid, tcon->ses, tree, tcon, nlsc);
4095 rc = ops->tree_connect(xid, tcon->ses, tcon->treeName, tcon, nlsc);
4100 rc = dfs_cache_noreq_find(tcon->dfs_path + 1, &ref, &tl);
4103 isroot = ref.server_type == DFS_TYPE_ROOT;
4104 free_dfs_info_param(&ref);
4106 extract_unc_hostname(server->hostname, &tcp_host, &tcp_host_len);
4108 for (it = dfs_cache_get_tgt_iterator(&tl); it; it = dfs_cache_get_next_tgt(&tl, it)) {
4116 rc = dfs_cache_get_tgt_share(tcon->dfs_path + 1, it, &share, &prefix);
4118 cifs_dbg(VFS, "%s: failed to parse target share %d\n",
4123 extract_unc_hostname(share, &dfs_host, &dfs_host_len);
4125 if (dfs_host_len != tcp_host_len
4126 || strncasecmp(dfs_host, tcp_host, dfs_host_len) != 0) {
4127 cifs_dbg(FYI, "%s: %.*s doesn't match %.*s\n", __func__, (int)dfs_host_len,
4128 dfs_host, (int)tcp_host_len, tcp_host);
4130 rc = match_target_ip(server, dfs_host, dfs_host_len, &target_match);
4132 cifs_dbg(VFS, "%s: failed to match target ip: %d\n", __func__, rc);
4136 if (!target_match) {
4137 cifs_dbg(FYI, "%s: skipping target\n", __func__);
4143 scnprintf(tree, MAX_TREE_SIZE, "\\\\%s\\IPC$", share);
4144 rc = ops->tree_connect(xid, tcon->ses, tree, tcon, nlsc);
4146 scnprintf(tree, MAX_TREE_SIZE, "\\%s", share);
4147 rc = ops->tree_connect(xid, tcon->ses, tree, tcon, nlsc);
4148 /* Only handle prefix paths of DFS link targets */
4149 if (!rc && !isroot) {
4150 rc = update_super_prepath(tcon, prefix);
4163 rc = dfs_cache_noreq_update_tgthint(tcon->dfs_path + 1, it);
4167 dfs_cache_free_tgts(&tl);
4173 int cifs_tree_connect(const unsigned int xid, struct cifs_tcon *tcon, const struct nls_table *nlsc)
4175 const struct smb_version_operations *ops = tcon->ses->server->ops;
4177 return ops->tree_connect(xid, tcon->ses, tcon->treeName, tcon, nlsc);