4 * Copyright (C) International Business Machines Corp., 2002,2011
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/sched/mm.h>
25 #include <linux/sched/signal.h>
26 #include <linux/list.h>
27 #include <linux/wait.h>
28 #include <linux/slab.h>
29 #include <linux/pagemap.h>
30 #include <linux/ctype.h>
31 #include <linux/utsname.h>
32 #include <linux/mempool.h>
33 #include <linux/delay.h>
34 #include <linux/completion.h>
35 #include <linux/kthread.h>
36 #include <linux/pagevec.h>
37 #include <linux/freezer.h>
38 #include <linux/namei.h>
39 #include <linux/uuid.h>
40 #include <linux/uaccess.h>
41 #include <asm/processor.h>
42 #include <linux/inet.h>
43 #include <linux/module.h>
44 #include <keys/user-type.h>
46 #include <linux/parser.h>
47 #include <linux/bvec.h>
50 #include "cifsproto.h"
51 #include "cifs_unicode.h"
52 #include "cifs_debug.h"
53 #include "cifs_fs_sb.h"
56 #include "rfc1002pdu.h"
58 #include "smb2proto.h"
59 #include "smbdirect.h"
60 #include "dns_resolve.h"
61 #ifdef CONFIG_CIFS_DFS_UPCALL
62 #include "dfs_cache.h"
64 #include "fs_context.h"
67 extern mempool_t *cifs_req_poolp;
68 extern bool disable_legacy_dialects;
70 /* FIXME: should these be tunable? */
71 #define TLINK_ERROR_EXPIRE (1 * HZ)
72 #define TLINK_IDLE_EXPIRE (600 * HZ)
74 /* Drop the connection to not overload the server */
75 #define NUM_STATUS_IO_TIMEOUT 5
77 static int ip_connect(struct TCP_Server_Info *server);
78 static int generic_ip_connect(struct TCP_Server_Info *server);
79 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
80 static void cifs_prune_tlinks(struct work_struct *work);
83 * Resolve hostname and set ip addr in tcp ses. Useful for hostnames that may
84 * get their ip addresses changed at some point.
86 * This should be called with server->srv_mutex held.
88 static int reconn_set_ipaddr_from_hostname(struct TCP_Server_Info *server)
92 char *unc, *ipaddr = NULL;
94 if (!server->hostname)
97 len = strlen(server->hostname) + 3;
99 unc = kmalloc(len, GFP_KERNEL);
101 cifs_dbg(FYI, "%s: failed to create UNC path\n", __func__);
104 scnprintf(unc, len, "\\\\%s", server->hostname);
106 rc = dns_resolve_server_name_to_ip(unc, &ipaddr);
110 cifs_dbg(FYI, "%s: failed to resolve server part of %s to IP: %d\n",
111 __func__, server->hostname, rc);
115 spin_lock(&cifs_tcp_ses_lock);
116 rc = cifs_convert_address((struct sockaddr *)&server->dstaddr, ipaddr,
118 spin_unlock(&cifs_tcp_ses_lock);
124 #ifdef CONFIG_CIFS_DFS_UPCALL
125 /* These functions must be called with server->srv_mutex held */
126 static void reconn_set_next_dfs_target(struct TCP_Server_Info *server,
127 struct cifs_sb_info *cifs_sb,
128 struct dfs_cache_tgt_list *tgt_list,
129 struct dfs_cache_tgt_iterator **tgt_it)
134 if (!cifs_sb || !cifs_sb->origin_fullpath)
138 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
140 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
142 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
145 cifs_dbg(FYI, "%s: UNC: %s\n", __func__, cifs_sb->origin_fullpath);
147 name = dfs_cache_get_tgt_name(*tgt_it);
149 kfree(server->hostname);
151 server->hostname = extract_hostname(name);
152 if (IS_ERR(server->hostname)) {
154 "%s: failed to extract hostname from target: %ld\n",
155 __func__, PTR_ERR(server->hostname));
159 rc = reconn_set_ipaddr_from_hostname(server);
161 cifs_dbg(FYI, "%s: failed to resolve hostname: %d\n",
166 static inline int reconn_setup_dfs_targets(struct cifs_sb_info *cifs_sb,
167 struct dfs_cache_tgt_list *tl)
169 if (!cifs_sb->origin_fullpath)
171 return dfs_cache_noreq_find(cifs_sb->origin_fullpath + 1, NULL, tl);
176 * cifs tcp session reconnection
178 * mark tcp session as reconnecting so temporarily locked
179 * mark all smb sessions as reconnecting for tcp session
180 * reconnect tcp session
181 * wake up waiters on reconnection? - (not needed currently)
184 cifs_reconnect(struct TCP_Server_Info *server)
187 struct list_head *tmp, *tmp2;
188 struct cifs_ses *ses;
189 struct cifs_tcon *tcon;
190 struct mid_q_entry *mid_entry;
191 struct list_head retry_list;
192 #ifdef CONFIG_CIFS_DFS_UPCALL
193 struct super_block *sb = NULL;
194 struct cifs_sb_info *cifs_sb = NULL;
195 struct dfs_cache_tgt_list tgt_list = {0};
196 struct dfs_cache_tgt_iterator *tgt_it = NULL;
199 spin_lock(&GlobalMid_Lock);
200 server->nr_targets = 1;
201 #ifdef CONFIG_CIFS_DFS_UPCALL
202 spin_unlock(&GlobalMid_Lock);
203 sb = cifs_get_tcp_super(server);
206 cifs_dbg(FYI, "%s: will not do DFS failover: rc = %d\n",
210 cifs_sb = CIFS_SB(sb);
211 rc = reconn_setup_dfs_targets(cifs_sb, &tgt_list);
214 if (rc != -EOPNOTSUPP) {
215 cifs_server_dbg(VFS, "%s: no target servers for DFS failover\n",
219 server->nr_targets = dfs_cache_get_nr_tgts(&tgt_list);
222 cifs_dbg(FYI, "%s: will retry %d target(s)\n", __func__,
224 spin_lock(&GlobalMid_Lock);
226 if (server->tcpStatus == CifsExiting) {
227 /* the demux thread will exit normally
228 next time through the loop */
229 spin_unlock(&GlobalMid_Lock);
230 #ifdef CONFIG_CIFS_DFS_UPCALL
231 dfs_cache_free_tgts(&tgt_list);
232 cifs_put_tcp_super(sb);
234 wake_up(&server->response_q);
237 server->tcpStatus = CifsNeedReconnect;
238 spin_unlock(&GlobalMid_Lock);
240 server->max_read = 0;
242 cifs_dbg(FYI, "Mark tcp session as need reconnect\n");
243 trace_smb3_reconnect(server->CurrentMid, server->conn_id, server->hostname);
245 /* before reconnecting the tcp session, mark the smb session (uid)
246 and the tid bad so they are not used until reconnected */
247 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
249 spin_lock(&cifs_tcp_ses_lock);
250 list_for_each(tmp, &server->smb_ses_list) {
251 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
252 ses->need_reconnect = true;
253 list_for_each(tmp2, &ses->tcon_list) {
254 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
255 tcon->need_reconnect = true;
258 ses->tcon_ipc->need_reconnect = true;
260 spin_unlock(&cifs_tcp_ses_lock);
262 /* do not want to be sending data on a socket we are freeing */
263 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
264 mutex_lock(&server->srv_mutex);
265 if (server->ssocket) {
266 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
267 server->ssocket->state, server->ssocket->flags);
268 kernel_sock_shutdown(server->ssocket, SHUT_WR);
269 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
270 server->ssocket->state, server->ssocket->flags);
271 sock_release(server->ssocket);
272 server->ssocket = NULL;
274 server->sequence_number = 0;
275 server->session_estab = false;
276 kfree(server->session_key.response);
277 server->session_key.response = NULL;
278 server->session_key.len = 0;
279 server->lstrp = jiffies;
281 /* mark submitted MIDs for retry and issue callback */
282 INIT_LIST_HEAD(&retry_list);
283 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
284 spin_lock(&GlobalMid_Lock);
285 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
286 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
287 kref_get(&mid_entry->refcount);
288 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
289 mid_entry->mid_state = MID_RETRY_NEEDED;
290 list_move(&mid_entry->qhead, &retry_list);
291 mid_entry->mid_flags |= MID_DELETED;
293 spin_unlock(&GlobalMid_Lock);
294 mutex_unlock(&server->srv_mutex);
296 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
297 list_for_each_safe(tmp, tmp2, &retry_list) {
298 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
299 list_del_init(&mid_entry->qhead);
300 mid_entry->callback(mid_entry);
301 cifs_mid_q_entry_release(mid_entry);
304 if (cifs_rdma_enabled(server)) {
305 mutex_lock(&server->srv_mutex);
306 smbd_destroy(server);
307 mutex_unlock(&server->srv_mutex);
313 mutex_lock(&server->srv_mutex);
316 if (!cifs_swn_set_server_dstaddr(server)) {
317 #ifdef CONFIG_CIFS_DFS_UPCALL
318 if (cifs_sb && cifs_sb->origin_fullpath)
320 * Set up next DFS target server (if any) for reconnect. If DFS
321 * feature is disabled, then we will retry last server we
322 * connected to before.
324 reconn_set_next_dfs_target(server, cifs_sb, &tgt_list, &tgt_it);
328 * Resolve the hostname again to make sure that IP address is up-to-date.
330 rc = reconn_set_ipaddr_from_hostname(server);
332 cifs_dbg(FYI, "%s: failed to resolve hostname: %d\n",
336 #ifdef CONFIG_CIFS_DFS_UPCALL
343 if (cifs_rdma_enabled(server))
344 rc = smbd_reconnect(server);
346 rc = generic_ip_connect(server);
348 cifs_dbg(FYI, "reconnect error %d\n", rc);
349 mutex_unlock(&server->srv_mutex);
352 atomic_inc(&tcpSesReconnectCount);
353 set_credits(server, 1);
354 spin_lock(&GlobalMid_Lock);
355 if (server->tcpStatus != CifsExiting)
356 server->tcpStatus = CifsNeedNegotiate;
357 spin_unlock(&GlobalMid_Lock);
358 cifs_swn_reset_server_dstaddr(server);
359 mutex_unlock(&server->srv_mutex);
361 } while (server->tcpStatus == CifsNeedReconnect);
363 #ifdef CONFIG_CIFS_DFS_UPCALL
365 rc = dfs_cache_noreq_update_tgthint(cifs_sb->origin_fullpath + 1,
368 cifs_server_dbg(VFS, "%s: failed to update DFS target hint: rc = %d\n",
371 rc = dfs_cache_update_vol(cifs_sb->origin_fullpath, server);
373 cifs_server_dbg(VFS, "%s: failed to update vol info in DFS cache: rc = %d\n",
376 dfs_cache_free_tgts(&tgt_list);
380 cifs_put_tcp_super(sb);
382 if (server->tcpStatus == CifsNeedNegotiate)
383 mod_delayed_work(cifsiod_wq, &server->echo, 0);
385 wake_up(&server->response_q);
390 cifs_echo_request(struct work_struct *work)
393 struct TCP_Server_Info *server = container_of(work,
394 struct TCP_Server_Info, echo.work);
397 * We cannot send an echo if it is disabled.
398 * Also, no need to ping if we got a response recently.
401 if (server->tcpStatus == CifsNeedReconnect ||
402 server->tcpStatus == CifsExiting ||
403 server->tcpStatus == CifsNew ||
404 (server->ops->can_echo && !server->ops->can_echo(server)) ||
405 time_before(jiffies, server->lstrp + server->echo_interval - HZ))
408 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
410 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
413 /* Check witness registrations */
417 queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
421 allocate_buffers(struct TCP_Server_Info *server)
423 if (!server->bigbuf) {
424 server->bigbuf = (char *)cifs_buf_get();
425 if (!server->bigbuf) {
426 cifs_server_dbg(VFS, "No memory for large SMB response\n");
428 /* retry will check if exiting */
431 } else if (server->large_buf) {
432 /* we are reusing a dirty large buf, clear its start */
433 memset(server->bigbuf, 0, HEADER_SIZE(server));
436 if (!server->smallbuf) {
437 server->smallbuf = (char *)cifs_small_buf_get();
438 if (!server->smallbuf) {
439 cifs_server_dbg(VFS, "No memory for SMB response\n");
441 /* retry will check if exiting */
444 /* beginning of smb buffer is cleared in our buf_get */
446 /* if existing small buf clear beginning */
447 memset(server->smallbuf, 0, HEADER_SIZE(server));
454 server_unresponsive(struct TCP_Server_Info *server)
457 * We need to wait 3 echo intervals to make sure we handle such
459 * 1s client sends a normal SMB request
460 * 2s client gets a response
461 * 30s echo workqueue job pops, and decides we got a response recently
462 * and don't need to send another
464 * 65s kernel_recvmsg times out, and we see that we haven't gotten
465 * a response in >60s.
467 if ((server->tcpStatus == CifsGood ||
468 server->tcpStatus == CifsNeedNegotiate) &&
469 (!server->ops->can_echo || server->ops->can_echo(server)) &&
470 time_after(jiffies, server->lstrp + 3 * server->echo_interval)) {
471 cifs_server_dbg(VFS, "has not responded in %lu seconds. Reconnecting...\n",
472 (3 * server->echo_interval) / HZ);
473 cifs_reconnect(server);
481 zero_credits(struct TCP_Server_Info *server)
485 spin_lock(&server->req_lock);
486 val = server->credits + server->echo_credits + server->oplock_credits;
487 if (server->in_flight == 0 && val == 0) {
488 spin_unlock(&server->req_lock);
491 spin_unlock(&server->req_lock);
496 cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
501 smb_msg->msg_control = NULL;
502 smb_msg->msg_controllen = 0;
504 for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
507 /* reconnect if no credits and no requests in flight */
508 if (zero_credits(server)) {
509 cifs_reconnect(server);
510 return -ECONNABORTED;
513 if (server_unresponsive(server))
514 return -ECONNABORTED;
515 if (cifs_rdma_enabled(server) && server->smbd_conn)
516 length = smbd_recv(server->smbd_conn, smb_msg);
518 length = sock_recvmsg(server->ssocket, smb_msg, 0);
520 if (server->tcpStatus == CifsExiting)
523 if (server->tcpStatus == CifsNeedReconnect) {
524 cifs_reconnect(server);
525 return -ECONNABORTED;
528 if (length == -ERESTARTSYS ||
532 * Minimum sleep to prevent looping, allowing socket
533 * to clear and app threads to set tcpStatus
534 * CifsNeedReconnect if server hung.
536 usleep_range(1000, 2000);
542 cifs_dbg(FYI, "Received no data or error: %d\n", length);
543 cifs_reconnect(server);
544 return -ECONNABORTED;
551 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
552 unsigned int to_read)
554 struct msghdr smb_msg;
555 struct kvec iov = {.iov_base = buf, .iov_len = to_read};
556 iov_iter_kvec(&smb_msg.msg_iter, READ, &iov, 1, to_read);
558 return cifs_readv_from_socket(server, &smb_msg);
562 cifs_discard_from_socket(struct TCP_Server_Info *server, size_t to_read)
564 struct msghdr smb_msg;
567 * iov_iter_discard already sets smb_msg.type and count and iov_offset
568 * and cifs_readv_from_socket sets msg_control and msg_controllen
569 * so little to initialize in struct msghdr
571 smb_msg.msg_name = NULL;
572 smb_msg.msg_namelen = 0;
573 iov_iter_discard(&smb_msg.msg_iter, READ, to_read);
575 return cifs_readv_from_socket(server, &smb_msg);
579 cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
580 unsigned int page_offset, unsigned int to_read)
582 struct msghdr smb_msg;
583 struct bio_vec bv = {
584 .bv_page = page, .bv_len = to_read, .bv_offset = page_offset};
585 iov_iter_bvec(&smb_msg.msg_iter, READ, &bv, 1, to_read);
586 return cifs_readv_from_socket(server, &smb_msg);
590 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
593 * The first byte big endian of the length field,
594 * is actually not part of the length but the type
595 * with the most common, zero, as regular data.
598 case RFC1002_SESSION_MESSAGE:
599 /* Regular SMB response */
601 case RFC1002_SESSION_KEEP_ALIVE:
602 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
604 case RFC1002_POSITIVE_SESSION_RESPONSE:
605 cifs_dbg(FYI, "RFC 1002 positive session response\n");
607 case RFC1002_NEGATIVE_SESSION_RESPONSE:
609 * We get this from Windows 98 instead of an error on
610 * SMB negprot response.
612 cifs_dbg(FYI, "RFC 1002 negative session response\n");
613 /* give server a second to clean up */
616 * Always try 445 first on reconnect since we get NACK
617 * on some if we ever connected to port 139 (the NACK
618 * is since we do not begin with RFC1001 session
621 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
622 cifs_reconnect(server);
625 cifs_server_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
626 cifs_reconnect(server);
633 dequeue_mid(struct mid_q_entry *mid, bool malformed)
635 #ifdef CONFIG_CIFS_STATS2
636 mid->when_received = jiffies;
638 spin_lock(&GlobalMid_Lock);
640 mid->mid_state = MID_RESPONSE_RECEIVED;
642 mid->mid_state = MID_RESPONSE_MALFORMED;
644 * Trying to handle/dequeue a mid after the send_recv()
645 * function has finished processing it is a bug.
647 if (mid->mid_flags & MID_DELETED)
648 pr_warn_once("trying to dequeue a deleted mid\n");
650 list_del_init(&mid->qhead);
651 mid->mid_flags |= MID_DELETED;
653 spin_unlock(&GlobalMid_Lock);
657 smb2_get_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
659 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
662 * SMB1 does not use credits.
664 if (server->vals->header_preamble_size)
667 return le16_to_cpu(shdr->CreditRequest);
671 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
672 char *buf, int malformed)
674 if (server->ops->check_trans2 &&
675 server->ops->check_trans2(mid, server, buf, malformed))
677 mid->credits_received = smb2_get_credits_from_hdr(buf, server);
679 mid->large_buf = server->large_buf;
680 /* Was previous buf put in mpx struct for multi-rsp? */
681 if (!mid->multiRsp) {
682 /* smb buffer will be freed by user thread */
683 if (server->large_buf)
684 server->bigbuf = NULL;
686 server->smallbuf = NULL;
688 dequeue_mid(mid, malformed);
691 static void clean_demultiplex_info(struct TCP_Server_Info *server)
695 /* take it off the list, if it's not already */
696 spin_lock(&cifs_tcp_ses_lock);
697 list_del_init(&server->tcp_ses_list);
698 spin_unlock(&cifs_tcp_ses_lock);
700 cancel_delayed_work_sync(&server->echo);
702 spin_lock(&GlobalMid_Lock);
703 server->tcpStatus = CifsExiting;
704 spin_unlock(&GlobalMid_Lock);
705 wake_up_all(&server->response_q);
707 /* check if we have blocked requests that need to free */
708 spin_lock(&server->req_lock);
709 if (server->credits <= 0)
711 spin_unlock(&server->req_lock);
713 * Although there should not be any requests blocked on this queue it
714 * can not hurt to be paranoid and try to wake up requests that may
715 * haven been blocked when more than 50 at time were on the wire to the
716 * same server - they now will see the session is in exit state and get
717 * out of SendReceive.
719 wake_up_all(&server->request_q);
720 /* give those requests time to exit */
722 if (cifs_rdma_enabled(server))
723 smbd_destroy(server);
724 if (server->ssocket) {
725 sock_release(server->ssocket);
726 server->ssocket = NULL;
729 if (!list_empty(&server->pending_mid_q)) {
730 struct list_head dispose_list;
731 struct mid_q_entry *mid_entry;
732 struct list_head *tmp, *tmp2;
734 INIT_LIST_HEAD(&dispose_list);
735 spin_lock(&GlobalMid_Lock);
736 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
737 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
738 cifs_dbg(FYI, "Clearing mid %llu\n", mid_entry->mid);
739 kref_get(&mid_entry->refcount);
740 mid_entry->mid_state = MID_SHUTDOWN;
741 list_move(&mid_entry->qhead, &dispose_list);
742 mid_entry->mid_flags |= MID_DELETED;
744 spin_unlock(&GlobalMid_Lock);
746 /* now walk dispose list and issue callbacks */
747 list_for_each_safe(tmp, tmp2, &dispose_list) {
748 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
749 cifs_dbg(FYI, "Callback mid %llu\n", mid_entry->mid);
750 list_del_init(&mid_entry->qhead);
751 mid_entry->callback(mid_entry);
752 cifs_mid_q_entry_release(mid_entry);
754 /* 1/8th of sec is more than enough time for them to exit */
758 if (!list_empty(&server->pending_mid_q)) {
760 * mpx threads have not exited yet give them at least the smb
761 * send timeout time for long ops.
763 * Due to delays on oplock break requests, we need to wait at
764 * least 45 seconds before giving up on a request getting a
765 * response and going ahead and killing cifsd.
767 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
770 * If threads still have not exited they are probably never
771 * coming home not much else we can do but free the memory.
775 kfree(server->hostname);
778 length = atomic_dec_return(&tcpSesAllocCount);
780 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
784 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
787 char *buf = server->smallbuf;
788 unsigned int pdu_length = server->pdu_size;
790 /* make sure this will fit in a large buffer */
791 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) -
792 server->vals->header_preamble_size) {
793 cifs_server_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
794 cifs_reconnect(server);
795 return -ECONNABORTED;
798 /* switch to large buffer if too big for a small one */
799 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
800 server->large_buf = true;
801 memcpy(server->bigbuf, buf, server->total_read);
802 buf = server->bigbuf;
805 /* now read the rest */
806 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
807 pdu_length - HEADER_SIZE(server) + 1
808 + server->vals->header_preamble_size);
812 server->total_read += length;
814 dump_smb(buf, server->total_read);
816 return cifs_handle_standard(server, mid);
820 cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
822 char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
826 * We know that we received enough to get to the MID as we
827 * checked the pdu_length earlier. Now check to see
828 * if the rest of the header is OK. We borrow the length
829 * var for the rest of the loop to avoid a new stack var.
831 * 48 bytes is enough to display the header and a little bit
832 * into the payload for debugging purposes.
834 length = server->ops->check_message(buf, server->total_read, server);
836 cifs_dump_mem("Bad SMB: ", buf,
837 min_t(unsigned int, server->total_read, 48));
839 if (server->ops->is_session_expired &&
840 server->ops->is_session_expired(buf)) {
841 cifs_reconnect(server);
845 if (server->ops->is_status_pending &&
846 server->ops->is_status_pending(buf, server))
852 handle_mid(mid, server, buf, length);
857 smb2_add_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
859 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
860 int scredits, in_flight;
863 * SMB1 does not use credits.
865 if (server->vals->header_preamble_size)
868 if (shdr->CreditRequest) {
869 spin_lock(&server->req_lock);
870 server->credits += le16_to_cpu(shdr->CreditRequest);
871 scredits = server->credits;
872 in_flight = server->in_flight;
873 spin_unlock(&server->req_lock);
874 wake_up(&server->request_q);
876 trace_smb3_add_credits(server->CurrentMid,
877 server->conn_id, server->hostname, scredits,
878 le16_to_cpu(shdr->CreditRequest), in_flight);
879 cifs_server_dbg(FYI, "%s: added %u credits total=%d\n",
880 __func__, le16_to_cpu(shdr->CreditRequest),
887 cifs_demultiplex_thread(void *p)
889 int i, num_mids, length;
890 struct TCP_Server_Info *server = p;
891 unsigned int pdu_length;
892 unsigned int next_offset;
894 struct task_struct *task_to_wake = NULL;
895 struct mid_q_entry *mids[MAX_COMPOUND];
896 char *bufs[MAX_COMPOUND];
897 unsigned int noreclaim_flag, num_io_timeout = 0;
899 noreclaim_flag = memalloc_noreclaim_save();
900 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
902 length = atomic_inc_return(&tcpSesAllocCount);
904 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
907 allow_kernel_signal(SIGKILL);
908 while (server->tcpStatus != CifsExiting) {
912 if (!allocate_buffers(server))
915 server->large_buf = false;
916 buf = server->smallbuf;
917 pdu_length = 4; /* enough to get RFC1001 header */
919 length = cifs_read_from_socket(server, buf, pdu_length);
923 if (server->vals->header_preamble_size == 0)
924 server->total_read = 0;
926 server->total_read = length;
929 * The right amount was read from socket - 4 bytes,
930 * so we can now interpret the length field.
932 pdu_length = get_rfc1002_length(buf);
934 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
935 if (!is_smb_response(server, buf[0]))
938 server->pdu_size = pdu_length;
940 /* make sure we have enough to get to the MID */
941 if (server->pdu_size < HEADER_SIZE(server) - 1 -
942 server->vals->header_preamble_size) {
943 cifs_server_dbg(VFS, "SMB response too short (%u bytes)\n",
945 cifs_reconnect(server);
949 /* read down to the MID */
950 length = cifs_read_from_socket(server,
951 buf + server->vals->header_preamble_size,
952 HEADER_SIZE(server) - 1
953 - server->vals->header_preamble_size);
956 server->total_read += length;
958 if (server->ops->next_header) {
959 next_offset = server->ops->next_header(buf);
961 server->pdu_size = next_offset;
964 memset(mids, 0, sizeof(mids));
965 memset(bufs, 0, sizeof(bufs));
968 if (server->ops->is_transform_hdr &&
969 server->ops->receive_transform &&
970 server->ops->is_transform_hdr(buf)) {
971 length = server->ops->receive_transform(server,
976 mids[0] = server->ops->find_mid(server, buf);
980 if (!mids[0] || !mids[0]->receive)
981 length = standard_receive3(server, mids[0]);
983 length = mids[0]->receive(server, mids[0]);
987 for (i = 0; i < num_mids; i++)
989 cifs_mid_q_entry_release(mids[i]);
993 if (server->ops->is_status_io_timeout &&
994 server->ops->is_status_io_timeout(buf)) {
996 if (num_io_timeout > NUM_STATUS_IO_TIMEOUT) {
997 cifs_reconnect(server);
1003 server->lstrp = jiffies;
1005 for (i = 0; i < num_mids; i++) {
1006 if (mids[i] != NULL) {
1007 mids[i]->resp_buf_size = server->pdu_size;
1009 if (bufs[i] && server->ops->is_network_name_deleted)
1010 server->ops->is_network_name_deleted(bufs[i],
1013 if (!mids[i]->multiRsp || mids[i]->multiEnd)
1014 mids[i]->callback(mids[i]);
1016 cifs_mid_q_entry_release(mids[i]);
1017 } else if (server->ops->is_oplock_break &&
1018 server->ops->is_oplock_break(bufs[i],
1020 smb2_add_credits_from_hdr(bufs[i], server);
1021 cifs_dbg(FYI, "Received oplock break\n");
1023 cifs_server_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
1024 atomic_read(&midCount));
1025 cifs_dump_mem("Received Data is: ", bufs[i],
1026 HEADER_SIZE(server));
1027 smb2_add_credits_from_hdr(bufs[i], server);
1028 #ifdef CONFIG_CIFS_DEBUG2
1029 if (server->ops->dump_detail)
1030 server->ops->dump_detail(bufs[i],
1032 cifs_dump_mids(server);
1033 #endif /* CIFS_DEBUG2 */
1037 if (pdu_length > server->pdu_size) {
1038 if (!allocate_buffers(server))
1040 pdu_length -= server->pdu_size;
1041 server->total_read = 0;
1042 server->large_buf = false;
1043 buf = server->smallbuf;
1046 } /* end while !EXITING */
1048 /* buffer usually freed in free_mid - need to free it here on exit */
1049 cifs_buf_release(server->bigbuf);
1050 if (server->smallbuf) /* no sense logging a debug message if NULL */
1051 cifs_small_buf_release(server->smallbuf);
1053 task_to_wake = xchg(&server->tsk, NULL);
1054 clean_demultiplex_info(server);
1056 /* if server->tsk was NULL then wait for a signal before exiting */
1057 if (!task_to_wake) {
1058 set_current_state(TASK_INTERRUPTIBLE);
1059 while (!signal_pending(current)) {
1061 set_current_state(TASK_INTERRUPTIBLE);
1063 set_current_state(TASK_RUNNING);
1066 memalloc_noreclaim_restore(noreclaim_flag);
1067 module_put_and_exit(0);
1071 * Returns true if srcaddr isn't specified and rhs isn't specified, or
1072 * if srcaddr is specified and matches the IP address of the rhs argument
1075 cifs_match_ipaddr(struct sockaddr *srcaddr, struct sockaddr *rhs)
1077 switch (srcaddr->sa_family) {
1079 return (rhs->sa_family == AF_UNSPEC);
1081 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1082 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1083 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1086 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1087 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1088 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1092 return false; /* don't expect to be here */
1097 * If no port is specified in addr structure, we try to match with 445 port
1098 * and if it fails - with 139 ports. It should be called only if address
1099 * families of server and addr are equal.
1102 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1104 __be16 port, *sport;
1106 /* SMBDirect manages its own ports, don't match it here */
1110 switch (addr->sa_family) {
1112 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1113 port = ((struct sockaddr_in *) addr)->sin_port;
1116 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1117 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1125 port = htons(CIFS_PORT);
1129 port = htons(RFC1001_PORT);
1132 return port == *sport;
1136 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1137 struct sockaddr *srcaddr)
1139 switch (addr->sa_family) {
1141 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1142 struct sockaddr_in *srv_addr4 =
1143 (struct sockaddr_in *)&server->dstaddr;
1145 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1150 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1151 struct sockaddr_in6 *srv_addr6 =
1152 (struct sockaddr_in6 *)&server->dstaddr;
1154 if (!ipv6_addr_equal(&addr6->sin6_addr,
1155 &srv_addr6->sin6_addr))
1157 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1163 return false; /* don't expect to be here */
1166 if (!cifs_match_ipaddr(srcaddr, (struct sockaddr *)&server->srcaddr))
1173 match_security(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
1176 * The select_sectype function should either return the ctx->sectype
1177 * that was specified, or "Unspecified" if that sectype was not
1178 * compatible with the given NEGOTIATE request.
1180 if (server->ops->select_sectype(server, ctx->sectype)
1185 * Now check if signing mode is acceptable. No need to check
1186 * global_secflags at this point since if MUST_SIGN is set then
1187 * the server->sign had better be too.
1189 if (ctx->sign && !server->sign)
1195 static int match_server(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
1197 struct sockaddr *addr = (struct sockaddr *)&ctx->dstaddr;
1199 if (ctx->nosharesock)
1202 /* If multidialect negotiation see if existing sessions match one */
1203 if (strcmp(ctx->vals->version_string, SMB3ANY_VERSION_STRING) == 0) {
1204 if (server->vals->protocol_id < SMB30_PROT_ID)
1206 } else if (strcmp(ctx->vals->version_string,
1207 SMBDEFAULT_VERSION_STRING) == 0) {
1208 if (server->vals->protocol_id < SMB21_PROT_ID)
1210 } else if ((server->vals != ctx->vals) || (server->ops != ctx->ops))
1213 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1216 if (!match_address(server, addr,
1217 (struct sockaddr *)&ctx->srcaddr))
1220 if (!match_port(server, addr))
1223 if (!match_security(server, ctx))
1226 if (server->echo_interval != ctx->echo_interval * HZ)
1229 if (server->rdma != ctx->rdma)
1232 if (server->ignore_signature != ctx->ignore_signature)
1235 if (server->min_offload != ctx->min_offload)
1241 struct TCP_Server_Info *
1242 cifs_find_tcp_session(struct smb3_fs_context *ctx)
1244 struct TCP_Server_Info *server;
1246 spin_lock(&cifs_tcp_ses_lock);
1247 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1249 * Skip ses channels since they're only handled in lower layers
1250 * (e.g. cifs_send_recv).
1252 if (server->is_channel || !match_server(server, ctx))
1255 ++server->srv_count;
1256 spin_unlock(&cifs_tcp_ses_lock);
1257 cifs_dbg(FYI, "Existing tcp session with server found\n");
1260 spin_unlock(&cifs_tcp_ses_lock);
1265 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
1267 struct task_struct *task;
1269 spin_lock(&cifs_tcp_ses_lock);
1270 if (--server->srv_count > 0) {
1271 spin_unlock(&cifs_tcp_ses_lock);
1275 put_net(cifs_net_ns(server));
1277 list_del_init(&server->tcp_ses_list);
1278 spin_unlock(&cifs_tcp_ses_lock);
1280 cancel_delayed_work_sync(&server->echo);
1284 * Avoid deadlock here: reconnect work calls
1285 * cifs_put_tcp_session() at its end. Need to be sure
1286 * that reconnect work does nothing with server pointer after
1289 cancel_delayed_work(&server->reconnect);
1291 cancel_delayed_work_sync(&server->reconnect);
1293 spin_lock(&GlobalMid_Lock);
1294 server->tcpStatus = CifsExiting;
1295 spin_unlock(&GlobalMid_Lock);
1297 cifs_crypto_secmech_release(server);
1298 cifs_fscache_release_client_cookie(server);
1300 kfree(server->session_key.response);
1301 server->session_key.response = NULL;
1302 server->session_key.len = 0;
1304 task = xchg(&server->tsk, NULL);
1306 send_sig(SIGKILL, task, 1);
1309 struct TCP_Server_Info *
1310 cifs_get_tcp_session(struct smb3_fs_context *ctx)
1312 struct TCP_Server_Info *tcp_ses = NULL;
1315 cifs_dbg(FYI, "UNC: %s\n", ctx->UNC);
1317 /* see if we already have a matching tcp_ses */
1318 tcp_ses = cifs_find_tcp_session(ctx);
1322 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1328 tcp_ses->ops = ctx->ops;
1329 tcp_ses->vals = ctx->vals;
1330 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
1331 tcp_ses->hostname = extract_hostname(ctx->UNC);
1332 if (IS_ERR(tcp_ses->hostname)) {
1333 rc = PTR_ERR(tcp_ses->hostname);
1334 goto out_err_crypto_release;
1337 tcp_ses->conn_id = atomic_inc_return(&tcpSesNextId);
1338 tcp_ses->noblockcnt = ctx->rootfs;
1339 tcp_ses->noblocksnd = ctx->noblocksnd || ctx->rootfs;
1340 tcp_ses->noautotune = ctx->noautotune;
1341 tcp_ses->tcp_nodelay = ctx->sockopt_tcp_nodelay;
1342 tcp_ses->rdma = ctx->rdma;
1343 tcp_ses->in_flight = 0;
1344 tcp_ses->max_in_flight = 0;
1345 tcp_ses->credits = 1;
1346 init_waitqueue_head(&tcp_ses->response_q);
1347 init_waitqueue_head(&tcp_ses->request_q);
1348 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1349 mutex_init(&tcp_ses->srv_mutex);
1350 memcpy(tcp_ses->workstation_RFC1001_name,
1351 ctx->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1352 memcpy(tcp_ses->server_RFC1001_name,
1353 ctx->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1354 tcp_ses->session_estab = false;
1355 tcp_ses->sequence_number = 0;
1356 tcp_ses->reconnect_instance = 1;
1357 tcp_ses->lstrp = jiffies;
1358 tcp_ses->compress_algorithm = cpu_to_le16(ctx->compression);
1359 spin_lock_init(&tcp_ses->req_lock);
1360 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1361 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1362 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
1363 INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
1364 mutex_init(&tcp_ses->reconnect_mutex);
1365 memcpy(&tcp_ses->srcaddr, &ctx->srcaddr,
1366 sizeof(tcp_ses->srcaddr));
1367 memcpy(&tcp_ses->dstaddr, &ctx->dstaddr,
1368 sizeof(tcp_ses->dstaddr));
1369 if (ctx->use_client_guid)
1370 memcpy(tcp_ses->client_guid, ctx->client_guid,
1371 SMB2_CLIENT_GUID_SIZE);
1373 generate_random_uuid(tcp_ses->client_guid);
1375 * at this point we are the only ones with the pointer
1376 * to the struct since the kernel thread not created yet
1377 * no need to spinlock this init of tcpStatus or srv_count
1379 tcp_ses->tcpStatus = CifsNew;
1380 ++tcp_ses->srv_count;
1382 if (ctx->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
1383 ctx->echo_interval <= SMB_ECHO_INTERVAL_MAX)
1384 tcp_ses->echo_interval = ctx->echo_interval * HZ;
1386 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
1387 if (tcp_ses->rdma) {
1388 #ifndef CONFIG_CIFS_SMB_DIRECT
1389 cifs_dbg(VFS, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
1391 goto out_err_crypto_release;
1393 tcp_ses->smbd_conn = smbd_get_connection(
1394 tcp_ses, (struct sockaddr *)&ctx->dstaddr);
1395 if (tcp_ses->smbd_conn) {
1396 cifs_dbg(VFS, "RDMA transport established\n");
1398 goto smbd_connected;
1401 goto out_err_crypto_release;
1404 rc = ip_connect(tcp_ses);
1406 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
1407 goto out_err_crypto_release;
1411 * since we're in a cifs function already, we know that
1412 * this will succeed. No need for try_module_get().
1414 __module_get(THIS_MODULE);
1415 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
1417 if (IS_ERR(tcp_ses->tsk)) {
1418 rc = PTR_ERR(tcp_ses->tsk);
1419 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
1420 module_put(THIS_MODULE);
1421 goto out_err_crypto_release;
1423 tcp_ses->min_offload = ctx->min_offload;
1424 tcp_ses->tcpStatus = CifsNeedNegotiate;
1426 if ((ctx->max_credits < 20) || (ctx->max_credits > 60000))
1427 tcp_ses->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
1429 tcp_ses->max_credits = ctx->max_credits;
1431 tcp_ses->nr_targets = 1;
1432 tcp_ses->ignore_signature = ctx->ignore_signature;
1433 /* thread spawned, put it on the list */
1434 spin_lock(&cifs_tcp_ses_lock);
1435 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1436 spin_unlock(&cifs_tcp_ses_lock);
1438 cifs_fscache_get_client_cookie(tcp_ses);
1440 /* queue echo request delayed work */
1441 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
1445 out_err_crypto_release:
1446 cifs_crypto_secmech_release(tcp_ses);
1448 put_net(cifs_net_ns(tcp_ses));
1452 if (!IS_ERR(tcp_ses->hostname))
1453 kfree(tcp_ses->hostname);
1454 if (tcp_ses->ssocket)
1455 sock_release(tcp_ses->ssocket);
1461 static int match_session(struct cifs_ses *ses, struct smb3_fs_context *ctx)
1463 if (ctx->sectype != Unspecified &&
1464 ctx->sectype != ses->sectype)
1468 * If an existing session is limited to less channels than
1469 * requested, it should not be reused
1471 if (ses->chan_max < ctx->max_channels)
1474 switch (ses->sectype) {
1476 if (!uid_eq(ctx->cred_uid, ses->cred_uid))
1480 /* NULL username means anonymous session */
1481 if (ses->user_name == NULL) {
1487 /* anything else takes username/password */
1488 if (strncmp(ses->user_name,
1489 ctx->username ? ctx->username : "",
1490 CIFS_MAX_USERNAME_LEN))
1492 if ((ctx->username && strlen(ctx->username) != 0) &&
1493 ses->password != NULL &&
1494 strncmp(ses->password,
1495 ctx->password ? ctx->password : "",
1496 CIFS_MAX_PASSWORD_LEN))
1503 * cifs_setup_ipc - helper to setup the IPC tcon for the session
1505 * A new IPC connection is made and stored in the session
1506 * tcon_ipc. The IPC tcon has the same lifetime as the session.
1509 cifs_setup_ipc(struct cifs_ses *ses, struct smb3_fs_context *ctx)
1512 struct cifs_tcon *tcon;
1513 char unc[SERVER_NAME_LENGTH + sizeof("//x/IPC$")] = {0};
1515 struct TCP_Server_Info *server = ses->server;
1518 * If the mount request that resulted in the creation of the
1519 * session requires encryption, force IPC to be encrypted too.
1522 if (server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)
1525 cifs_server_dbg(VFS,
1526 "IPC: server doesn't support encryption\n");
1531 tcon = tconInfoAlloc();
1535 scnprintf(unc, sizeof(unc), "\\\\%s\\IPC$", server->hostname);
1541 rc = server->ops->tree_connect(xid, ses, unc, tcon, ctx->local_nls);
1545 cifs_server_dbg(VFS, "failed to connect to IPC (rc=%d)\n", rc);
1550 cifs_dbg(FYI, "IPC tcon rc = %d ipc tid = %d\n", rc, tcon->tid);
1552 ses->tcon_ipc = tcon;
1558 * cifs_free_ipc - helper to release the session IPC tcon
1560 * Needs to be called everytime a session is destroyed
1563 cifs_free_ipc(struct cifs_ses *ses)
1566 struct cifs_tcon *tcon = ses->tcon_ipc;
1571 if (ses->server->ops->tree_disconnect) {
1573 rc = ses->server->ops->tree_disconnect(xid, tcon);
1578 cifs_dbg(FYI, "failed to disconnect IPC tcon (rc=%d)\n", rc);
1581 ses->tcon_ipc = NULL;
1585 static struct cifs_ses *
1586 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
1588 struct cifs_ses *ses;
1590 spin_lock(&cifs_tcp_ses_lock);
1591 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1592 if (ses->status == CifsExiting)
1594 if (!match_session(ses, ctx))
1597 spin_unlock(&cifs_tcp_ses_lock);
1600 spin_unlock(&cifs_tcp_ses_lock);
1604 void cifs_put_smb_ses(struct cifs_ses *ses)
1606 unsigned int rc, xid;
1607 struct TCP_Server_Info *server = ses->server;
1609 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
1611 spin_lock(&cifs_tcp_ses_lock);
1612 if (ses->status == CifsExiting) {
1613 spin_unlock(&cifs_tcp_ses_lock);
1616 if (--ses->ses_count > 0) {
1617 spin_unlock(&cifs_tcp_ses_lock);
1620 if (ses->status == CifsGood)
1621 ses->status = CifsExiting;
1622 spin_unlock(&cifs_tcp_ses_lock);
1626 if (ses->status == CifsExiting && server->ops->logoff) {
1628 rc = server->ops->logoff(xid, ses);
1630 cifs_server_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
1635 spin_lock(&cifs_tcp_ses_lock);
1636 list_del_init(&ses->smb_ses_list);
1637 spin_unlock(&cifs_tcp_ses_lock);
1639 /* close any extra channels */
1640 if (ses->chan_count > 1) {
1643 for (i = 1; i < ses->chan_count; i++)
1644 cifs_put_tcp_session(ses->chans[i].server, 0);
1648 cifs_put_tcp_session(server, 0);
1653 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
1654 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
1656 /* Populate username and pw fields from keyring if possible */
1658 cifs_set_cifscreds(struct smb3_fs_context *ctx, struct cifs_ses *ses)
1662 const char *delim, *payload;
1666 struct TCP_Server_Info *server = ses->server;
1667 struct sockaddr_in *sa;
1668 struct sockaddr_in6 *sa6;
1669 const struct user_key_payload *upayload;
1671 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
1675 /* try to find an address key first */
1676 switch (server->dstaddr.ss_family) {
1678 sa = (struct sockaddr_in *)&server->dstaddr;
1679 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
1682 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
1683 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
1686 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
1687 server->dstaddr.ss_family);
1692 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
1693 key = request_key(&key_type_logon, desc, "");
1695 if (!ses->domainName) {
1696 cifs_dbg(FYI, "domainName is NULL\n");
1701 /* didn't work, try to find a domain key */
1702 sprintf(desc, "cifs:d:%s", ses->domainName);
1703 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
1704 key = request_key(&key_type_logon, desc, "");
1712 down_read(&key->sem);
1713 upayload = user_key_payload_locked(key);
1714 if (IS_ERR_OR_NULL(upayload)) {
1715 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
1719 /* find first : in payload */
1720 payload = upayload->data;
1721 delim = strnchr(payload, upayload->datalen, ':');
1722 cifs_dbg(FYI, "payload=%s\n", payload);
1724 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
1730 len = delim - payload;
1731 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
1732 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
1738 ctx->username = kstrndup(payload, len, GFP_KERNEL);
1739 if (!ctx->username) {
1740 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
1745 cifs_dbg(FYI, "%s: username=%s\n", __func__, ctx->username);
1747 len = key->datalen - (len + 1);
1748 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
1749 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
1751 kfree(ctx->username);
1752 ctx->username = NULL;
1757 ctx->password = kstrndup(delim, len, GFP_KERNEL);
1758 if (!ctx->password) {
1759 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
1762 kfree(ctx->username);
1763 ctx->username = NULL;
1768 * If we have a domain key then we must set the domainName in the
1771 if (is_domain && ses->domainName) {
1772 ctx->domainname = kstrdup(ses->domainName, GFP_KERNEL);
1773 if (!ctx->domainname) {
1774 cifs_dbg(FYI, "Unable to allocate %zd bytes for domain\n",
1777 kfree(ctx->username);
1778 ctx->username = NULL;
1779 kfree_sensitive(ctx->password);
1780 ctx->password = NULL;
1790 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
1793 #else /* ! CONFIG_KEYS */
1795 cifs_set_cifscreds(struct smb3_fs_context *ctx __attribute__((unused)),
1796 struct cifs_ses *ses __attribute__((unused)))
1800 #endif /* CONFIG_KEYS */
1803 * cifs_get_smb_ses - get a session matching @ctx data from @server
1805 * This function assumes it is being called from cifs_mount() where we
1806 * already got a server reference (server refcount +1). See
1807 * cifs_get_tcon() for refcount explanations.
1810 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
1814 struct cifs_ses *ses;
1815 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1816 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
1820 ses = cifs_find_smb_ses(server, ctx);
1822 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
1825 mutex_lock(&ses->session_mutex);
1826 rc = cifs_negotiate_protocol(xid, ses);
1828 mutex_unlock(&ses->session_mutex);
1829 /* problem -- put our ses reference */
1830 cifs_put_smb_ses(ses);
1834 if (ses->need_reconnect) {
1835 cifs_dbg(FYI, "Session needs reconnect\n");
1836 rc = cifs_setup_session(xid, ses,
1839 mutex_unlock(&ses->session_mutex);
1840 /* problem -- put our reference */
1841 cifs_put_smb_ses(ses);
1846 mutex_unlock(&ses->session_mutex);
1848 /* existing SMB ses has a server reference already */
1849 cifs_put_tcp_session(server, 0);
1854 cifs_dbg(FYI, "Existing smb sess not found\n");
1855 ses = sesInfoAlloc();
1859 /* new SMB session uses our server ref */
1860 ses->server = server;
1861 if (server->dstaddr.ss_family == AF_INET6)
1862 sprintf(ses->ip_addr, "%pI6", &addr6->sin6_addr);
1864 sprintf(ses->ip_addr, "%pI4", &addr->sin_addr);
1866 if (ctx->username) {
1867 ses->user_name = kstrdup(ctx->username, GFP_KERNEL);
1868 if (!ses->user_name)
1872 /* ctx->password freed at unmount */
1873 if (ctx->password) {
1874 ses->password = kstrdup(ctx->password, GFP_KERNEL);
1878 if (ctx->domainname) {
1879 ses->domainName = kstrdup(ctx->domainname, GFP_KERNEL);
1880 if (!ses->domainName)
1883 if (ctx->domainauto)
1884 ses->domainAuto = ctx->domainauto;
1885 ses->cred_uid = ctx->cred_uid;
1886 ses->linux_uid = ctx->linux_uid;
1888 ses->sectype = ctx->sectype;
1889 ses->sign = ctx->sign;
1890 mutex_lock(&ses->session_mutex);
1892 /* add server as first channel */
1893 ses->chans[0].server = server;
1894 ses->chan_count = 1;
1895 ses->chan_max = ctx->multichannel ? ctx->max_channels:1;
1897 rc = cifs_negotiate_protocol(xid, ses);
1899 rc = cifs_setup_session(xid, ses, ctx->local_nls);
1901 /* each channel uses a different signing key */
1902 memcpy(ses->chans[0].signkey, ses->smb3signingkey,
1903 sizeof(ses->smb3signingkey));
1905 mutex_unlock(&ses->session_mutex);
1909 /* success, put it on the list and add it as first channel */
1910 spin_lock(&cifs_tcp_ses_lock);
1911 list_add(&ses->smb_ses_list, &server->smb_ses_list);
1912 spin_unlock(&cifs_tcp_ses_lock);
1916 cifs_setup_ipc(ses, ctx);
1926 static int match_tcon(struct cifs_tcon *tcon, struct smb3_fs_context *ctx)
1928 if (tcon->tidStatus == CifsExiting)
1930 if (strncmp(tcon->treeName, ctx->UNC, MAX_TREE_SIZE))
1932 if (tcon->seal != ctx->seal)
1934 if (tcon->snapshot_time != ctx->snapshot_time)
1936 if (tcon->handle_timeout != ctx->handle_timeout)
1938 if (tcon->no_lease != ctx->no_lease)
1940 if (tcon->nodelete != ctx->nodelete)
1945 static struct cifs_tcon *
1946 cifs_find_tcon(struct cifs_ses *ses, struct smb3_fs_context *ctx)
1948 struct list_head *tmp;
1949 struct cifs_tcon *tcon;
1951 spin_lock(&cifs_tcp_ses_lock);
1952 list_for_each(tmp, &ses->tcon_list) {
1953 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
1954 #ifdef CONFIG_CIFS_DFS_UPCALL
1958 if (!match_tcon(tcon, ctx))
1961 spin_unlock(&cifs_tcp_ses_lock);
1964 spin_unlock(&cifs_tcp_ses_lock);
1969 cifs_put_tcon(struct cifs_tcon *tcon)
1972 struct cifs_ses *ses;
1975 * IPC tcon share the lifetime of their session and are
1976 * destroyed in the session put function
1978 if (tcon == NULL || tcon->ipc)
1982 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
1983 spin_lock(&cifs_tcp_ses_lock);
1984 if (--tcon->tc_count > 0) {
1985 spin_unlock(&cifs_tcp_ses_lock);
1989 if (tcon->use_witness) {
1992 rc = cifs_swn_unregister(tcon);
1994 cifs_dbg(VFS, "%s: Failed to unregister for witness notifications: %d\n",
1999 list_del_init(&tcon->tcon_list);
2000 spin_unlock(&cifs_tcp_ses_lock);
2003 if (ses->server->ops->tree_disconnect)
2004 ses->server->ops->tree_disconnect(xid, tcon);
2007 cifs_fscache_release_super_cookie(tcon);
2009 cifs_put_smb_ses(ses);
2013 * cifs_get_tcon - get a tcon matching @ctx data from @ses
2015 * - tcon refcount is the number of mount points using the tcon.
2016 * - ses refcount is the number of tcon using the session.
2018 * 1. This function assumes it is being called from cifs_mount() where
2019 * we already got a session reference (ses refcount +1).
2021 * 2. Since we're in the context of adding a mount point, the end
2022 * result should be either:
2024 * a) a new tcon already allocated with refcount=1 (1 mount point) and
2025 * its session refcount incremented (1 new tcon). This +1 was
2026 * already done in (1).
2028 * b) an existing tcon with refcount+1 (add a mount point to it) and
2029 * identical ses refcount (no new tcon). Because of (1) we need to
2030 * decrement the ses refcount.
2032 static struct cifs_tcon *
2033 cifs_get_tcon(struct cifs_ses *ses, struct smb3_fs_context *ctx)
2036 struct cifs_tcon *tcon;
2038 tcon = cifs_find_tcon(ses, ctx);
2041 * tcon has refcount already incremented but we need to
2042 * decrement extra ses reference gotten by caller (case b)
2044 cifs_dbg(FYI, "Found match on UNC path\n");
2045 cifs_put_smb_ses(ses);
2049 if (!ses->server->ops->tree_connect) {
2054 tcon = tconInfoAlloc();
2060 if (ctx->snapshot_time) {
2061 if (ses->server->vals->protocol_id == 0) {
2063 "Use SMB2 or later for snapshot mount option\n");
2067 tcon->snapshot_time = ctx->snapshot_time;
2070 if (ctx->handle_timeout) {
2071 if (ses->server->vals->protocol_id == 0) {
2073 "Use SMB2.1 or later for handle timeout option\n");
2077 tcon->handle_timeout = ctx->handle_timeout;
2081 if (ctx->password) {
2082 tcon->password = kstrdup(ctx->password, GFP_KERNEL);
2083 if (!tcon->password) {
2090 if (ses->server->vals->protocol_id == 0) {
2092 "SMB3 or later required for encryption\n");
2095 } else if (tcon->ses->server->capabilities &
2096 SMB2_GLOBAL_CAP_ENCRYPTION)
2099 cifs_dbg(VFS, "Encryption is not supported on share\n");
2105 if (ctx->linux_ext) {
2106 if (ses->server->posix_ext_supported) {
2107 tcon->posix_extensions = true;
2108 pr_warn_once("SMB3.11 POSIX Extensions are experimental\n");
2110 cifs_dbg(VFS, "Server does not support mounting with posix SMB3.11 extensions\n");
2117 * BB Do we need to wrap session_mutex around this TCon call and Unix
2118 * SetFS as we do on SessSetup and reconnect?
2121 rc = ses->server->ops->tree_connect(xid, ses, ctx->UNC, tcon,
2124 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2128 tcon->use_persistent = false;
2129 /* check if SMB2 or later, CIFS does not support persistent handles */
2130 if (ctx->persistent) {
2131 if (ses->server->vals->protocol_id == 0) {
2133 "SMB3 or later required for persistent handles\n");
2136 } else if (ses->server->capabilities &
2137 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2138 tcon->use_persistent = true;
2139 else /* persistent handles requested but not supported */ {
2141 "Persistent handles not supported on share\n");
2145 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2146 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2147 && (ctx->nopersistent == false)) {
2148 cifs_dbg(FYI, "enabling persistent handles\n");
2149 tcon->use_persistent = true;
2150 } else if (ctx->resilient) {
2151 if (ses->server->vals->protocol_id == 0) {
2153 "SMB2.1 or later required for resilient handles\n");
2157 tcon->use_resilient = true;
2160 tcon->use_witness = false;
2161 if (IS_ENABLED(CONFIG_CIFS_SWN_UPCALL) && ctx->witness) {
2162 if (ses->server->vals->protocol_id >= SMB30_PROT_ID) {
2163 if (tcon->capabilities & SMB2_SHARE_CAP_CLUSTER) {
2165 * Set witness in use flag in first place
2166 * to retry registration in the echo task
2168 tcon->use_witness = true;
2169 /* And try to register immediately */
2170 rc = cifs_swn_register(tcon);
2172 cifs_dbg(VFS, "Failed to register for witness notifications: %d\n", rc);
2176 /* TODO: try to extend for non-cluster uses (eg multichannel) */
2177 cifs_dbg(VFS, "witness requested on mount but no CLUSTER capability on share\n");
2182 cifs_dbg(VFS, "SMB3 or later required for witness option\n");
2188 /* If the user really knows what they are doing they can override */
2189 if (tcon->share_flags & SMB2_SHAREFLAG_NO_CACHING) {
2191 cifs_dbg(VFS, "cache=ro requested on mount but NO_CACHING flag set on share\n");
2192 else if (ctx->cache_rw)
2193 cifs_dbg(VFS, "cache=singleclient requested on mount but NO_CACHING flag set on share\n");
2196 if (ctx->no_lease) {
2197 if (ses->server->vals->protocol_id == 0) {
2199 "SMB2 or later required for nolease option\n");
2203 tcon->no_lease = ctx->no_lease;
2207 * We can have only one retry value for a connection to a share so for
2208 * resources mounted more than once to the same server share the last
2209 * value passed in for the retry flag is used.
2211 tcon->retry = ctx->retry;
2212 tcon->nocase = ctx->nocase;
2213 if (ses->server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING)
2214 tcon->nohandlecache = ctx->nohandlecache;
2216 tcon->nohandlecache = true;
2217 tcon->nodelete = ctx->nodelete;
2218 tcon->local_lease = ctx->local_lease;
2219 INIT_LIST_HEAD(&tcon->pending_opens);
2221 spin_lock(&cifs_tcp_ses_lock);
2222 list_add(&tcon->tcon_list, &ses->tcon_list);
2223 spin_unlock(&cifs_tcp_ses_lock);
2225 cifs_fscache_get_super_cookie(tcon);
2235 cifs_put_tlink(struct tcon_link *tlink)
2237 if (!tlink || IS_ERR(tlink))
2240 if (!atomic_dec_and_test(&tlink->tl_count) ||
2241 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2242 tlink->tl_time = jiffies;
2246 if (!IS_ERR(tlink_tcon(tlink)))
2247 cifs_put_tcon(tlink_tcon(tlink));
2253 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2255 struct cifs_sb_info *old = CIFS_SB(sb);
2256 struct cifs_sb_info *new = mnt_data->cifs_sb;
2257 unsigned int oldflags = old->mnt_cifs_flags & CIFS_MOUNT_MASK;
2258 unsigned int newflags = new->mnt_cifs_flags & CIFS_MOUNT_MASK;
2260 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2263 if (old->mnt_cifs_serverino_autodisabled)
2264 newflags &= ~CIFS_MOUNT_SERVER_INUM;
2266 if (oldflags != newflags)
2270 * We want to share sb only if we don't specify an r/wsize or
2271 * specified r/wsize is greater than or equal to existing one.
2273 if (new->ctx->wsize && new->ctx->wsize < old->ctx->wsize)
2276 if (new->ctx->rsize && new->ctx->rsize < old->ctx->rsize)
2279 if (!uid_eq(old->ctx->linux_uid, new->ctx->linux_uid) ||
2280 !gid_eq(old->ctx->linux_gid, new->ctx->linux_gid))
2283 if (old->ctx->file_mode != new->ctx->file_mode ||
2284 old->ctx->dir_mode != new->ctx->dir_mode)
2287 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2290 if (old->ctx->acregmax != new->ctx->acregmax)
2292 if (old->ctx->acdirmax != new->ctx->acdirmax)
2299 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2301 struct cifs_sb_info *old = CIFS_SB(sb);
2302 struct cifs_sb_info *new = mnt_data->cifs_sb;
2303 bool old_set = (old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
2305 bool new_set = (new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
2308 if (old_set && new_set && !strcmp(new->prepath, old->prepath))
2310 else if (!old_set && !new_set)
2317 cifs_match_super(struct super_block *sb, void *data)
2319 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2320 struct smb3_fs_context *ctx;
2321 struct cifs_sb_info *cifs_sb;
2322 struct TCP_Server_Info *tcp_srv;
2323 struct cifs_ses *ses;
2324 struct cifs_tcon *tcon;
2325 struct tcon_link *tlink;
2328 spin_lock(&cifs_tcp_ses_lock);
2329 cifs_sb = CIFS_SB(sb);
2330 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2331 if (IS_ERR(tlink)) {
2332 spin_unlock(&cifs_tcp_ses_lock);
2335 tcon = tlink_tcon(tlink);
2337 tcp_srv = ses->server;
2339 ctx = mnt_data->ctx;
2341 if (!match_server(tcp_srv, ctx) ||
2342 !match_session(ses, ctx) ||
2343 !match_tcon(tcon, ctx) ||
2344 !match_prepath(sb, mnt_data)) {
2349 rc = compare_mount_options(sb, mnt_data);
2351 spin_unlock(&cifs_tcp_ses_lock);
2352 cifs_put_tlink(tlink);
2356 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2357 static struct lock_class_key cifs_key[2];
2358 static struct lock_class_key cifs_slock_key[2];
2361 cifs_reclassify_socket4(struct socket *sock)
2363 struct sock *sk = sock->sk;
2364 BUG_ON(!sock_allow_reclassification(sk));
2365 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2366 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2370 cifs_reclassify_socket6(struct socket *sock)
2372 struct sock *sk = sock->sk;
2373 BUG_ON(!sock_allow_reclassification(sk));
2374 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2375 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2379 cifs_reclassify_socket4(struct socket *sock)
2384 cifs_reclassify_socket6(struct socket *sock)
2389 /* See RFC1001 section 14 on representation of Netbios names */
2390 static void rfc1002mangle(char *target, char *source, unsigned int length)
2394 for (i = 0, j = 0; i < (length); i++) {
2395 /* mask a nibble at a time and encode */
2396 target[j] = 'A' + (0x0F & (source[i] >> 4));
2397 target[j+1] = 'A' + (0x0F & source[i]);
2404 bind_socket(struct TCP_Server_Info *server)
2407 if (server->srcaddr.ss_family != AF_UNSPEC) {
2408 /* Bind to the specified local IP address */
2409 struct socket *socket = server->ssocket;
2410 rc = socket->ops->bind(socket,
2411 (struct sockaddr *) &server->srcaddr,
2412 sizeof(server->srcaddr));
2414 struct sockaddr_in *saddr4;
2415 struct sockaddr_in6 *saddr6;
2416 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2417 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2418 if (saddr6->sin6_family == AF_INET6)
2419 cifs_server_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2420 &saddr6->sin6_addr, rc);
2422 cifs_server_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2423 &saddr4->sin_addr.s_addr, rc);
2430 ip_rfc1001_connect(struct TCP_Server_Info *server)
2434 * some servers require RFC1001 sessinit before sending
2435 * negprot - BB check reconnection in case where second
2436 * sessinit is sent but no second negprot
2438 struct rfc1002_session_packet *ses_init_buf;
2439 struct smb_hdr *smb_buf;
2440 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2443 ses_init_buf->trailer.session_req.called_len = 32;
2445 if (server->server_RFC1001_name[0] != 0)
2446 rfc1002mangle(ses_init_buf->trailer.
2447 session_req.called_name,
2448 server->server_RFC1001_name,
2449 RFC1001_NAME_LEN_WITH_NULL);
2451 rfc1002mangle(ses_init_buf->trailer.
2452 session_req.called_name,
2453 DEFAULT_CIFS_CALLED_NAME,
2454 RFC1001_NAME_LEN_WITH_NULL);
2456 ses_init_buf->trailer.session_req.calling_len = 32;
2459 * calling name ends in null (byte 16) from old smb
2462 if (server->workstation_RFC1001_name[0] != 0)
2463 rfc1002mangle(ses_init_buf->trailer.
2464 session_req.calling_name,
2465 server->workstation_RFC1001_name,
2466 RFC1001_NAME_LEN_WITH_NULL);
2468 rfc1002mangle(ses_init_buf->trailer.
2469 session_req.calling_name,
2471 RFC1001_NAME_LEN_WITH_NULL);
2473 ses_init_buf->trailer.session_req.scope1 = 0;
2474 ses_init_buf->trailer.session_req.scope2 = 0;
2475 smb_buf = (struct smb_hdr *)ses_init_buf;
2477 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2478 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2479 rc = smb_send(server, smb_buf, 0x44);
2480 kfree(ses_init_buf);
2482 * RFC1001 layer in at least one server
2483 * requires very short break before negprot
2484 * presumably because not expecting negprot
2485 * to follow so fast. This is a simple
2486 * solution that works without
2487 * complicating the code and causes no
2488 * significant slowing down on mount
2491 usleep_range(1000, 2000);
2494 * else the negprot may still work without this
2495 * even though malloc failed
2502 generic_ip_connect(struct TCP_Server_Info *server)
2507 struct socket *socket = server->ssocket;
2508 struct sockaddr *saddr;
2510 saddr = (struct sockaddr *) &server->dstaddr;
2512 if (server->dstaddr.ss_family == AF_INET6) {
2513 struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)&server->dstaddr;
2515 sport = ipv6->sin6_port;
2516 slen = sizeof(struct sockaddr_in6);
2518 cifs_dbg(FYI, "%s: connecting to [%pI6]:%d\n", __func__, &ipv6->sin6_addr,
2521 struct sockaddr_in *ipv4 = (struct sockaddr_in *)&server->dstaddr;
2523 sport = ipv4->sin_port;
2524 slen = sizeof(struct sockaddr_in);
2526 cifs_dbg(FYI, "%s: connecting to %pI4:%d\n", __func__, &ipv4->sin_addr,
2530 if (socket == NULL) {
2531 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2532 IPPROTO_TCP, &socket, 1);
2534 cifs_server_dbg(VFS, "Error %d creating socket\n", rc);
2535 server->ssocket = NULL;
2539 /* BB other socket options to set KEEPALIVE, NODELAY? */
2540 cifs_dbg(FYI, "Socket created\n");
2541 server->ssocket = socket;
2542 socket->sk->sk_allocation = GFP_NOFS;
2543 if (sfamily == AF_INET6)
2544 cifs_reclassify_socket6(socket);
2546 cifs_reclassify_socket4(socket);
2549 rc = bind_socket(server);
2554 * Eventually check for other socket options to change from
2555 * the default. sock_setsockopt not used because it expects
2558 socket->sk->sk_rcvtimeo = 7 * HZ;
2559 socket->sk->sk_sndtimeo = 5 * HZ;
2561 /* make the bufsizes depend on wsize/rsize and max requests */
2562 if (server->noautotune) {
2563 if (socket->sk->sk_sndbuf < (200 * 1024))
2564 socket->sk->sk_sndbuf = 200 * 1024;
2565 if (socket->sk->sk_rcvbuf < (140 * 1024))
2566 socket->sk->sk_rcvbuf = 140 * 1024;
2569 if (server->tcp_nodelay)
2570 tcp_sock_set_nodelay(socket->sk);
2572 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
2573 socket->sk->sk_sndbuf,
2574 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2576 rc = socket->ops->connect(socket, saddr, slen,
2577 server->noblockcnt ? O_NONBLOCK : 0);
2579 * When mounting SMB root file systems, we do not want to block in
2580 * connect. Otherwise bail out and then let cifs_reconnect() perform
2581 * reconnect failover - if possible.
2583 if (server->noblockcnt && rc == -EINPROGRESS)
2586 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
2587 sock_release(socket);
2588 server->ssocket = NULL;
2592 if (sport == htons(RFC1001_PORT))
2593 rc = ip_rfc1001_connect(server);
2599 ip_connect(struct TCP_Server_Info *server)
2602 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2603 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2605 if (server->dstaddr.ss_family == AF_INET6)
2606 sport = &addr6->sin6_port;
2608 sport = &addr->sin_port;
2613 /* try with 445 port at first */
2614 *sport = htons(CIFS_PORT);
2616 rc = generic_ip_connect(server);
2620 /* if it failed, try with 139 port */
2621 *sport = htons(RFC1001_PORT);
2624 return generic_ip_connect(server);
2627 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
2628 struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx)
2631 * If we are reconnecting then should we check to see if
2632 * any requested capabilities changed locally e.g. via
2633 * remount but we can not do much about it here
2634 * if they have (even if we could detect it by the following)
2635 * Perhaps we could add a backpointer to array of sb from tcon
2636 * or if we change to make all sb to same share the same
2637 * sb as NFS - then we only have one backpointer to sb.
2638 * What if we wanted to mount the server share twice once with
2639 * and once without posixacls or posix paths?
2641 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2643 if (ctx && ctx->no_linux_ext) {
2644 tcon->fsUnixInfo.Capability = 0;
2645 tcon->unix_ext = 0; /* Unix Extensions disabled */
2646 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
2649 tcon->unix_ext = 1; /* Unix Extensions supported */
2651 if (!tcon->unix_ext) {
2652 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
2656 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2657 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2658 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
2660 * check for reconnect case in which we do not
2661 * want to change the mount behavior if we can avoid it
2665 * turn off POSIX ACL and PATHNAMES if not set
2666 * originally at mount time
2668 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2669 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2670 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2671 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2672 cifs_dbg(VFS, "POSIXPATH support change\n");
2673 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2674 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2675 cifs_dbg(VFS, "possible reconnect error\n");
2676 cifs_dbg(VFS, "server disabled POSIX path support\n");
2680 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2681 cifs_dbg(VFS, "per-share encryption not supported yet\n");
2683 cap &= CIFS_UNIX_CAP_MASK;
2684 if (ctx && ctx->no_psx_acl)
2685 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2686 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2687 cifs_dbg(FYI, "negotiated posix acl support\n");
2689 cifs_sb->mnt_cifs_flags |=
2690 CIFS_MOUNT_POSIXACL;
2693 if (ctx && ctx->posix_paths == 0)
2694 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2695 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2696 cifs_dbg(FYI, "negotiate posix pathnames\n");
2698 cifs_sb->mnt_cifs_flags |=
2699 CIFS_MOUNT_POSIX_PATHS;
2702 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
2703 #ifdef CONFIG_CIFS_DEBUG2
2704 if (cap & CIFS_UNIX_FCNTL_CAP)
2705 cifs_dbg(FYI, "FCNTL cap\n");
2706 if (cap & CIFS_UNIX_EXTATTR_CAP)
2707 cifs_dbg(FYI, "EXTATTR cap\n");
2708 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2709 cifs_dbg(FYI, "POSIX path cap\n");
2710 if (cap & CIFS_UNIX_XATTR_CAP)
2711 cifs_dbg(FYI, "XATTR cap\n");
2712 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2713 cifs_dbg(FYI, "POSIX ACL cap\n");
2714 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2715 cifs_dbg(FYI, "very large read cap\n");
2716 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2717 cifs_dbg(FYI, "very large write cap\n");
2718 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
2719 cifs_dbg(FYI, "transport encryption cap\n");
2720 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
2721 cifs_dbg(FYI, "mandatory transport encryption cap\n");
2722 #endif /* CIFS_DEBUG2 */
2723 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2725 cifs_dbg(FYI, "resetting capabilities failed\n");
2727 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");
2733 int cifs_setup_cifs_sb(struct cifs_sb_info *cifs_sb)
2735 struct smb3_fs_context *ctx = cifs_sb->ctx;
2737 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2739 spin_lock_init(&cifs_sb->tlink_tree_lock);
2740 cifs_sb->tlink_tree = RB_ROOT;
2742 cifs_dbg(FYI, "file mode: %04ho dir mode: %04ho\n",
2743 ctx->file_mode, ctx->dir_mode);
2745 /* this is needed for ASCII cp to Unicode converts */
2746 if (ctx->iocharset == NULL) {
2747 /* load_nls_default cannot return null */
2748 cifs_sb->local_nls = load_nls_default();
2750 cifs_sb->local_nls = load_nls(ctx->iocharset);
2751 if (cifs_sb->local_nls == NULL) {
2752 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
2757 ctx->local_nls = cifs_sb->local_nls;
2759 smb3_update_mnt_flags(cifs_sb);
2762 cifs_dbg(FYI, "mounting share using direct i/o\n");
2763 if (ctx->cache_ro) {
2764 cifs_dbg(VFS, "mounting share with read only caching. Ensure that the share will not be modified while in use.\n");
2765 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RO_CACHE;
2766 } else if (ctx->cache_rw) {
2767 cifs_dbg(VFS, "mounting share in single client RW caching mode. Ensure that no other systems will be accessing the share.\n");
2768 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_RO_CACHE |
2769 CIFS_MOUNT_RW_CACHE);
2772 if ((ctx->cifs_acl) && (ctx->dynperm))
2773 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
2776 cifs_sb->prepath = kstrdup(ctx->prepath, GFP_KERNEL);
2777 if (cifs_sb->prepath == NULL)
2779 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
2785 /* Release all succeed connections */
2786 static inline void mount_put_conns(struct cifs_sb_info *cifs_sb,
2788 struct TCP_Server_Info *server,
2789 struct cifs_ses *ses, struct cifs_tcon *tcon)
2794 cifs_put_tcon(tcon);
2796 cifs_put_smb_ses(ses);
2798 cifs_put_tcp_session(server, 0);
2799 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
2803 /* Get connections for tcp, ses and tcon */
2804 static int mount_get_conns(struct smb3_fs_context *ctx, struct cifs_sb_info *cifs_sb,
2806 struct TCP_Server_Info **nserver,
2807 struct cifs_ses **nses, struct cifs_tcon **ntcon)
2810 struct TCP_Server_Info *server;
2811 struct cifs_ses *ses;
2812 struct cifs_tcon *tcon;
2820 /* get a reference to a tcp session */
2821 server = cifs_get_tcp_session(ctx);
2822 if (IS_ERR(server)) {
2823 rc = PTR_ERR(server);
2829 /* get a reference to a SMB session */
2830 ses = cifs_get_smb_ses(server, ctx);
2838 if ((ctx->persistent == true) && (!(ses->server->capabilities &
2839 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES))) {
2840 cifs_server_dbg(VFS, "persistent handles not supported by server\n");
2844 /* search for existing tcon to this server share */
2845 tcon = cifs_get_tcon(ses, ctx);
2853 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
2854 if (tcon->posix_extensions)
2855 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
2857 /* tell server which Unix caps we support */
2858 if (cap_unix(tcon->ses)) {
2860 * reset of caps checks mount to see if unix extensions disabled
2861 * for just this mount.
2863 reset_cifs_unix_caps(*xid, tcon, cifs_sb, ctx);
2864 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
2865 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
2866 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP))
2869 tcon->unix_ext = 0; /* server does not support them */
2871 /* do not care if a following call succeed - informational */
2872 if (!tcon->pipe && server->ops->qfs_tcon) {
2873 server->ops->qfs_tcon(*xid, tcon, cifs_sb);
2874 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE) {
2875 if (tcon->fsDevInfo.DeviceCharacteristics &
2876 cpu_to_le32(FILE_READ_ONLY_DEVICE))
2877 cifs_dbg(VFS, "mounted to read only share\n");
2878 else if ((cifs_sb->mnt_cifs_flags &
2879 CIFS_MOUNT_RW_CACHE) == 0)
2880 cifs_dbg(VFS, "read only mount of RW share\n");
2881 /* no need to log a RW mount of a typical RW share */
2886 * Clamp the rsize/wsize mount arguments if they are too big for the server
2887 * and set the rsize/wsize to the negotiated values if not passed in by
2890 if ((cifs_sb->ctx->wsize == 0) ||
2891 (cifs_sb->ctx->wsize > server->ops->negotiate_wsize(tcon, ctx)))
2892 cifs_sb->ctx->wsize = server->ops->negotiate_wsize(tcon, ctx);
2893 if ((cifs_sb->ctx->rsize == 0) ||
2894 (cifs_sb->ctx->rsize > server->ops->negotiate_rsize(tcon, ctx)))
2895 cifs_sb->ctx->rsize = server->ops->negotiate_rsize(tcon, ctx);
2900 static int mount_setup_tlink(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
2901 struct cifs_tcon *tcon)
2903 struct tcon_link *tlink;
2905 /* hang the tcon off of the superblock */
2906 tlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
2910 tlink->tl_uid = ses->linux_uid;
2911 tlink->tl_tcon = tcon;
2912 tlink->tl_time = jiffies;
2913 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
2914 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
2916 cifs_sb->master_tlink = tlink;
2917 spin_lock(&cifs_sb->tlink_tree_lock);
2918 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
2919 spin_unlock(&cifs_sb->tlink_tree_lock);
2921 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
2926 #ifdef CONFIG_CIFS_DFS_UPCALL
2928 * cifs_build_path_to_root returns full path to root when we do not have an
2929 * existing connection (tcon)
2932 build_unc_path_to_root(const struct smb3_fs_context *ctx,
2933 const struct cifs_sb_info *cifs_sb, bool useppath)
2935 char *full_path, *pos;
2936 unsigned int pplen = useppath && ctx->prepath ?
2937 strlen(ctx->prepath) + 1 : 0;
2938 unsigned int unc_len = strnlen(ctx->UNC, MAX_TREE_SIZE + 1);
2940 if (unc_len > MAX_TREE_SIZE)
2941 return ERR_PTR(-EINVAL);
2943 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
2944 if (full_path == NULL)
2945 return ERR_PTR(-ENOMEM);
2947 memcpy(full_path, ctx->UNC, unc_len);
2948 pos = full_path + unc_len;
2951 *pos = CIFS_DIR_SEP(cifs_sb);
2952 memcpy(pos + 1, ctx->prepath, pplen);
2956 *pos = '\0'; /* add trailing null */
2957 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
2958 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
2963 * expand_dfs_referral - Perform a dfs referral query and update the cifs_sb
2965 * If a referral is found, cifs_sb->ctx->mount_options will be (re-)allocated
2966 * to a string containing updated options for the submount. Otherwise it
2967 * will be left untouched.
2969 * Returns the rc from get_dfs_path to the caller, which can be used to
2970 * determine whether there were referrals.
2973 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
2974 struct smb3_fs_context *ctx, struct cifs_sb_info *cifs_sb,
2978 struct dfs_info3_param referral = {0};
2979 char *full_path = NULL, *mdata = NULL;
2981 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
2984 full_path = build_unc_path_to_root(ctx, cifs_sb, true);
2985 if (IS_ERR(full_path))
2986 return PTR_ERR(full_path);
2988 rc = dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
2989 ref_path, &referral, NULL);
2991 char *fake_devname = NULL;
2993 mdata = cifs_compose_mount_options(cifs_sb->ctx->mount_options,
2994 full_path + 1, &referral,
2996 free_dfs_info_param(&referral);
2998 if (IS_ERR(mdata)) {
2999 rc = PTR_ERR(mdata);
3003 * We can not clear out the whole structure since we
3004 * no longer have an explicit function to parse
3005 * a mount-string. Instead we need to clear out the
3006 * individual fields that are no longer valid.
3008 kfree(ctx->prepath);
3009 ctx->prepath = NULL;
3010 rc = cifs_setup_volume_info(ctx, mdata, fake_devname);
3012 kfree(fake_devname);
3013 kfree(cifs_sb->ctx->mount_options);
3014 cifs_sb->ctx->mount_options = mdata;
3020 static inline int get_next_dfs_tgt(const char *path,
3021 struct dfs_cache_tgt_list *tgt_list,
3022 struct dfs_cache_tgt_iterator **tgt_it)
3025 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
3027 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
3028 return !*tgt_it ? -EHOSTDOWN : 0;
3031 static int update_vol_info(const struct dfs_cache_tgt_iterator *tgt_it,
3032 struct smb3_fs_context *fake_ctx, struct smb3_fs_context *ctx)
3034 const char *tgt = dfs_cache_get_tgt_name(tgt_it);
3035 int len = strlen(tgt) + 2;
3038 new_unc = kmalloc(len, GFP_KERNEL);
3041 scnprintf(new_unc, len, "\\%s", tgt);
3046 if (fake_ctx->prepath) {
3047 kfree(ctx->prepath);
3048 ctx->prepath = fake_ctx->prepath;
3049 fake_ctx->prepath = NULL;
3051 memcpy(&ctx->dstaddr, &fake_ctx->dstaddr, sizeof(ctx->dstaddr));
3056 static int do_dfs_failover(const char *path, const char *full_path, struct cifs_sb_info *cifs_sb,
3057 struct smb3_fs_context *ctx, struct cifs_ses *root_ses,
3058 unsigned int *xid, struct TCP_Server_Info **server,
3059 struct cifs_ses **ses, struct cifs_tcon **tcon)
3062 struct dfs_cache_tgt_list tgt_list = {0};
3063 struct dfs_cache_tgt_iterator *tgt_it = NULL;
3064 struct smb3_fs_context tmp_ctx = {NULL};
3066 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
3069 cifs_dbg(FYI, "%s: path=%s full_path=%s\n", __func__, path, full_path);
3071 rc = dfs_cache_noreq_find(path, NULL, &tgt_list);
3075 * We use a 'tmp_ctx' here because we need pass it down to the mount_{get,put} functions to
3076 * test connection against new DFS targets.
3078 rc = smb3_fs_context_dup(&tmp_ctx, ctx);
3083 struct dfs_info3_param ref = {0};
3084 char *fake_devname = NULL, *mdata = NULL;
3086 /* Get next DFS target server - if any */
3087 rc = get_next_dfs_tgt(path, &tgt_list, &tgt_it);
3091 rc = dfs_cache_get_tgt_referral(path, tgt_it, &ref);
3095 cifs_dbg(FYI, "%s: old ctx: UNC=%s prepath=%s\n", __func__, tmp_ctx.UNC,
3098 mdata = cifs_compose_mount_options(cifs_sb->ctx->mount_options, full_path + 1, &ref,
3100 free_dfs_info_param(&ref);
3102 if (IS_ERR(mdata)) {
3103 rc = PTR_ERR(mdata);
3106 rc = cifs_setup_volume_info(&tmp_ctx, mdata, fake_devname);
3109 kfree(fake_devname);
3114 cifs_dbg(FYI, "%s: new ctx: UNC=%s prepath=%s\n", __func__, tmp_ctx.UNC,
3117 mount_put_conns(cifs_sb, *xid, *server, *ses, *tcon);
3118 rc = mount_get_conns(&tmp_ctx, cifs_sb, xid, server, ses, tcon);
3119 if (!rc || (*server && *ses)) {
3121 * We were able to connect to new target server. Update current context with
3122 * new target server.
3124 rc = update_vol_info(tgt_it, &tmp_ctx, ctx);
3129 cifs_dbg(FYI, "%s: final ctx: UNC=%s prepath=%s\n", __func__, tmp_ctx.UNC,
3132 * Update DFS target hint in DFS referral cache with the target server we
3133 * successfully reconnected to.
3135 rc = dfs_cache_update_tgthint(*xid, root_ses ? root_ses : *ses, cifs_sb->local_nls,
3136 cifs_remap(cifs_sb), path, tgt_it);
3140 smb3_cleanup_fs_context_contents(&tmp_ctx);
3141 dfs_cache_free_tgts(&tgt_list);
3146 /* TODO: all callers to this are broken. We are not parsing mount_options here
3147 * we should pass a clone of the original context?
3150 cifs_setup_volume_info(struct smb3_fs_context *ctx, const char *mntopts, const char *devname)
3155 cifs_dbg(FYI, "%s: devname=%s\n", __func__, devname);
3156 rc = smb3_parse_devname(devname, ctx);
3158 cifs_dbg(VFS, "%s: failed to parse %s: %d\n", __func__, devname, rc);
3166 rc = smb3_parse_opt(mntopts, "ip", &ip);
3168 cifs_dbg(VFS, "%s: failed to parse ip options: %d\n", __func__, rc);
3172 rc = cifs_convert_address((struct sockaddr *)&ctx->dstaddr, ip, strlen(ip));
3175 cifs_dbg(VFS, "%s: failed to convert ip address\n", __func__);
3180 if (ctx->nullauth) {
3181 cifs_dbg(FYI, "Anonymous login\n");
3182 kfree(ctx->username);
3183 ctx->username = NULL;
3184 } else if (ctx->username) {
3185 /* BB fixme parse for domain name here */
3186 cifs_dbg(FYI, "Username: %s\n", ctx->username);
3188 cifs_dbg(VFS, "No username specified\n");
3189 /* In userspace mount helper we can get user name from alternate
3190 locations such as env variables and files on disk */
3198 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3200 struct cifs_tcon *tcon,
3201 struct cifs_sb_info *cifs_sb,
3208 int skip = added_treename ? 1 : 0;
3210 sep = CIFS_DIR_SEP(cifs_sb);
3213 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3215 /* skip separators */
3220 /* next separator */
3221 while (*s && *s != sep)
3224 * if the treename is added, we then have to skip the first
3225 * part within the separators
3232 * temporarily null-terminate the path at the end of
3233 * the current component
3237 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3245 * Check if path is remote (e.g. a DFS share). Return -EREMOTE if it is,
3248 static int is_path_remote(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx,
3249 const unsigned int xid,
3250 struct TCP_Server_Info *server,
3251 struct cifs_tcon *tcon)
3256 if (!server->ops->is_path_accessible)
3260 * cifs_build_path_to_root works only when we have a valid tcon
3262 full_path = cifs_build_path_to_root(ctx, cifs_sb, tcon,
3263 tcon->Flags & SMB_SHARE_IS_IN_DFS);
3264 if (full_path == NULL)
3267 cifs_dbg(FYI, "%s: full_path: %s\n", __func__, full_path);
3269 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3271 if (rc != 0 && rc != -EREMOTE) {
3276 if (rc != -EREMOTE) {
3277 rc = cifs_are_all_path_components_accessible(server, xid, tcon,
3278 cifs_sb, full_path, tcon->Flags & SMB_SHARE_IS_IN_DFS);
3280 cifs_server_dbg(VFS, "cannot query dirs between root and final path, enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3281 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3290 #ifdef CONFIG_CIFS_DFS_UPCALL
3291 static void set_root_ses(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
3292 struct cifs_ses **root_ses)
3295 spin_lock(&cifs_tcp_ses_lock);
3298 ses->tcon_ipc->remap = cifs_remap(cifs_sb);
3299 spin_unlock(&cifs_tcp_ses_lock);
3304 static void put_root_ses(struct cifs_ses *ses)
3307 cifs_put_smb_ses(ses);
3310 /* Set up next dfs prefix path in @dfs_path */
3311 static int next_dfs_prepath(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx,
3312 const unsigned int xid, struct TCP_Server_Info *server,
3313 struct cifs_tcon *tcon, char **dfs_path)
3316 int added_treename = is_tcon_dfs(tcon);
3319 path = cifs_build_path_to_root(ctx, cifs_sb, tcon, added_treename);
3323 rc = is_path_remote(cifs_sb, ctx, xid, server, tcon);
3324 if (rc == -EREMOTE) {
3325 struct smb3_fs_context v = {NULL};
3326 /* if @path contains a tree name, skip it in the prefix path */
3327 if (added_treename) {
3328 rc = smb3_parse_devname(path, &v);
3331 npath = build_unc_path_to_root(&v, cifs_sb, true);
3332 smb3_cleanup_fs_context_contents(&v);
3335 v.prepath = path + 1;
3336 npath = build_unc_path_to_root(&v, cifs_sb, true);
3339 if (IS_ERR(npath)) {
3340 rc = PTR_ERR(npath);
3354 /* Check if resolved targets can handle any DFS referrals */
3355 static int is_referral_server(const char *ref_path, struct cifs_tcon *tcon, bool *ref_server)
3358 struct dfs_info3_param ref = {0};
3360 if (is_tcon_dfs(tcon)) {
3363 cifs_dbg(FYI, "%s: ref_path=%s\n", __func__, ref_path);
3365 rc = dfs_cache_noreq_find(ref_path, &ref, NULL);
3367 cifs_dbg(VFS, "%s: dfs_cache_noreq_find: failed (rc=%d)\n", __func__, rc);
3370 cifs_dbg(FYI, "%s: ref.flags=0x%x\n", __func__, ref.flags);
3372 * Check if all targets are capable of handling DFS referrals as per
3373 * MS-DFSC 2.2.4 RESP_GET_DFS_REFERRAL.
3375 *ref_server = !!(ref.flags & DFSREF_REFERRAL_SERVER);
3376 free_dfs_info_param(&ref);
3381 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx)
3385 struct TCP_Server_Info *server = NULL;
3386 struct cifs_ses *ses = NULL, *root_ses = NULL;
3387 struct cifs_tcon *tcon = NULL;
3389 char *ref_path = NULL, *full_path = NULL;
3390 char *oldmnt = NULL;
3391 char *mntdata = NULL;
3392 bool ref_server = false;
3394 rc = mount_get_conns(ctx, cifs_sb, &xid, &server, &ses, &tcon);
3396 * If called with 'nodfs' mount option, then skip DFS resolving. Otherwise unconditionally
3397 * try to get an DFS referral (even cached) to determine whether it is an DFS mount.
3399 * Skip prefix path to provide support for DFS referrals from w2k8 servers which don't seem
3400 * to respond with PATH_NOT_COVERED to requests that include the prefix.
3402 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS) ||
3403 dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb), ctx->UNC + 1, NULL,
3407 /* Check if it is fully accessible and then mount it */
3408 rc = is_path_remote(cifs_sb, ctx, xid, server, tcon);
3414 /* Save mount options */
3415 mntdata = kstrdup(cifs_sb->ctx->mount_options, GFP_KERNEL);
3420 /* Get path of DFS root */
3421 ref_path = build_unc_path_to_root(ctx, cifs_sb, false);
3422 if (IS_ERR(ref_path)) {
3423 rc = PTR_ERR(ref_path);
3428 set_root_ses(cifs_sb, ses, &root_ses);
3430 /* Save full path of last DFS path we used to resolve final target server */
3432 full_path = build_unc_path_to_root(ctx, cifs_sb, !!count);
3433 if (IS_ERR(full_path)) {
3434 rc = PTR_ERR(full_path);
3438 /* Chase referral */
3439 oldmnt = cifs_sb->ctx->mount_options;
3440 rc = expand_dfs_referral(xid, root_ses, ctx, cifs_sb, ref_path + 1);
3443 /* Connect to new DFS target only if we were redirected */
3444 if (oldmnt != cifs_sb->ctx->mount_options) {
3445 mount_put_conns(cifs_sb, xid, server, ses, tcon);
3446 rc = mount_get_conns(ctx, cifs_sb, &xid, &server, &ses, &tcon);
3448 if (rc && !server && !ses) {
3449 /* Failed to connect. Try to connect to other targets in the referral. */
3450 rc = do_dfs_failover(ref_path + 1, full_path, cifs_sb, ctx, root_ses, &xid,
3451 &server, &ses, &tcon);
3453 if (rc == -EACCES || rc == -EOPNOTSUPP || !server || !ses)
3458 /* Make sure that requests go through new root servers */
3459 rc = is_referral_server(ref_path + 1, tcon, &ref_server);
3463 put_root_ses(root_ses);
3464 set_root_ses(cifs_sb, ses, &root_ses);
3467 /* Get next dfs path and then continue chasing them if -EREMOTE */
3468 rc = next_dfs_prepath(cifs_sb, ctx, xid, server, tcon, &ref_path);
3469 /* Prevent recursion on broken link referrals */
3470 if (rc == -EREMOTE && ++count > MAX_NESTED_LINKS)
3472 } while (rc == -EREMOTE);
3476 put_root_ses(root_ses);
3481 * Store DFS full path in both superblock and tree connect structures.
3483 * For DFS root mounts, the prefix path (cifs_sb->prepath) is preserved during reconnect so
3484 * only the root path is set in cifs_sb->origin_fullpath and tcon->dfs_path. And for DFS
3485 * links, the prefix path is included in both and may be changed during reconnect. See
3486 * cifs_tree_connect().
3488 cifs_sb->origin_fullpath = kstrdup(full_path, GFP_KERNEL);
3489 if (!cifs_sb->origin_fullpath) {
3493 spin_lock(&cifs_tcp_ses_lock);
3494 tcon->dfs_path = full_path;
3496 tcon->remap = cifs_remap(cifs_sb);
3497 spin_unlock(&cifs_tcp_ses_lock);
3499 /* Add original context for DFS cache to be used when refreshing referrals */
3500 rc = dfs_cache_add_vol(mntdata, ctx, cifs_sb->origin_fullpath);
3504 * After reconnecting to a different server, unique ids won't
3505 * match anymore, so we disable serverino. This prevents
3506 * dentry revalidation to think the dentry are stale (ESTALE).
3508 cifs_autodisable_serverino(cifs_sb);
3510 * Force the use of prefix path to support failover on DFS paths that
3511 * resolve to targets that have different prefix paths.
3513 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3514 kfree(cifs_sb->prepath);
3515 cifs_sb->prepath = ctx->prepath;
3516 ctx->prepath = NULL;
3520 cifs_try_adding_channels(cifs_sb, ses);
3521 return mount_setup_tlink(cifs_sb, ses, tcon);
3527 kfree(cifs_sb->origin_fullpath);
3528 put_root_ses(root_ses);
3529 mount_put_conns(cifs_sb, xid, server, ses, tcon);
3533 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx)
3537 struct cifs_ses *ses;
3538 struct cifs_tcon *tcon;
3539 struct TCP_Server_Info *server;
3541 rc = mount_get_conns(ctx, cifs_sb, &xid, &server, &ses, &tcon);
3546 rc = is_path_remote(cifs_sb, ctx, xid, server, tcon);
3555 return mount_setup_tlink(cifs_sb, ses, tcon);
3558 mount_put_conns(cifs_sb, xid, server, ses, tcon);
3564 * Issue a TREE_CONNECT request.
3567 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3568 const char *tree, struct cifs_tcon *tcon,
3569 const struct nls_table *nls_codepage)
3571 struct smb_hdr *smb_buffer;
3572 struct smb_hdr *smb_buffer_response;
3575 unsigned char *bcc_ptr;
3578 __u16 bytes_left, count;
3583 smb_buffer = cifs_buf_get();
3584 if (smb_buffer == NULL)
3587 smb_buffer_response = smb_buffer;
3589 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3590 NULL /*no tid */ , 4 /*wct */ );
3592 smb_buffer->Mid = get_next_mid(ses->server);
3593 smb_buffer->Uid = ses->Suid;
3594 pSMB = (TCONX_REQ *) smb_buffer;
3595 pSMBr = (TCONX_RSP *) smb_buffer_response;
3597 pSMB->AndXCommand = 0xFF;
3598 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3599 bcc_ptr = &pSMB->Password[0];
3600 if (tcon->pipe || (ses->server->sec_mode & SECMODE_USER)) {
3601 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3602 *bcc_ptr = 0; /* password is null byte */
3603 bcc_ptr++; /* skip password */
3604 /* already aligned so no need to do it below */
3606 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3607 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3608 specified as required (when that support is added to
3609 the vfs in the future) as only NTLM or the much
3610 weaker LANMAN (which we do not send by default) is accepted
3611 by Samba (not sure whether other servers allow
3612 NTLMv2 password here) */
3613 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3614 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3615 (ses->sectype == LANMAN))
3616 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3617 ses->server->sec_mode &
3618 SECMODE_PW_ENCRYPT ? true : false,
3621 #endif /* CIFS_WEAK_PW_HASH */
3622 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3623 bcc_ptr, nls_codepage);
3625 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3627 cifs_buf_release(smb_buffer);
3631 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3632 if (ses->capabilities & CAP_UNICODE) {
3633 /* must align unicode strings */
3634 *bcc_ptr = 0; /* null byte password */
3639 if (ses->server->sign)
3640 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3642 if (ses->capabilities & CAP_STATUS32) {
3643 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3645 if (ses->capabilities & CAP_DFS) {
3646 smb_buffer->Flags2 |= SMBFLG2_DFS;
3648 if (ses->capabilities & CAP_UNICODE) {
3649 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3651 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3652 6 /* max utf8 char length in bytes */ *
3653 (/* server len*/ + 256 /* share len */), nls_codepage);
3654 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3655 bcc_ptr += 2; /* skip trailing null */
3656 } else { /* ASCII */
3657 strcpy(bcc_ptr, tree);
3658 bcc_ptr += strlen(tree) + 1;
3660 strcpy(bcc_ptr, "?????");
3661 bcc_ptr += strlen("?????");
3663 count = bcc_ptr - &pSMB->Password[0];
3664 be32_add_cpu(&pSMB->hdr.smb_buf_length, count);
3665 pSMB->ByteCount = cpu_to_le16(count);
3667 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3670 /* above now done in SendReceive */
3674 tcon->tidStatus = CifsGood;
3675 tcon->need_reconnect = false;
3676 tcon->tid = smb_buffer_response->Tid;
3677 bcc_ptr = pByteArea(smb_buffer_response);
3678 bytes_left = get_bcc(smb_buffer_response);
3679 length = strnlen(bcc_ptr, bytes_left - 2);
3680 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3686 /* skip service field (NB: this field is always ASCII) */
3688 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3689 (bcc_ptr[2] == 'C')) {
3690 cifs_dbg(FYI, "IPC connection\n");
3694 } else if (length == 2) {
3695 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3696 /* the most common case */
3697 cifs_dbg(FYI, "disk share connection\n");
3700 bcc_ptr += length + 1;
3701 bytes_left -= (length + 1);
3702 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
3704 /* mostly informational -- no need to fail on error here */
3705 kfree(tcon->nativeFileSystem);
3706 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3707 bytes_left, is_unicode,
3710 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
3712 if ((smb_buffer_response->WordCount == 3) ||
3713 (smb_buffer_response->WordCount == 7))
3714 /* field is in same location */
3715 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3718 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
3721 cifs_buf_release(smb_buffer);
3725 static void delayed_free(struct rcu_head *p)
3727 struct cifs_sb_info *cifs_sb = container_of(p, struct cifs_sb_info, rcu);
3729 unload_nls(cifs_sb->local_nls);
3730 smb3_cleanup_fs_context(cifs_sb->ctx);
3735 cifs_umount(struct cifs_sb_info *cifs_sb)
3737 struct rb_root *root = &cifs_sb->tlink_tree;
3738 struct rb_node *node;
3739 struct tcon_link *tlink;
3741 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3743 spin_lock(&cifs_sb->tlink_tree_lock);
3744 while ((node = rb_first(root))) {
3745 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3746 cifs_get_tlink(tlink);
3747 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3748 rb_erase(node, root);
3750 spin_unlock(&cifs_sb->tlink_tree_lock);
3751 cifs_put_tlink(tlink);
3752 spin_lock(&cifs_sb->tlink_tree_lock);
3754 spin_unlock(&cifs_sb->tlink_tree_lock);
3756 kfree(cifs_sb->prepath);
3757 #ifdef CONFIG_CIFS_DFS_UPCALL
3758 dfs_cache_del_vol(cifs_sb->origin_fullpath);
3759 kfree(cifs_sb->origin_fullpath);
3761 call_rcu(&cifs_sb->rcu, delayed_free);
3765 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3768 struct TCP_Server_Info *server = cifs_ses_server(ses);
3770 if (!server->ops->need_neg || !server->ops->negotiate)
3773 /* only send once per connect */
3774 if (!server->ops->need_neg(server))
3777 rc = server->ops->negotiate(xid, ses);
3779 spin_lock(&GlobalMid_Lock);
3780 if (server->tcpStatus == CifsNeedNegotiate)
3781 server->tcpStatus = CifsGood;
3784 spin_unlock(&GlobalMid_Lock);
3791 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3792 struct nls_table *nls_info)
3795 struct TCP_Server_Info *server = cifs_ses_server(ses);
3797 if (!ses->binding) {
3798 ses->capabilities = server->capabilities;
3799 if (!linuxExtEnabled)
3800 ses->capabilities &= (~server->vals->cap_unix);
3802 if (ses->auth_key.response) {
3803 cifs_dbg(FYI, "Free previous auth_key.response = %p\n",
3804 ses->auth_key.response);
3805 kfree(ses->auth_key.response);
3806 ses->auth_key.response = NULL;
3807 ses->auth_key.len = 0;
3811 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
3812 server->sec_mode, server->capabilities, server->timeAdj);
3814 if (server->ops->sess_setup)
3815 rc = server->ops->sess_setup(xid, ses, nls_info);
3818 cifs_server_dbg(VFS, "Send error in SessSetup = %d\n", rc);
3824 cifs_set_vol_auth(struct smb3_fs_context *ctx, struct cifs_ses *ses)
3826 ctx->sectype = ses->sectype;
3828 /* krb5 is special, since we don't need username or pw */
3829 if (ctx->sectype == Kerberos)
3832 return cifs_set_cifscreds(ctx, ses);
3835 static struct cifs_tcon *
3836 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
3839 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3840 struct cifs_ses *ses;
3841 struct cifs_tcon *tcon = NULL;
3842 struct smb3_fs_context *ctx;
3844 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
3846 return ERR_PTR(-ENOMEM);
3848 ctx->local_nls = cifs_sb->local_nls;
3849 ctx->linux_uid = fsuid;
3850 ctx->cred_uid = fsuid;
3851 ctx->UNC = master_tcon->treeName;
3852 ctx->retry = master_tcon->retry;
3853 ctx->nocase = master_tcon->nocase;
3854 ctx->nohandlecache = master_tcon->nohandlecache;
3855 ctx->local_lease = master_tcon->local_lease;
3856 ctx->no_lease = master_tcon->no_lease;
3857 ctx->resilient = master_tcon->use_resilient;
3858 ctx->persistent = master_tcon->use_persistent;
3859 ctx->handle_timeout = master_tcon->handle_timeout;
3860 ctx->no_linux_ext = !master_tcon->unix_ext;
3861 ctx->linux_ext = master_tcon->posix_extensions;
3862 ctx->sectype = master_tcon->ses->sectype;
3863 ctx->sign = master_tcon->ses->sign;
3864 ctx->seal = master_tcon->seal;
3865 ctx->witness = master_tcon->use_witness;
3867 rc = cifs_set_vol_auth(ctx, master_tcon->ses);
3873 /* get a reference for the same TCP session */
3874 spin_lock(&cifs_tcp_ses_lock);
3875 ++master_tcon->ses->server->srv_count;
3876 spin_unlock(&cifs_tcp_ses_lock);
3878 ses = cifs_get_smb_ses(master_tcon->ses->server, ctx);
3880 tcon = (struct cifs_tcon *)ses;
3881 cifs_put_tcp_session(master_tcon->ses->server, 0);
3885 tcon = cifs_get_tcon(ses, ctx);
3887 cifs_put_smb_ses(ses);
3892 reset_cifs_unix_caps(0, tcon, NULL, ctx);
3895 kfree(ctx->username);
3896 kfree_sensitive(ctx->password);
3903 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3905 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3908 /* find and return a tlink with given uid */
3909 static struct tcon_link *
3910 tlink_rb_search(struct rb_root *root, kuid_t uid)
3912 struct rb_node *node = root->rb_node;
3913 struct tcon_link *tlink;
3916 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3918 if (uid_gt(tlink->tl_uid, uid))
3919 node = node->rb_left;
3920 else if (uid_lt(tlink->tl_uid, uid))
3921 node = node->rb_right;
3928 /* insert a tcon_link into the tree */
3930 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3932 struct rb_node **new = &(root->rb_node), *parent = NULL;
3933 struct tcon_link *tlink;
3936 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3939 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
3940 new = &((*new)->rb_left);
3942 new = &((*new)->rb_right);
3945 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3946 rb_insert_color(&new_tlink->tl_rbnode, root);
3950 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3953 * If the superblock doesn't refer to a multiuser mount, then just return
3954 * the master tcon for the mount.
3956 * First, search the rbtree for an existing tcon for this fsuid. If one
3957 * exists, then check to see if it's pending construction. If it is then wait
3958 * for construction to complete. Once it's no longer pending, check to see if
3959 * it failed and either return an error or retry construction, depending on
3962 * If one doesn't exist then insert a new tcon_link struct into the tree and
3963 * try to construct a new one.
3966 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3969 kuid_t fsuid = current_fsuid();
3970 struct tcon_link *tlink, *newtlink;
3972 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3973 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3975 spin_lock(&cifs_sb->tlink_tree_lock);
3976 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3978 cifs_get_tlink(tlink);
3979 spin_unlock(&cifs_sb->tlink_tree_lock);
3981 if (tlink == NULL) {
3982 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3983 if (newtlink == NULL)
3984 return ERR_PTR(-ENOMEM);
3985 newtlink->tl_uid = fsuid;
3986 newtlink->tl_tcon = ERR_PTR(-EACCES);
3987 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3988 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3989 cifs_get_tlink(newtlink);
3991 spin_lock(&cifs_sb->tlink_tree_lock);
3992 /* was one inserted after previous search? */
3993 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3995 cifs_get_tlink(tlink);
3996 spin_unlock(&cifs_sb->tlink_tree_lock);
3998 goto wait_for_construction;
4001 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4002 spin_unlock(&cifs_sb->tlink_tree_lock);
4004 wait_for_construction:
4005 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4006 TASK_INTERRUPTIBLE);
4008 cifs_put_tlink(tlink);
4009 return ERR_PTR(-ERESTARTSYS);
4012 /* if it's good, return it */
4013 if (!IS_ERR(tlink->tl_tcon))
4016 /* return error if we tried this already recently */
4017 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4018 cifs_put_tlink(tlink);
4019 return ERR_PTR(-EACCES);
4022 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4023 goto wait_for_construction;
4026 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4027 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4028 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4030 if (IS_ERR(tlink->tl_tcon)) {
4031 cifs_put_tlink(tlink);
4032 return ERR_PTR(-EACCES);
4039 * periodic workqueue job that scans tcon_tree for a superblock and closes
4043 cifs_prune_tlinks(struct work_struct *work)
4045 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4047 struct rb_root *root = &cifs_sb->tlink_tree;
4048 struct rb_node *node;
4049 struct rb_node *tmp;
4050 struct tcon_link *tlink;
4053 * Because we drop the spinlock in the loop in order to put the tlink
4054 * it's not guarded against removal of links from the tree. The only
4055 * places that remove entries from the tree are this function and
4056 * umounts. Because this function is non-reentrant and is canceled
4057 * before umount can proceed, this is safe.
4059 spin_lock(&cifs_sb->tlink_tree_lock);
4060 node = rb_first(root);
4061 while (node != NULL) {
4063 node = rb_next(tmp);
4064 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4066 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4067 atomic_read(&tlink->tl_count) != 0 ||
4068 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4071 cifs_get_tlink(tlink);
4072 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4073 rb_erase(tmp, root);
4075 spin_unlock(&cifs_sb->tlink_tree_lock);
4076 cifs_put_tlink(tlink);
4077 spin_lock(&cifs_sb->tlink_tree_lock);
4079 spin_unlock(&cifs_sb->tlink_tree_lock);
4081 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4085 #ifdef CONFIG_CIFS_DFS_UPCALL
4086 int cifs_tree_connect(const unsigned int xid, struct cifs_tcon *tcon, const struct nls_table *nlsc)
4089 struct TCP_Server_Info *server = tcon->ses->server;
4090 const struct smb_version_operations *ops = server->ops;
4091 struct dfs_cache_tgt_list tl;
4092 struct dfs_cache_tgt_iterator *it = NULL;
4094 const char *tcp_host;
4095 size_t tcp_host_len;
4096 const char *dfs_host;
4097 size_t dfs_host_len;
4098 char *share = NULL, *prefix = NULL;
4099 struct dfs_info3_param ref = {0};
4102 tree = kzalloc(MAX_TREE_SIZE, GFP_KERNEL);
4106 if (!tcon->dfs_path) {
4108 scnprintf(tree, MAX_TREE_SIZE, "\\\\%s\\IPC$", server->hostname);
4109 rc = ops->tree_connect(xid, tcon->ses, tree, tcon, nlsc);
4111 rc = ops->tree_connect(xid, tcon->ses, tcon->treeName, tcon, nlsc);
4116 rc = dfs_cache_noreq_find(tcon->dfs_path + 1, &ref, &tl);
4119 isroot = ref.server_type == DFS_TYPE_ROOT;
4120 free_dfs_info_param(&ref);
4122 extract_unc_hostname(server->hostname, &tcp_host, &tcp_host_len);
4124 for (it = dfs_cache_get_tgt_iterator(&tl); it; it = dfs_cache_get_next_tgt(&tl, it)) {
4132 rc = dfs_cache_get_tgt_share(tcon->dfs_path + 1, it, &share, &prefix);
4134 cifs_dbg(VFS, "%s: failed to parse target share %d\n",
4139 extract_unc_hostname(share, &dfs_host, &dfs_host_len);
4141 if (dfs_host_len != tcp_host_len
4142 || strncasecmp(dfs_host, tcp_host, dfs_host_len) != 0) {
4143 cifs_dbg(FYI, "%s: %.*s doesn't match %.*s\n", __func__, (int)dfs_host_len,
4144 dfs_host, (int)tcp_host_len, tcp_host);
4146 rc = match_target_ip(server, dfs_host, dfs_host_len, &target_match);
4148 cifs_dbg(VFS, "%s: failed to match target ip: %d\n", __func__, rc);
4152 if (!target_match) {
4153 cifs_dbg(FYI, "%s: skipping target\n", __func__);
4159 scnprintf(tree, MAX_TREE_SIZE, "\\\\%s\\IPC$", share);
4160 rc = ops->tree_connect(xid, tcon->ses, tree, tcon, nlsc);
4162 scnprintf(tree, MAX_TREE_SIZE, "\\%s", share);
4163 rc = ops->tree_connect(xid, tcon->ses, tree, tcon, nlsc);
4164 /* Only handle prefix paths of DFS link targets */
4165 if (!rc && !isroot) {
4166 rc = update_super_prepath(tcon, prefix);
4179 rc = dfs_cache_noreq_update_tgthint(tcon->dfs_path + 1, it);
4183 dfs_cache_free_tgts(&tl);
4189 int cifs_tree_connect(const unsigned int xid, struct cifs_tcon *tcon, const struct nls_table *nlsc)
4191 const struct smb_version_operations *ops = tcon->ses->server->ops;
4193 return ops->tree_connect(xid, tcon->ses, tcon->treeName, tcon, nlsc);