138c8a9a5SSteve French // SPDX-License-Identifier: LGPL-2.1
238c8a9a5SSteve French /*
338c8a9a5SSteve French *
438c8a9a5SSteve French * Copyright (C) International Business Machines Corp., 2002,2011
538c8a9a5SSteve French * Author(s): Steve French (sfrench@us.ibm.com)
638c8a9a5SSteve French *
738c8a9a5SSteve French */
838c8a9a5SSteve French #include <linux/fs.h>
938c8a9a5SSteve French #include <linux/net.h>
1038c8a9a5SSteve French #include <linux/string.h>
1138c8a9a5SSteve French #include <linux/sched/mm.h>
1238c8a9a5SSteve French #include <linux/sched/signal.h>
1338c8a9a5SSteve French #include <linux/list.h>
1438c8a9a5SSteve French #include <linux/wait.h>
1538c8a9a5SSteve French #include <linux/slab.h>
1638c8a9a5SSteve French #include <linux/pagemap.h>
1738c8a9a5SSteve French #include <linux/ctype.h>
1838c8a9a5SSteve French #include <linux/utsname.h>
1938c8a9a5SSteve French #include <linux/mempool.h>
2038c8a9a5SSteve French #include <linux/delay.h>
2138c8a9a5SSteve French #include <linux/completion.h>
2238c8a9a5SSteve French #include <linux/kthread.h>
2338c8a9a5SSteve French #include <linux/pagevec.h>
2438c8a9a5SSteve French #include <linux/freezer.h>
2538c8a9a5SSteve French #include <linux/namei.h>
2638c8a9a5SSteve French #include <linux/uuid.h>
2738c8a9a5SSteve French #include <linux/uaccess.h>
2838c8a9a5SSteve French #include <asm/processor.h>
2938c8a9a5SSteve French #include <linux/inet.h>
3038c8a9a5SSteve French #include <linux/module.h>
3138c8a9a5SSteve French #include <keys/user-type.h>
3238c8a9a5SSteve French #include <net/ipv6.h>
3338c8a9a5SSteve French #include <linux/parser.h>
3438c8a9a5SSteve French #include <linux/bvec.h>
3538c8a9a5SSteve French #include "cifspdu.h"
3638c8a9a5SSteve French #include "cifsglob.h"
3738c8a9a5SSteve French #include "cifsproto.h"
3838c8a9a5SSteve French #include "cifs_unicode.h"
3938c8a9a5SSteve French #include "cifs_debug.h"
4038c8a9a5SSteve French #include "cifs_fs_sb.h"
4138c8a9a5SSteve French #include "ntlmssp.h"
4238c8a9a5SSteve French #include "nterr.h"
4338c8a9a5SSteve French #include "rfc1002pdu.h"
4438c8a9a5SSteve French #include "fscache.h"
4538c8a9a5SSteve French #include "smb2proto.h"
4638c8a9a5SSteve French #include "smbdirect.h"
4738c8a9a5SSteve French #include "dns_resolve.h"
4838c8a9a5SSteve French #ifdef CONFIG_CIFS_DFS_UPCALL
4938c8a9a5SSteve French #include "dfs.h"
5038c8a9a5SSteve French #include "dfs_cache.h"
5138c8a9a5SSteve French #endif
5238c8a9a5SSteve French #include "fs_context.h"
5338c8a9a5SSteve French #include "cifs_swn.h"
5438c8a9a5SSteve French
5538c8a9a5SSteve French /* FIXME: should these be tunable? */
5638c8a9a5SSteve French #define TLINK_ERROR_EXPIRE (1 * HZ)
5738c8a9a5SSteve French #define TLINK_IDLE_EXPIRE (600 * HZ)
5838c8a9a5SSteve French
5938c8a9a5SSteve French /* Drop the connection to not overload the server */
6069cba9d3SShyam Prasad N #define MAX_STATUS_IO_TIMEOUT 5
6138c8a9a5SSteve French
6238c8a9a5SSteve French static int ip_connect(struct TCP_Server_Info *server);
6338c8a9a5SSteve French static int generic_ip_connect(struct TCP_Server_Info *server);
6438c8a9a5SSteve French static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
6538c8a9a5SSteve French static void cifs_prune_tlinks(struct work_struct *work);
6638c8a9a5SSteve French
6738c8a9a5SSteve French /*
6838c8a9a5SSteve French * Resolve hostname and set ip addr in tcp ses. Useful for hostnames that may
6938c8a9a5SSteve French * get their ip addresses changed at some point.
7038c8a9a5SSteve French *
7138c8a9a5SSteve French * This should be called with server->srv_mutex held.
7238c8a9a5SSteve French */
reconn_set_ipaddr_from_hostname(struct TCP_Server_Info * server)7338c8a9a5SSteve French static int reconn_set_ipaddr_from_hostname(struct TCP_Server_Info *server)
7438c8a9a5SSteve French {
7538c8a9a5SSteve French int rc;
7638c8a9a5SSteve French int len;
7738c8a9a5SSteve French char *unc;
7838c8a9a5SSteve French struct sockaddr_storage ss;
7938c8a9a5SSteve French
8038c8a9a5SSteve French if (!server->hostname)
8138c8a9a5SSteve French return -EINVAL;
8238c8a9a5SSteve French
8338c8a9a5SSteve French /* if server hostname isn't populated, there's nothing to do here */
8438c8a9a5SSteve French if (server->hostname[0] == '\0')
8538c8a9a5SSteve French return 0;
8638c8a9a5SSteve French
8738c8a9a5SSteve French len = strlen(server->hostname) + 3;
8838c8a9a5SSteve French
8938c8a9a5SSteve French unc = kmalloc(len, GFP_KERNEL);
9038c8a9a5SSteve French if (!unc) {
9138c8a9a5SSteve French cifs_dbg(FYI, "%s: failed to create UNC path\n", __func__);
9238c8a9a5SSteve French return -ENOMEM;
9338c8a9a5SSteve French }
9438c8a9a5SSteve French scnprintf(unc, len, "\\\\%s", server->hostname);
9538c8a9a5SSteve French
9638c8a9a5SSteve French spin_lock(&server->srv_lock);
9738c8a9a5SSteve French ss = server->dstaddr;
9838c8a9a5SSteve French spin_unlock(&server->srv_lock);
9938c8a9a5SSteve French
10038c8a9a5SSteve French rc = dns_resolve_server_name_to_ip(unc, (struct sockaddr *)&ss, NULL);
10138c8a9a5SSteve French kfree(unc);
10238c8a9a5SSteve French
10338c8a9a5SSteve French if (rc < 0) {
10438c8a9a5SSteve French cifs_dbg(FYI, "%s: failed to resolve server part of %s to IP: %d\n",
10538c8a9a5SSteve French __func__, server->hostname, rc);
10638c8a9a5SSteve French } else {
10738c8a9a5SSteve French spin_lock(&server->srv_lock);
10838c8a9a5SSteve French memcpy(&server->dstaddr, &ss, sizeof(server->dstaddr));
10938c8a9a5SSteve French spin_unlock(&server->srv_lock);
11038c8a9a5SSteve French rc = 0;
11138c8a9a5SSteve French }
11238c8a9a5SSteve French
11338c8a9a5SSteve French return rc;
11438c8a9a5SSteve French }
11538c8a9a5SSteve French
smb2_query_server_interfaces(struct work_struct * work)11638c8a9a5SSteve French static void smb2_query_server_interfaces(struct work_struct *work)
11738c8a9a5SSteve French {
11838c8a9a5SSteve French int rc;
119407ced4eSShyam Prasad N int xid;
12038c8a9a5SSteve French struct cifs_tcon *tcon = container_of(work,
12138c8a9a5SSteve French struct cifs_tcon,
12238c8a9a5SSteve French query_interfaces.work);
12366c2940cSShyam Prasad N struct TCP_Server_Info *server = tcon->ses->server;
12438c8a9a5SSteve French
12538c8a9a5SSteve French /*
12638c8a9a5SSteve French * query server network interfaces, in case they change
12738c8a9a5SSteve French */
12866c2940cSShyam Prasad N if (!server->ops->query_server_interfaces)
12966c2940cSShyam Prasad N return;
13066c2940cSShyam Prasad N
131407ced4eSShyam Prasad N xid = get_xid();
13266c2940cSShyam Prasad N rc = server->ops->query_server_interfaces(xid, tcon, false);
133407ced4eSShyam Prasad N free_xid(xid);
134407ced4eSShyam Prasad N
13538c8a9a5SSteve French if (rc) {
1365075e9f4SShyam Prasad N if (rc == -EOPNOTSUPP)
1375075e9f4SShyam Prasad N return;
1385075e9f4SShyam Prasad N
13938c8a9a5SSteve French cifs_dbg(FYI, "%s: failed to query server interfaces: %d\n",
14038c8a9a5SSteve French __func__, rc);
14138c8a9a5SSteve French }
14238c8a9a5SSteve French
14338c8a9a5SSteve French queue_delayed_work(cifsiod_wq, &tcon->query_interfaces,
14438c8a9a5SSteve French (SMB_INTERFACE_POLL_INTERVAL * HZ));
14538c8a9a5SSteve French }
14638c8a9a5SSteve French
14738c8a9a5SSteve French /*
14838c8a9a5SSteve French * Update the tcpStatus for the server.
14938c8a9a5SSteve French * This is used to signal the cifsd thread to call cifs_reconnect
15038c8a9a5SSteve French * ONLY cifsd thread should call cifs_reconnect. For any other
15138c8a9a5SSteve French * thread, use this function
15238c8a9a5SSteve French *
15338c8a9a5SSteve French * @server: the tcp ses for which reconnect is needed
15438c8a9a5SSteve French * @all_channels: if this needs to be done for all channels
15538c8a9a5SSteve French */
15638c8a9a5SSteve French void
cifs_signal_cifsd_for_reconnect(struct TCP_Server_Info * server,bool all_channels)15738c8a9a5SSteve French cifs_signal_cifsd_for_reconnect(struct TCP_Server_Info *server,
15838c8a9a5SSteve French bool all_channels)
15938c8a9a5SSteve French {
16038c8a9a5SSteve French struct TCP_Server_Info *pserver;
16138c8a9a5SSteve French struct cifs_ses *ses;
16238c8a9a5SSteve French int i;
16338c8a9a5SSteve French
16438c8a9a5SSteve French /* If server is a channel, select the primary channel */
165b3773b19SSteve French pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;
16638c8a9a5SSteve French
167e42c5730SShyam Prasad N /* if we need to signal just this channel */
16838c8a9a5SSteve French if (!all_channels) {
169e42c5730SShyam Prasad N spin_lock(&server->srv_lock);
170e42c5730SShyam Prasad N if (server->tcpStatus != CifsExiting)
171e42c5730SShyam Prasad N server->tcpStatus = CifsNeedReconnect;
172e42c5730SShyam Prasad N spin_unlock(&server->srv_lock);
17338c8a9a5SSteve French return;
17438c8a9a5SSteve French }
17538c8a9a5SSteve French
17638c8a9a5SSteve French spin_lock(&cifs_tcp_ses_lock);
17738c8a9a5SSteve French list_for_each_entry(ses, &pserver->smb_ses_list, smb_ses_list) {
1782cfff217SPaulo Alcantara if (cifs_ses_exiting(ses))
1792cfff217SPaulo Alcantara continue;
18038c8a9a5SSteve French spin_lock(&ses->chan_lock);
18138c8a9a5SSteve French for (i = 0; i < ses->chan_count; i++) {
182c395f798SShyam Prasad N if (!ses->chans[i].server)
183c395f798SShyam Prasad N continue;
184c395f798SShyam Prasad N
18538c8a9a5SSteve French spin_lock(&ses->chans[i].server->srv_lock);
186c395f798SShyam Prasad N if (ses->chans[i].server->tcpStatus != CifsExiting)
18738c8a9a5SSteve French ses->chans[i].server->tcpStatus = CifsNeedReconnect;
18838c8a9a5SSteve French spin_unlock(&ses->chans[i].server->srv_lock);
18938c8a9a5SSteve French }
19038c8a9a5SSteve French spin_unlock(&ses->chan_lock);
19138c8a9a5SSteve French }
19238c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
19338c8a9a5SSteve French }
19438c8a9a5SSteve French
19538c8a9a5SSteve French /*
19638c8a9a5SSteve French * Mark all sessions and tcons for reconnect.
19738c8a9a5SSteve French * IMPORTANT: make sure that this gets called only from
19838c8a9a5SSteve French * cifsd thread. For any other thread, use
19938c8a9a5SSteve French * cifs_signal_cifsd_for_reconnect
20038c8a9a5SSteve French *
20138c8a9a5SSteve French * @server: the tcp ses for which reconnect is needed
20238c8a9a5SSteve French * @server needs to be previously set to CifsNeedReconnect.
20338c8a9a5SSteve French * @mark_smb_session: whether even sessions need to be marked
20438c8a9a5SSteve French */
20538c8a9a5SSteve French void
cifs_mark_tcp_ses_conns_for_reconnect(struct TCP_Server_Info * server,bool mark_smb_session)20638c8a9a5SSteve French cifs_mark_tcp_ses_conns_for_reconnect(struct TCP_Server_Info *server,
20738c8a9a5SSteve French bool mark_smb_session)
20838c8a9a5SSteve French {
20938c8a9a5SSteve French struct TCP_Server_Info *pserver;
21038c8a9a5SSteve French struct cifs_ses *ses, *nses;
21138c8a9a5SSteve French struct cifs_tcon *tcon;
21238c8a9a5SSteve French
21338c8a9a5SSteve French /*
21438c8a9a5SSteve French * before reconnecting the tcp session, mark the smb session (uid) and the tid bad so they
21538c8a9a5SSteve French * are not used until reconnected.
21638c8a9a5SSteve French */
21738c8a9a5SSteve French cifs_dbg(FYI, "%s: marking necessary sessions and tcons for reconnect\n", __func__);
21838c8a9a5SSteve French
21938c8a9a5SSteve French /* If server is a channel, select the primary channel */
220b3773b19SSteve French pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;
22138c8a9a5SSteve French
22214bafd19SShyam Prasad N /*
22314bafd19SShyam Prasad N * if the server has been marked for termination, there is a
22414bafd19SShyam Prasad N * chance that the remaining channels all need reconnect. To be
22514bafd19SShyam Prasad N * on the safer side, mark the session and trees for reconnect
22614bafd19SShyam Prasad N * for this scenario. This might cause a few redundant session
22714bafd19SShyam Prasad N * setup and tree connect requests, but it is better than not doing
22814bafd19SShyam Prasad N * a tree connect when needed, and all following requests failing
22914bafd19SShyam Prasad N */
23014bafd19SShyam Prasad N if (server->terminate) {
23114bafd19SShyam Prasad N mark_smb_session = true;
23214bafd19SShyam Prasad N server = pserver;
23314bafd19SShyam Prasad N }
23438c8a9a5SSteve French
23538c8a9a5SSteve French spin_lock(&cifs_tcp_ses_lock);
23638c8a9a5SSteve French list_for_each_entry_safe(ses, nses, &pserver->smb_ses_list, smb_ses_list) {
2376202996aSPaulo Alcantara spin_lock(&ses->ses_lock);
2386202996aSPaulo Alcantara if (ses->ses_status == SES_EXITING) {
2396202996aSPaulo Alcantara spin_unlock(&ses->ses_lock);
2406202996aSPaulo Alcantara continue;
2416202996aSPaulo Alcantara }
2426202996aSPaulo Alcantara spin_unlock(&ses->ses_lock);
2436202996aSPaulo Alcantara
24438c8a9a5SSteve French spin_lock(&ses->chan_lock);
245dd40cbafSShyam Prasad N if (cifs_ses_get_chan_index(ses, server) ==
246dd40cbafSShyam Prasad N CIFS_INVAL_CHAN_INDEX) {
247dd40cbafSShyam Prasad N spin_unlock(&ses->chan_lock);
248dd40cbafSShyam Prasad N continue;
249dd40cbafSShyam Prasad N }
250dd40cbafSShyam Prasad N
25140fc7dfdSShyam Prasad N if (!cifs_chan_is_iface_active(ses, server)) {
25240fc7dfdSShyam Prasad N spin_unlock(&ses->chan_lock);
25340fc7dfdSShyam Prasad N cifs_chan_update_iface(ses, server);
25440fc7dfdSShyam Prasad N spin_lock(&ses->chan_lock);
25540fc7dfdSShyam Prasad N }
25640fc7dfdSShyam Prasad N
25738c8a9a5SSteve French if (!mark_smb_session && cifs_chan_needs_reconnect(ses, server)) {
25838c8a9a5SSteve French spin_unlock(&ses->chan_lock);
25938c8a9a5SSteve French continue;
26038c8a9a5SSteve French }
26138c8a9a5SSteve French
26238c8a9a5SSteve French if (mark_smb_session)
26338c8a9a5SSteve French CIFS_SET_ALL_CHANS_NEED_RECONNECT(ses);
26438c8a9a5SSteve French else
26538c8a9a5SSteve French cifs_chan_set_need_reconnect(ses, server);
26638c8a9a5SSteve French
26738c8a9a5SSteve French cifs_dbg(FYI, "%s: channel connect bitmap: 0x%lx\n",
26838c8a9a5SSteve French __func__, ses->chans_need_reconnect);
26938c8a9a5SSteve French
27038c8a9a5SSteve French /* If all channels need reconnect, then tcon needs reconnect */
27138c8a9a5SSteve French if (!mark_smb_session && !CIFS_ALL_CHANS_NEED_RECONNECT(ses)) {
27238c8a9a5SSteve French spin_unlock(&ses->chan_lock);
27338c8a9a5SSteve French continue;
27438c8a9a5SSteve French }
27538c8a9a5SSteve French spin_unlock(&ses->chan_lock);
27638c8a9a5SSteve French
27738c8a9a5SSteve French spin_lock(&ses->ses_lock);
27838c8a9a5SSteve French ses->ses_status = SES_NEED_RECON;
27938c8a9a5SSteve French spin_unlock(&ses->ses_lock);
28038c8a9a5SSteve French
28138c8a9a5SSteve French list_for_each_entry(tcon, &ses->tcon_list, tcon_list) {
28238c8a9a5SSteve French tcon->need_reconnect = true;
28338c8a9a5SSteve French spin_lock(&tcon->tc_lock);
28438c8a9a5SSteve French tcon->status = TID_NEED_RECON;
28538c8a9a5SSteve French spin_unlock(&tcon->tc_lock);
2863e161536SShyam Prasad N
2873e161536SShyam Prasad N cancel_delayed_work(&tcon->query_interfaces);
28838c8a9a5SSteve French }
28938c8a9a5SSteve French if (ses->tcon_ipc) {
29038c8a9a5SSteve French ses->tcon_ipc->need_reconnect = true;
29138c8a9a5SSteve French spin_lock(&ses->tcon_ipc->tc_lock);
29238c8a9a5SSteve French ses->tcon_ipc->status = TID_NEED_RECON;
29338c8a9a5SSteve French spin_unlock(&ses->tcon_ipc->tc_lock);
29438c8a9a5SSteve French }
29538c8a9a5SSteve French }
29638c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
29738c8a9a5SSteve French }
29838c8a9a5SSteve French
29938c8a9a5SSteve French static void
cifs_abort_connection(struct TCP_Server_Info * server)30038c8a9a5SSteve French cifs_abort_connection(struct TCP_Server_Info *server)
30138c8a9a5SSteve French {
30238c8a9a5SSteve French struct mid_q_entry *mid, *nmid;
30338c8a9a5SSteve French struct list_head retry_list;
30438c8a9a5SSteve French
30538c8a9a5SSteve French server->maxBuf = 0;
30638c8a9a5SSteve French server->max_read = 0;
30738c8a9a5SSteve French
30838c8a9a5SSteve French /* do not want to be sending data on a socket we are freeing */
30938c8a9a5SSteve French cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
31038c8a9a5SSteve French cifs_server_lock(server);
31138c8a9a5SSteve French if (server->ssocket) {
31238c8a9a5SSteve French cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n", server->ssocket->state,
31338c8a9a5SSteve French server->ssocket->flags);
31438c8a9a5SSteve French kernel_sock_shutdown(server->ssocket, SHUT_WR);
31538c8a9a5SSteve French cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n", server->ssocket->state,
31638c8a9a5SSteve French server->ssocket->flags);
31738c8a9a5SSteve French sock_release(server->ssocket);
31838c8a9a5SSteve French server->ssocket = NULL;
31938c8a9a5SSteve French }
32038c8a9a5SSteve French server->sequence_number = 0;
32138c8a9a5SSteve French server->session_estab = false;
32238c8a9a5SSteve French kfree_sensitive(server->session_key.response);
32338c8a9a5SSteve French server->session_key.response = NULL;
32438c8a9a5SSteve French server->session_key.len = 0;
32538c8a9a5SSteve French server->lstrp = jiffies;
32638c8a9a5SSteve French
32738c8a9a5SSteve French /* mark submitted MIDs for retry and issue callback */
32838c8a9a5SSteve French INIT_LIST_HEAD(&retry_list);
32938c8a9a5SSteve French cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
33038c8a9a5SSteve French spin_lock(&server->mid_lock);
33138c8a9a5SSteve French list_for_each_entry_safe(mid, nmid, &server->pending_mid_q, qhead) {
33238c8a9a5SSteve French kref_get(&mid->refcount);
33338c8a9a5SSteve French if (mid->mid_state == MID_REQUEST_SUBMITTED)
33438c8a9a5SSteve French mid->mid_state = MID_RETRY_NEEDED;
33538c8a9a5SSteve French list_move(&mid->qhead, &retry_list);
33638c8a9a5SSteve French mid->mid_flags |= MID_DELETED;
33738c8a9a5SSteve French }
33838c8a9a5SSteve French spin_unlock(&server->mid_lock);
33938c8a9a5SSteve French cifs_server_unlock(server);
34038c8a9a5SSteve French
34138c8a9a5SSteve French cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
34238c8a9a5SSteve French list_for_each_entry_safe(mid, nmid, &retry_list, qhead) {
34338c8a9a5SSteve French list_del_init(&mid->qhead);
34438c8a9a5SSteve French mid->callback(mid);
34538c8a9a5SSteve French release_mid(mid);
34638c8a9a5SSteve French }
34738c8a9a5SSteve French
34838c8a9a5SSteve French if (cifs_rdma_enabled(server)) {
34938c8a9a5SSteve French cifs_server_lock(server);
35038c8a9a5SSteve French smbd_destroy(server);
35138c8a9a5SSteve French cifs_server_unlock(server);
35238c8a9a5SSteve French }
35338c8a9a5SSteve French }
35438c8a9a5SSteve French
cifs_tcp_ses_needs_reconnect(struct TCP_Server_Info * server,int num_targets)35538c8a9a5SSteve French static bool cifs_tcp_ses_needs_reconnect(struct TCP_Server_Info *server, int num_targets)
35638c8a9a5SSteve French {
35738c8a9a5SSteve French spin_lock(&server->srv_lock);
35838c8a9a5SSteve French server->nr_targets = num_targets;
35938c8a9a5SSteve French if (server->tcpStatus == CifsExiting) {
36038c8a9a5SSteve French /* the demux thread will exit normally next time through the loop */
36138c8a9a5SSteve French spin_unlock(&server->srv_lock);
36238c8a9a5SSteve French wake_up(&server->response_q);
36338c8a9a5SSteve French return false;
36438c8a9a5SSteve French }
36538c8a9a5SSteve French
36638c8a9a5SSteve French cifs_dbg(FYI, "Mark tcp session as need reconnect\n");
36738c8a9a5SSteve French trace_smb3_reconnect(server->CurrentMid, server->conn_id,
36838c8a9a5SSteve French server->hostname);
36938c8a9a5SSteve French server->tcpStatus = CifsNeedReconnect;
37038c8a9a5SSteve French
37138c8a9a5SSteve French spin_unlock(&server->srv_lock);
37238c8a9a5SSteve French return true;
37338c8a9a5SSteve French }
37438c8a9a5SSteve French
37538c8a9a5SSteve French /*
37638c8a9a5SSteve French * cifs tcp session reconnection
37738c8a9a5SSteve French *
37838c8a9a5SSteve French * mark tcp session as reconnecting so temporarily locked
37938c8a9a5SSteve French * mark all smb sessions as reconnecting for tcp session
38038c8a9a5SSteve French * reconnect tcp session
38138c8a9a5SSteve French * wake up waiters on reconnection? - (not needed currently)
38238c8a9a5SSteve French *
38338c8a9a5SSteve French * if mark_smb_session is passed as true, unconditionally mark
38438c8a9a5SSteve French * the smb session (and tcon) for reconnect as well. This value
38538c8a9a5SSteve French * doesn't really matter for non-multichannel scenario.
38638c8a9a5SSteve French *
38738c8a9a5SSteve French */
__cifs_reconnect(struct TCP_Server_Info * server,bool mark_smb_session)38838c8a9a5SSteve French static int __cifs_reconnect(struct TCP_Server_Info *server,
38938c8a9a5SSteve French bool mark_smb_session)
39038c8a9a5SSteve French {
39138c8a9a5SSteve French int rc = 0;
39238c8a9a5SSteve French
39338c8a9a5SSteve French if (!cifs_tcp_ses_needs_reconnect(server, 1))
39438c8a9a5SSteve French return 0;
39538c8a9a5SSteve French
39638c8a9a5SSteve French cifs_mark_tcp_ses_conns_for_reconnect(server, mark_smb_session);
39738c8a9a5SSteve French
39838c8a9a5SSteve French cifs_abort_connection(server);
39938c8a9a5SSteve French
40038c8a9a5SSteve French do {
40138c8a9a5SSteve French try_to_freeze();
40238c8a9a5SSteve French cifs_server_lock(server);
40338c8a9a5SSteve French
40438c8a9a5SSteve French if (!cifs_swn_set_server_dstaddr(server)) {
40538c8a9a5SSteve French /* resolve the hostname again to make sure that IP address is up-to-date */
40638c8a9a5SSteve French rc = reconn_set_ipaddr_from_hostname(server);
40738c8a9a5SSteve French cifs_dbg(FYI, "%s: reconn_set_ipaddr_from_hostname: rc=%d\n", __func__, rc);
40838c8a9a5SSteve French }
40938c8a9a5SSteve French
41038c8a9a5SSteve French if (cifs_rdma_enabled(server))
41138c8a9a5SSteve French rc = smbd_reconnect(server);
41238c8a9a5SSteve French else
41338c8a9a5SSteve French rc = generic_ip_connect(server);
41438c8a9a5SSteve French if (rc) {
41538c8a9a5SSteve French cifs_server_unlock(server);
41638c8a9a5SSteve French cifs_dbg(FYI, "%s: reconnect error %d\n", __func__, rc);
41738c8a9a5SSteve French msleep(3000);
41838c8a9a5SSteve French } else {
41938c8a9a5SSteve French atomic_inc(&tcpSesReconnectCount);
42038c8a9a5SSteve French set_credits(server, 1);
42138c8a9a5SSteve French spin_lock(&server->srv_lock);
42238c8a9a5SSteve French if (server->tcpStatus != CifsExiting)
42338c8a9a5SSteve French server->tcpStatus = CifsNeedNegotiate;
42438c8a9a5SSteve French spin_unlock(&server->srv_lock);
42538c8a9a5SSteve French cifs_swn_reset_server_dstaddr(server);
42638c8a9a5SSteve French cifs_server_unlock(server);
4273a0ef868SShyam Prasad N mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
42838c8a9a5SSteve French }
42938c8a9a5SSteve French } while (server->tcpStatus == CifsNeedReconnect);
43038c8a9a5SSteve French
43138c8a9a5SSteve French spin_lock(&server->srv_lock);
43238c8a9a5SSteve French if (server->tcpStatus == CifsNeedNegotiate)
43338c8a9a5SSteve French mod_delayed_work(cifsiod_wq, &server->echo, 0);
43438c8a9a5SSteve French spin_unlock(&server->srv_lock);
43538c8a9a5SSteve French
43638c8a9a5SSteve French wake_up(&server->response_q);
43738c8a9a5SSteve French return rc;
43838c8a9a5SSteve French }
43938c8a9a5SSteve French
44038c8a9a5SSteve French #ifdef CONFIG_CIFS_DFS_UPCALL
__reconnect_target_unlocked(struct TCP_Server_Info * server,const char * target)44138c8a9a5SSteve French static int __reconnect_target_unlocked(struct TCP_Server_Info *server, const char *target)
44238c8a9a5SSteve French {
44338c8a9a5SSteve French int rc;
44438c8a9a5SSteve French char *hostname;
44538c8a9a5SSteve French
44638c8a9a5SSteve French if (!cifs_swn_set_server_dstaddr(server)) {
44738c8a9a5SSteve French if (server->hostname != target) {
44838c8a9a5SSteve French hostname = extract_hostname(target);
44938c8a9a5SSteve French if (!IS_ERR(hostname)) {
45038c8a9a5SSteve French spin_lock(&server->srv_lock);
45138c8a9a5SSteve French kfree(server->hostname);
45238c8a9a5SSteve French server->hostname = hostname;
45338c8a9a5SSteve French spin_unlock(&server->srv_lock);
45438c8a9a5SSteve French } else {
45538c8a9a5SSteve French cifs_dbg(FYI, "%s: couldn't extract hostname or address from dfs target: %ld\n",
45638c8a9a5SSteve French __func__, PTR_ERR(hostname));
45738c8a9a5SSteve French cifs_dbg(FYI, "%s: default to last target server: %s\n", __func__,
45838c8a9a5SSteve French server->hostname);
45938c8a9a5SSteve French }
46038c8a9a5SSteve French }
46138c8a9a5SSteve French /* resolve the hostname again to make sure that IP address is up-to-date. */
46238c8a9a5SSteve French rc = reconn_set_ipaddr_from_hostname(server);
46338c8a9a5SSteve French cifs_dbg(FYI, "%s: reconn_set_ipaddr_from_hostname: rc=%d\n", __func__, rc);
46438c8a9a5SSteve French }
46538c8a9a5SSteve French /* Reconnect the socket */
46638c8a9a5SSteve French if (cifs_rdma_enabled(server))
46738c8a9a5SSteve French rc = smbd_reconnect(server);
46838c8a9a5SSteve French else
46938c8a9a5SSteve French rc = generic_ip_connect(server);
47038c8a9a5SSteve French
47138c8a9a5SSteve French return rc;
47238c8a9a5SSteve French }
47338c8a9a5SSteve French
reconnect_target_unlocked(struct TCP_Server_Info * server,struct dfs_cache_tgt_list * tl,struct dfs_cache_tgt_iterator ** target_hint)47438c8a9a5SSteve French static int reconnect_target_unlocked(struct TCP_Server_Info *server, struct dfs_cache_tgt_list *tl,
47538c8a9a5SSteve French struct dfs_cache_tgt_iterator **target_hint)
47638c8a9a5SSteve French {
47738c8a9a5SSteve French int rc;
47838c8a9a5SSteve French struct dfs_cache_tgt_iterator *tit;
47938c8a9a5SSteve French
48038c8a9a5SSteve French *target_hint = NULL;
48138c8a9a5SSteve French
48238c8a9a5SSteve French /* If dfs target list is empty, then reconnect to last server */
48338c8a9a5SSteve French tit = dfs_cache_get_tgt_iterator(tl);
48438c8a9a5SSteve French if (!tit)
48538c8a9a5SSteve French return __reconnect_target_unlocked(server, server->hostname);
48638c8a9a5SSteve French
48738c8a9a5SSteve French /* Otherwise, try every dfs target in @tl */
48838c8a9a5SSteve French for (; tit; tit = dfs_cache_get_next_tgt(tl, tit)) {
48938c8a9a5SSteve French rc = __reconnect_target_unlocked(server, dfs_cache_get_tgt_name(tit));
49038c8a9a5SSteve French if (!rc) {
49138c8a9a5SSteve French *target_hint = tit;
49238c8a9a5SSteve French break;
49338c8a9a5SSteve French }
49438c8a9a5SSteve French }
49538c8a9a5SSteve French return rc;
49638c8a9a5SSteve French }
49738c8a9a5SSteve French
reconnect_dfs_server(struct TCP_Server_Info * server)49838c8a9a5SSteve French static int reconnect_dfs_server(struct TCP_Server_Info *server)
49938c8a9a5SSteve French {
50038c8a9a5SSteve French struct dfs_cache_tgt_iterator *target_hint = NULL;
501da70c1d3SPierre Mariani
5023fea12f3SPaulo Alcantara DFS_CACHE_TGT_LIST(tl);
50338c8a9a5SSteve French int num_targets = 0;
5043fea12f3SPaulo Alcantara int rc = 0;
50538c8a9a5SSteve French
50638c8a9a5SSteve French /*
50738c8a9a5SSteve French * Determine the number of dfs targets the referral path in @cifs_sb resolves to.
50838c8a9a5SSteve French *
50938c8a9a5SSteve French * smb2_reconnect() needs to know how long it should wait based upon the number of dfs
51038c8a9a5SSteve French * targets (server->nr_targets). It's also possible that the cached referral was cleared
51138c8a9a5SSteve French * through /proc/fs/cifs/dfscache or the target list is empty due to server settings after
51238c8a9a5SSteve French * refreshing the referral, so, in this case, default it to 1.
51338c8a9a5SSteve French */
51438c8a9a5SSteve French mutex_lock(&server->refpath_lock);
51538c8a9a5SSteve French if (!dfs_cache_noreq_find(server->leaf_fullpath + 1, NULL, &tl))
51638c8a9a5SSteve French num_targets = dfs_cache_get_nr_tgts(&tl);
51738c8a9a5SSteve French mutex_unlock(&server->refpath_lock);
51838c8a9a5SSteve French if (!num_targets)
51938c8a9a5SSteve French num_targets = 1;
52038c8a9a5SSteve French
52138c8a9a5SSteve French if (!cifs_tcp_ses_needs_reconnect(server, num_targets))
52238c8a9a5SSteve French return 0;
52338c8a9a5SSteve French
52438c8a9a5SSteve French /*
52538c8a9a5SSteve French * Unconditionally mark all sessions & tcons for reconnect as we might be connecting to a
52638c8a9a5SSteve French * different server or share during failover. It could be improved by adding some logic to
52738c8a9a5SSteve French * only do that in case it connects to a different server or share, though.
52838c8a9a5SSteve French */
52938c8a9a5SSteve French cifs_mark_tcp_ses_conns_for_reconnect(server, true);
53038c8a9a5SSteve French
53138c8a9a5SSteve French cifs_abort_connection(server);
53238c8a9a5SSteve French
53338c8a9a5SSteve French do {
53438c8a9a5SSteve French try_to_freeze();
53538c8a9a5SSteve French cifs_server_lock(server);
53638c8a9a5SSteve French
53738c8a9a5SSteve French rc = reconnect_target_unlocked(server, &tl, &target_hint);
53838c8a9a5SSteve French if (rc) {
53938c8a9a5SSteve French /* Failed to reconnect socket */
54038c8a9a5SSteve French cifs_server_unlock(server);
54138c8a9a5SSteve French cifs_dbg(FYI, "%s: reconnect error %d\n", __func__, rc);
54238c8a9a5SSteve French msleep(3000);
54338c8a9a5SSteve French continue;
54438c8a9a5SSteve French }
54538c8a9a5SSteve French /*
54638c8a9a5SSteve French * Socket was created. Update tcp session status to CifsNeedNegotiate so that a
54738c8a9a5SSteve French * process waiting for reconnect will know it needs to re-establish session and tcon
54838c8a9a5SSteve French * through the reconnected target server.
54938c8a9a5SSteve French */
55038c8a9a5SSteve French atomic_inc(&tcpSesReconnectCount);
55138c8a9a5SSteve French set_credits(server, 1);
55238c8a9a5SSteve French spin_lock(&server->srv_lock);
55338c8a9a5SSteve French if (server->tcpStatus != CifsExiting)
55438c8a9a5SSteve French server->tcpStatus = CifsNeedNegotiate;
55538c8a9a5SSteve French spin_unlock(&server->srv_lock);
55638c8a9a5SSteve French cifs_swn_reset_server_dstaddr(server);
55738c8a9a5SSteve French cifs_server_unlock(server);
5583a0ef868SShyam Prasad N mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
55938c8a9a5SSteve French } while (server->tcpStatus == CifsNeedReconnect);
56038c8a9a5SSteve French
56138c8a9a5SSteve French mutex_lock(&server->refpath_lock);
56238c8a9a5SSteve French dfs_cache_noreq_update_tgthint(server->leaf_fullpath + 1, target_hint);
56338c8a9a5SSteve French mutex_unlock(&server->refpath_lock);
56438c8a9a5SSteve French dfs_cache_free_tgts(&tl);
56538c8a9a5SSteve French
56638c8a9a5SSteve French /* Need to set up echo worker again once connection has been established */
56738c8a9a5SSteve French spin_lock(&server->srv_lock);
56838c8a9a5SSteve French if (server->tcpStatus == CifsNeedNegotiate)
56938c8a9a5SSteve French mod_delayed_work(cifsiod_wq, &server->echo, 0);
57038c8a9a5SSteve French spin_unlock(&server->srv_lock);
57138c8a9a5SSteve French
57238c8a9a5SSteve French wake_up(&server->response_q);
57338c8a9a5SSteve French return rc;
57438c8a9a5SSteve French }
57538c8a9a5SSteve French
cifs_reconnect(struct TCP_Server_Info * server,bool mark_smb_session)57638c8a9a5SSteve French int cifs_reconnect(struct TCP_Server_Info *server, bool mark_smb_session)
57738c8a9a5SSteve French {
57838c8a9a5SSteve French mutex_lock(&server->refpath_lock);
57938c8a9a5SSteve French if (!server->leaf_fullpath) {
58038c8a9a5SSteve French mutex_unlock(&server->refpath_lock);
58138c8a9a5SSteve French return __cifs_reconnect(server, mark_smb_session);
58238c8a9a5SSteve French }
58338c8a9a5SSteve French mutex_unlock(&server->refpath_lock);
58438c8a9a5SSteve French
58538c8a9a5SSteve French return reconnect_dfs_server(server);
58638c8a9a5SSteve French }
58738c8a9a5SSteve French #else
cifs_reconnect(struct TCP_Server_Info * server,bool mark_smb_session)58838c8a9a5SSteve French int cifs_reconnect(struct TCP_Server_Info *server, bool mark_smb_session)
58938c8a9a5SSteve French {
59038c8a9a5SSteve French return __cifs_reconnect(server, mark_smb_session);
59138c8a9a5SSteve French }
59238c8a9a5SSteve French #endif
59338c8a9a5SSteve French
59438c8a9a5SSteve French static void
cifs_echo_request(struct work_struct * work)59538c8a9a5SSteve French cifs_echo_request(struct work_struct *work)
59638c8a9a5SSteve French {
59738c8a9a5SSteve French int rc;
59838c8a9a5SSteve French struct TCP_Server_Info *server = container_of(work,
59938c8a9a5SSteve French struct TCP_Server_Info, echo.work);
60038c8a9a5SSteve French
60138c8a9a5SSteve French /*
60238c8a9a5SSteve French * We cannot send an echo if it is disabled.
60338c8a9a5SSteve French * Also, no need to ping if we got a response recently.
60438c8a9a5SSteve French */
60538c8a9a5SSteve French
60638c8a9a5SSteve French if (server->tcpStatus == CifsNeedReconnect ||
60738c8a9a5SSteve French server->tcpStatus == CifsExiting ||
60838c8a9a5SSteve French server->tcpStatus == CifsNew ||
60938c8a9a5SSteve French (server->ops->can_echo && !server->ops->can_echo(server)) ||
61038c8a9a5SSteve French time_before(jiffies, server->lstrp + server->echo_interval - HZ))
61138c8a9a5SSteve French goto requeue_echo;
61238c8a9a5SSteve French
61338c8a9a5SSteve French rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
61438c8a9a5SSteve French cifs_server_dbg(FYI, "send echo request: rc = %d\n", rc);
61538c8a9a5SSteve French
61638c8a9a5SSteve French /* Check witness registrations */
61738c8a9a5SSteve French cifs_swn_check();
61838c8a9a5SSteve French
61938c8a9a5SSteve French requeue_echo:
62038c8a9a5SSteve French queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
62138c8a9a5SSteve French }
62238c8a9a5SSteve French
62338c8a9a5SSteve French static bool
allocate_buffers(struct TCP_Server_Info * server)62438c8a9a5SSteve French allocate_buffers(struct TCP_Server_Info *server)
62538c8a9a5SSteve French {
62638c8a9a5SSteve French if (!server->bigbuf) {
62738c8a9a5SSteve French server->bigbuf = (char *)cifs_buf_get();
62838c8a9a5SSteve French if (!server->bigbuf) {
62938c8a9a5SSteve French cifs_server_dbg(VFS, "No memory for large SMB response\n");
63038c8a9a5SSteve French msleep(3000);
63138c8a9a5SSteve French /* retry will check if exiting */
63238c8a9a5SSteve French return false;
63338c8a9a5SSteve French }
63438c8a9a5SSteve French } else if (server->large_buf) {
63538c8a9a5SSteve French /* we are reusing a dirty large buf, clear its start */
63638c8a9a5SSteve French memset(server->bigbuf, 0, HEADER_SIZE(server));
63738c8a9a5SSteve French }
63838c8a9a5SSteve French
63938c8a9a5SSteve French if (!server->smallbuf) {
64038c8a9a5SSteve French server->smallbuf = (char *)cifs_small_buf_get();
64138c8a9a5SSteve French if (!server->smallbuf) {
64238c8a9a5SSteve French cifs_server_dbg(VFS, "No memory for SMB response\n");
64338c8a9a5SSteve French msleep(1000);
64438c8a9a5SSteve French /* retry will check if exiting */
64538c8a9a5SSteve French return false;
64638c8a9a5SSteve French }
64738c8a9a5SSteve French /* beginning of smb buffer is cleared in our buf_get */
64838c8a9a5SSteve French } else {
64938c8a9a5SSteve French /* if existing small buf clear beginning */
65038c8a9a5SSteve French memset(server->smallbuf, 0, HEADER_SIZE(server));
65138c8a9a5SSteve French }
65238c8a9a5SSteve French
65338c8a9a5SSteve French return true;
65438c8a9a5SSteve French }
65538c8a9a5SSteve French
65638c8a9a5SSteve French static bool
server_unresponsive(struct TCP_Server_Info * server)65738c8a9a5SSteve French server_unresponsive(struct TCP_Server_Info *server)
65838c8a9a5SSteve French {
65938c8a9a5SSteve French /*
66038c8a9a5SSteve French * We need to wait 3 echo intervals to make sure we handle such
66138c8a9a5SSteve French * situations right:
66238c8a9a5SSteve French * 1s client sends a normal SMB request
66338c8a9a5SSteve French * 2s client gets a response
66438c8a9a5SSteve French * 30s echo workqueue job pops, and decides we got a response recently
66538c8a9a5SSteve French * and don't need to send another
66638c8a9a5SSteve French * ...
66738c8a9a5SSteve French * 65s kernel_recvmsg times out, and we see that we haven't gotten
66838c8a9a5SSteve French * a response in >60s.
66938c8a9a5SSteve French */
67038c8a9a5SSteve French spin_lock(&server->srv_lock);
67138c8a9a5SSteve French if ((server->tcpStatus == CifsGood ||
67238c8a9a5SSteve French server->tcpStatus == CifsNeedNegotiate) &&
67338c8a9a5SSteve French (!server->ops->can_echo || server->ops->can_echo(server)) &&
67438c8a9a5SSteve French time_after(jiffies, server->lstrp + 3 * server->echo_interval)) {
67538c8a9a5SSteve French spin_unlock(&server->srv_lock);
67638c8a9a5SSteve French cifs_server_dbg(VFS, "has not responded in %lu seconds. Reconnecting...\n",
67738c8a9a5SSteve French (3 * server->echo_interval) / HZ);
67838c8a9a5SSteve French cifs_reconnect(server, false);
67938c8a9a5SSteve French return true;
68038c8a9a5SSteve French }
68138c8a9a5SSteve French spin_unlock(&server->srv_lock);
68238c8a9a5SSteve French
68338c8a9a5SSteve French return false;
68438c8a9a5SSteve French }
68538c8a9a5SSteve French
68638c8a9a5SSteve French static inline bool
zero_credits(struct TCP_Server_Info * server)68738c8a9a5SSteve French zero_credits(struct TCP_Server_Info *server)
68838c8a9a5SSteve French {
68938c8a9a5SSteve French int val;
69038c8a9a5SSteve French
69138c8a9a5SSteve French spin_lock(&server->req_lock);
69238c8a9a5SSteve French val = server->credits + server->echo_credits + server->oplock_credits;
69338c8a9a5SSteve French if (server->in_flight == 0 && val == 0) {
69438c8a9a5SSteve French spin_unlock(&server->req_lock);
69538c8a9a5SSteve French return true;
69638c8a9a5SSteve French }
69738c8a9a5SSteve French spin_unlock(&server->req_lock);
69838c8a9a5SSteve French return false;
69938c8a9a5SSteve French }
70038c8a9a5SSteve French
70138c8a9a5SSteve French static int
cifs_readv_from_socket(struct TCP_Server_Info * server,struct msghdr * smb_msg)70238c8a9a5SSteve French cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
70338c8a9a5SSteve French {
70438c8a9a5SSteve French int length = 0;
70538c8a9a5SSteve French int total_read;
70638c8a9a5SSteve French
70738c8a9a5SSteve French for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
70838c8a9a5SSteve French try_to_freeze();
70938c8a9a5SSteve French
71038c8a9a5SSteve French /* reconnect if no credits and no requests in flight */
71138c8a9a5SSteve French if (zero_credits(server)) {
71238c8a9a5SSteve French cifs_reconnect(server, false);
71338c8a9a5SSteve French return -ECONNABORTED;
71438c8a9a5SSteve French }
71538c8a9a5SSteve French
71638c8a9a5SSteve French if (server_unresponsive(server))
71738c8a9a5SSteve French return -ECONNABORTED;
71838c8a9a5SSteve French if (cifs_rdma_enabled(server) && server->smbd_conn)
71938c8a9a5SSteve French length = smbd_recv(server->smbd_conn, smb_msg);
72038c8a9a5SSteve French else
72138c8a9a5SSteve French length = sock_recvmsg(server->ssocket, smb_msg, 0);
72238c8a9a5SSteve French
72338c8a9a5SSteve French spin_lock(&server->srv_lock);
72438c8a9a5SSteve French if (server->tcpStatus == CifsExiting) {
72538c8a9a5SSteve French spin_unlock(&server->srv_lock);
72638c8a9a5SSteve French return -ESHUTDOWN;
72738c8a9a5SSteve French }
72838c8a9a5SSteve French
72938c8a9a5SSteve French if (server->tcpStatus == CifsNeedReconnect) {
73038c8a9a5SSteve French spin_unlock(&server->srv_lock);
73138c8a9a5SSteve French cifs_reconnect(server, false);
73238c8a9a5SSteve French return -ECONNABORTED;
73338c8a9a5SSteve French }
73438c8a9a5SSteve French spin_unlock(&server->srv_lock);
73538c8a9a5SSteve French
73638c8a9a5SSteve French if (length == -ERESTARTSYS ||
73738c8a9a5SSteve French length == -EAGAIN ||
73838c8a9a5SSteve French length == -EINTR) {
73938c8a9a5SSteve French /*
74038c8a9a5SSteve French * Minimum sleep to prevent looping, allowing socket
74138c8a9a5SSteve French * to clear and app threads to set tcpStatus
74238c8a9a5SSteve French * CifsNeedReconnect if server hung.
74338c8a9a5SSteve French */
74438c8a9a5SSteve French usleep_range(1000, 2000);
74538c8a9a5SSteve French length = 0;
74638c8a9a5SSteve French continue;
74738c8a9a5SSteve French }
74838c8a9a5SSteve French
74938c8a9a5SSteve French if (length <= 0) {
75038c8a9a5SSteve French cifs_dbg(FYI, "Received no data or error: %d\n", length);
75138c8a9a5SSteve French cifs_reconnect(server, false);
75238c8a9a5SSteve French return -ECONNABORTED;
75338c8a9a5SSteve French }
75438c8a9a5SSteve French }
75538c8a9a5SSteve French return total_read;
75638c8a9a5SSteve French }
75738c8a9a5SSteve French
75838c8a9a5SSteve French int
cifs_read_from_socket(struct TCP_Server_Info * server,char * buf,unsigned int to_read)75938c8a9a5SSteve French cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
76038c8a9a5SSteve French unsigned int to_read)
76138c8a9a5SSteve French {
76238c8a9a5SSteve French struct msghdr smb_msg = {};
76338c8a9a5SSteve French struct kvec iov = {.iov_base = buf, .iov_len = to_read};
764da70c1d3SPierre Mariani
76538c8a9a5SSteve French iov_iter_kvec(&smb_msg.msg_iter, ITER_DEST, &iov, 1, to_read);
76638c8a9a5SSteve French
76738c8a9a5SSteve French return cifs_readv_from_socket(server, &smb_msg);
76838c8a9a5SSteve French }
76938c8a9a5SSteve French
77038c8a9a5SSteve French ssize_t
cifs_discard_from_socket(struct TCP_Server_Info * server,size_t to_read)77138c8a9a5SSteve French cifs_discard_from_socket(struct TCP_Server_Info *server, size_t to_read)
77238c8a9a5SSteve French {
77338c8a9a5SSteve French struct msghdr smb_msg = {};
77438c8a9a5SSteve French
77538c8a9a5SSteve French /*
77638c8a9a5SSteve French * iov_iter_discard already sets smb_msg.type and count and iov_offset
77738c8a9a5SSteve French * and cifs_readv_from_socket sets msg_control and msg_controllen
77838c8a9a5SSteve French * so little to initialize in struct msghdr
77938c8a9a5SSteve French */
78038c8a9a5SSteve French iov_iter_discard(&smb_msg.msg_iter, ITER_DEST, to_read);
78138c8a9a5SSteve French
78238c8a9a5SSteve French return cifs_readv_from_socket(server, &smb_msg);
78338c8a9a5SSteve French }
78438c8a9a5SSteve French
78538c8a9a5SSteve French int
cifs_read_page_from_socket(struct TCP_Server_Info * server,struct page * page,unsigned int page_offset,unsigned int to_read)78638c8a9a5SSteve French cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
78738c8a9a5SSteve French unsigned int page_offset, unsigned int to_read)
78838c8a9a5SSteve French {
78938c8a9a5SSteve French struct msghdr smb_msg = {};
79038c8a9a5SSteve French struct bio_vec bv;
79138c8a9a5SSteve French
79238c8a9a5SSteve French bvec_set_page(&bv, page, to_read, page_offset);
79338c8a9a5SSteve French iov_iter_bvec(&smb_msg.msg_iter, ITER_DEST, &bv, 1, to_read);
79438c8a9a5SSteve French return cifs_readv_from_socket(server, &smb_msg);
79538c8a9a5SSteve French }
79638c8a9a5SSteve French
79738c8a9a5SSteve French int
cifs_read_iter_from_socket(struct TCP_Server_Info * server,struct iov_iter * iter,unsigned int to_read)79838c8a9a5SSteve French cifs_read_iter_from_socket(struct TCP_Server_Info *server, struct iov_iter *iter,
79938c8a9a5SSteve French unsigned int to_read)
80038c8a9a5SSteve French {
80138c8a9a5SSteve French struct msghdr smb_msg = { .msg_iter = *iter };
80238c8a9a5SSteve French int ret;
80338c8a9a5SSteve French
80438c8a9a5SSteve French iov_iter_truncate(&smb_msg.msg_iter, to_read);
80538c8a9a5SSteve French ret = cifs_readv_from_socket(server, &smb_msg);
80638c8a9a5SSteve French if (ret > 0)
80738c8a9a5SSteve French iov_iter_advance(iter, ret);
80838c8a9a5SSteve French return ret;
80938c8a9a5SSteve French }
81038c8a9a5SSteve French
81138c8a9a5SSteve French static bool
is_smb_response(struct TCP_Server_Info * server,unsigned char type)81238c8a9a5SSteve French is_smb_response(struct TCP_Server_Info *server, unsigned char type)
81338c8a9a5SSteve French {
81438c8a9a5SSteve French /*
81538c8a9a5SSteve French * The first byte big endian of the length field,
81638c8a9a5SSteve French * is actually not part of the length but the type
81738c8a9a5SSteve French * with the most common, zero, as regular data.
81838c8a9a5SSteve French */
81938c8a9a5SSteve French switch (type) {
82038c8a9a5SSteve French case RFC1002_SESSION_MESSAGE:
82138c8a9a5SSteve French /* Regular SMB response */
82238c8a9a5SSteve French return true;
82338c8a9a5SSteve French case RFC1002_SESSION_KEEP_ALIVE:
82438c8a9a5SSteve French cifs_dbg(FYI, "RFC 1002 session keep alive\n");
82538c8a9a5SSteve French break;
82638c8a9a5SSteve French case RFC1002_POSITIVE_SESSION_RESPONSE:
82738c8a9a5SSteve French cifs_dbg(FYI, "RFC 1002 positive session response\n");
82838c8a9a5SSteve French break;
82938c8a9a5SSteve French case RFC1002_NEGATIVE_SESSION_RESPONSE:
83038c8a9a5SSteve French /*
83138c8a9a5SSteve French * We get this from Windows 98 instead of an error on
83238c8a9a5SSteve French * SMB negprot response.
83338c8a9a5SSteve French */
83438c8a9a5SSteve French cifs_dbg(FYI, "RFC 1002 negative session response\n");
83538c8a9a5SSteve French /* give server a second to clean up */
83638c8a9a5SSteve French msleep(1000);
83738c8a9a5SSteve French /*
83838c8a9a5SSteve French * Always try 445 first on reconnect since we get NACK
83938c8a9a5SSteve French * on some if we ever connected to port 139 (the NACK
84038c8a9a5SSteve French * is since we do not begin with RFC1001 session
84138c8a9a5SSteve French * initialize frame).
84238c8a9a5SSteve French */
84338c8a9a5SSteve French cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
84438c8a9a5SSteve French cifs_reconnect(server, true);
84538c8a9a5SSteve French break;
84638c8a9a5SSteve French default:
84738c8a9a5SSteve French cifs_server_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
84838c8a9a5SSteve French cifs_reconnect(server, true);
84938c8a9a5SSteve French }
85038c8a9a5SSteve French
85138c8a9a5SSteve French return false;
85238c8a9a5SSteve French }
85338c8a9a5SSteve French
85438c8a9a5SSteve French void
dequeue_mid(struct mid_q_entry * mid,bool malformed)85538c8a9a5SSteve French dequeue_mid(struct mid_q_entry *mid, bool malformed)
85638c8a9a5SSteve French {
85738c8a9a5SSteve French #ifdef CONFIG_CIFS_STATS2
85838c8a9a5SSteve French mid->when_received = jiffies;
85938c8a9a5SSteve French #endif
86038c8a9a5SSteve French spin_lock(&mid->server->mid_lock);
86138c8a9a5SSteve French if (!malformed)
86238c8a9a5SSteve French mid->mid_state = MID_RESPONSE_RECEIVED;
86338c8a9a5SSteve French else
86438c8a9a5SSteve French mid->mid_state = MID_RESPONSE_MALFORMED;
86538c8a9a5SSteve French /*
86638c8a9a5SSteve French * Trying to handle/dequeue a mid after the send_recv()
86738c8a9a5SSteve French * function has finished processing it is a bug.
86838c8a9a5SSteve French */
86938c8a9a5SSteve French if (mid->mid_flags & MID_DELETED) {
87038c8a9a5SSteve French spin_unlock(&mid->server->mid_lock);
87138c8a9a5SSteve French pr_warn_once("trying to dequeue a deleted mid\n");
87238c8a9a5SSteve French } else {
87338c8a9a5SSteve French list_del_init(&mid->qhead);
87438c8a9a5SSteve French mid->mid_flags |= MID_DELETED;
87538c8a9a5SSteve French spin_unlock(&mid->server->mid_lock);
87638c8a9a5SSteve French }
87738c8a9a5SSteve French }
87838c8a9a5SSteve French
87938c8a9a5SSteve French static unsigned int
smb2_get_credits_from_hdr(char * buffer,struct TCP_Server_Info * server)88038c8a9a5SSteve French smb2_get_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
88138c8a9a5SSteve French {
88238c8a9a5SSteve French struct smb2_hdr *shdr = (struct smb2_hdr *)buffer;
88338c8a9a5SSteve French
88438c8a9a5SSteve French /*
88538c8a9a5SSteve French * SMB1 does not use credits.
88638c8a9a5SSteve French */
88738c8a9a5SSteve French if (is_smb1(server))
88838c8a9a5SSteve French return 0;
88938c8a9a5SSteve French
89038c8a9a5SSteve French return le16_to_cpu(shdr->CreditRequest);
89138c8a9a5SSteve French }
89238c8a9a5SSteve French
89338c8a9a5SSteve French static void
handle_mid(struct mid_q_entry * mid,struct TCP_Server_Info * server,char * buf,int malformed)89438c8a9a5SSteve French handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
89538c8a9a5SSteve French char *buf, int malformed)
89638c8a9a5SSteve French {
89738c8a9a5SSteve French if (server->ops->check_trans2 &&
89838c8a9a5SSteve French server->ops->check_trans2(mid, server, buf, malformed))
89938c8a9a5SSteve French return;
90038c8a9a5SSteve French mid->credits_received = smb2_get_credits_from_hdr(buf, server);
90138c8a9a5SSteve French mid->resp_buf = buf;
90238c8a9a5SSteve French mid->large_buf = server->large_buf;
90338c8a9a5SSteve French /* Was previous buf put in mpx struct for multi-rsp? */
90438c8a9a5SSteve French if (!mid->multiRsp) {
90538c8a9a5SSteve French /* smb buffer will be freed by user thread */
90638c8a9a5SSteve French if (server->large_buf)
90738c8a9a5SSteve French server->bigbuf = NULL;
90838c8a9a5SSteve French else
90938c8a9a5SSteve French server->smallbuf = NULL;
91038c8a9a5SSteve French }
91138c8a9a5SSteve French dequeue_mid(mid, malformed);
91238c8a9a5SSteve French }
91338c8a9a5SSteve French
91438c8a9a5SSteve French int
cifs_enable_signing(struct TCP_Server_Info * server,bool mnt_sign_required)91538c8a9a5SSteve French cifs_enable_signing(struct TCP_Server_Info *server, bool mnt_sign_required)
91638c8a9a5SSteve French {
91738c8a9a5SSteve French bool srv_sign_required = server->sec_mode & server->vals->signing_required;
91838c8a9a5SSteve French bool srv_sign_enabled = server->sec_mode & server->vals->signing_enabled;
91938c8a9a5SSteve French bool mnt_sign_enabled;
92038c8a9a5SSteve French
92138c8a9a5SSteve French /*
92238c8a9a5SSteve French * Is signing required by mnt options? If not then check
92338c8a9a5SSteve French * global_secflags to see if it is there.
92438c8a9a5SSteve French */
92538c8a9a5SSteve French if (!mnt_sign_required)
92638c8a9a5SSteve French mnt_sign_required = ((global_secflags & CIFSSEC_MUST_SIGN) ==
92738c8a9a5SSteve French CIFSSEC_MUST_SIGN);
92838c8a9a5SSteve French
92938c8a9a5SSteve French /*
93038c8a9a5SSteve French * If signing is required then it's automatically enabled too,
93138c8a9a5SSteve French * otherwise, check to see if the secflags allow it.
93238c8a9a5SSteve French */
93338c8a9a5SSteve French mnt_sign_enabled = mnt_sign_required ? mnt_sign_required :
93438c8a9a5SSteve French (global_secflags & CIFSSEC_MAY_SIGN);
93538c8a9a5SSteve French
93638c8a9a5SSteve French /* If server requires signing, does client allow it? */
93738c8a9a5SSteve French if (srv_sign_required) {
93838c8a9a5SSteve French if (!mnt_sign_enabled) {
93938c8a9a5SSteve French cifs_dbg(VFS, "Server requires signing, but it's disabled in SecurityFlags!\n");
94038c8a9a5SSteve French return -EOPNOTSUPP;
94138c8a9a5SSteve French }
94238c8a9a5SSteve French server->sign = true;
94338c8a9a5SSteve French }
94438c8a9a5SSteve French
94538c8a9a5SSteve French /* If client requires signing, does server allow it? */
94638c8a9a5SSteve French if (mnt_sign_required) {
94738c8a9a5SSteve French if (!srv_sign_enabled) {
94838c8a9a5SSteve French cifs_dbg(VFS, "Server does not support signing!\n");
94938c8a9a5SSteve French return -EOPNOTSUPP;
95038c8a9a5SSteve French }
95138c8a9a5SSteve French server->sign = true;
95238c8a9a5SSteve French }
95338c8a9a5SSteve French
95438c8a9a5SSteve French if (cifs_rdma_enabled(server) && server->sign)
95538c8a9a5SSteve French cifs_dbg(VFS, "Signing is enabled, and RDMA read/write will be disabled\n");
95638c8a9a5SSteve French
95738c8a9a5SSteve French return 0;
95838c8a9a5SSteve French }
95938c8a9a5SSteve French
960946ad1b8SPaulo Alcantara static noinline_for_stack void
clean_demultiplex_info(struct TCP_Server_Info * server)961946ad1b8SPaulo Alcantara clean_demultiplex_info(struct TCP_Server_Info *server)
96238c8a9a5SSteve French {
96338c8a9a5SSteve French int length;
96438c8a9a5SSteve French
96538c8a9a5SSteve French /* take it off the list, if it's not already */
96638c8a9a5SSteve French spin_lock(&server->srv_lock);
96738c8a9a5SSteve French list_del_init(&server->tcp_ses_list);
96838c8a9a5SSteve French spin_unlock(&server->srv_lock);
96938c8a9a5SSteve French
97038c8a9a5SSteve French cancel_delayed_work_sync(&server->echo);
97138c8a9a5SSteve French
97238c8a9a5SSteve French spin_lock(&server->srv_lock);
97338c8a9a5SSteve French server->tcpStatus = CifsExiting;
97438c8a9a5SSteve French spin_unlock(&server->srv_lock);
97538c8a9a5SSteve French wake_up_all(&server->response_q);
97638c8a9a5SSteve French
97738c8a9a5SSteve French /* check if we have blocked requests that need to free */
97838c8a9a5SSteve French spin_lock(&server->req_lock);
97938c8a9a5SSteve French if (server->credits <= 0)
98038c8a9a5SSteve French server->credits = 1;
98138c8a9a5SSteve French spin_unlock(&server->req_lock);
98238c8a9a5SSteve French /*
98338c8a9a5SSteve French * Although there should not be any requests blocked on this queue it
98438c8a9a5SSteve French * can not hurt to be paranoid and try to wake up requests that may
98538c8a9a5SSteve French * haven been blocked when more than 50 at time were on the wire to the
98638c8a9a5SSteve French * same server - they now will see the session is in exit state and get
98738c8a9a5SSteve French * out of SendReceive.
98838c8a9a5SSteve French */
98938c8a9a5SSteve French wake_up_all(&server->request_q);
99038c8a9a5SSteve French /* give those requests time to exit */
99138c8a9a5SSteve French msleep(125);
99238c8a9a5SSteve French if (cifs_rdma_enabled(server))
99338c8a9a5SSteve French smbd_destroy(server);
99438c8a9a5SSteve French if (server->ssocket) {
99538c8a9a5SSteve French sock_release(server->ssocket);
99638c8a9a5SSteve French server->ssocket = NULL;
99738c8a9a5SSteve French }
99838c8a9a5SSteve French
99938c8a9a5SSteve French if (!list_empty(&server->pending_mid_q)) {
100038c8a9a5SSteve French struct list_head dispose_list;
100138c8a9a5SSteve French struct mid_q_entry *mid_entry;
100238c8a9a5SSteve French struct list_head *tmp, *tmp2;
100338c8a9a5SSteve French
100438c8a9a5SSteve French INIT_LIST_HEAD(&dispose_list);
100538c8a9a5SSteve French spin_lock(&server->mid_lock);
100638c8a9a5SSteve French list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
100738c8a9a5SSteve French mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
100838c8a9a5SSteve French cifs_dbg(FYI, "Clearing mid %llu\n", mid_entry->mid);
100938c8a9a5SSteve French kref_get(&mid_entry->refcount);
101038c8a9a5SSteve French mid_entry->mid_state = MID_SHUTDOWN;
101138c8a9a5SSteve French list_move(&mid_entry->qhead, &dispose_list);
101238c8a9a5SSteve French mid_entry->mid_flags |= MID_DELETED;
101338c8a9a5SSteve French }
101438c8a9a5SSteve French spin_unlock(&server->mid_lock);
101538c8a9a5SSteve French
101638c8a9a5SSteve French /* now walk dispose list and issue callbacks */
101738c8a9a5SSteve French list_for_each_safe(tmp, tmp2, &dispose_list) {
101838c8a9a5SSteve French mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
101938c8a9a5SSteve French cifs_dbg(FYI, "Callback mid %llu\n", mid_entry->mid);
102038c8a9a5SSteve French list_del_init(&mid_entry->qhead);
102138c8a9a5SSteve French mid_entry->callback(mid_entry);
102238c8a9a5SSteve French release_mid(mid_entry);
102338c8a9a5SSteve French }
102438c8a9a5SSteve French /* 1/8th of sec is more than enough time for them to exit */
102538c8a9a5SSteve French msleep(125);
102638c8a9a5SSteve French }
102738c8a9a5SSteve French
102838c8a9a5SSteve French if (!list_empty(&server->pending_mid_q)) {
102938c8a9a5SSteve French /*
103038c8a9a5SSteve French * mpx threads have not exited yet give them at least the smb
103138c8a9a5SSteve French * send timeout time for long ops.
103238c8a9a5SSteve French *
103338c8a9a5SSteve French * Due to delays on oplock break requests, we need to wait at
103438c8a9a5SSteve French * least 45 seconds before giving up on a request getting a
103538c8a9a5SSteve French * response and going ahead and killing cifsd.
103638c8a9a5SSteve French */
103738c8a9a5SSteve French cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
103838c8a9a5SSteve French msleep(46000);
103938c8a9a5SSteve French /*
104038c8a9a5SSteve French * If threads still have not exited they are probably never
104138c8a9a5SSteve French * coming home not much else we can do but free the memory.
104238c8a9a5SSteve French */
104338c8a9a5SSteve French }
104438c8a9a5SSteve French
104538c8a9a5SSteve French kfree(server->leaf_fullpath);
104638c8a9a5SSteve French kfree(server);
104738c8a9a5SSteve French
104838c8a9a5SSteve French length = atomic_dec_return(&tcpSesAllocCount);
104938c8a9a5SSteve French if (length > 0)
105038c8a9a5SSteve French mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
105138c8a9a5SSteve French }
105238c8a9a5SSteve French
105338c8a9a5SSteve French static int
standard_receive3(struct TCP_Server_Info * server,struct mid_q_entry * mid)105438c8a9a5SSteve French standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
105538c8a9a5SSteve French {
105638c8a9a5SSteve French int length;
105738c8a9a5SSteve French char *buf = server->smallbuf;
105838c8a9a5SSteve French unsigned int pdu_length = server->pdu_size;
105938c8a9a5SSteve French
106038c8a9a5SSteve French /* make sure this will fit in a large buffer */
106138c8a9a5SSteve French if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) -
106238c8a9a5SSteve French HEADER_PREAMBLE_SIZE(server)) {
106338c8a9a5SSteve French cifs_server_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
106438c8a9a5SSteve French cifs_reconnect(server, true);
106538c8a9a5SSteve French return -ECONNABORTED;
106638c8a9a5SSteve French }
106738c8a9a5SSteve French
106838c8a9a5SSteve French /* switch to large buffer if too big for a small one */
106938c8a9a5SSteve French if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
107038c8a9a5SSteve French server->large_buf = true;
107138c8a9a5SSteve French memcpy(server->bigbuf, buf, server->total_read);
107238c8a9a5SSteve French buf = server->bigbuf;
107338c8a9a5SSteve French }
107438c8a9a5SSteve French
107538c8a9a5SSteve French /* now read the rest */
107638c8a9a5SSteve French length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
107738c8a9a5SSteve French pdu_length - MID_HEADER_SIZE(server));
107838c8a9a5SSteve French
107938c8a9a5SSteve French if (length < 0)
108038c8a9a5SSteve French return length;
108138c8a9a5SSteve French server->total_read += length;
108238c8a9a5SSteve French
108338c8a9a5SSteve French dump_smb(buf, server->total_read);
108438c8a9a5SSteve French
108538c8a9a5SSteve French return cifs_handle_standard(server, mid);
108638c8a9a5SSteve French }
108738c8a9a5SSteve French
108838c8a9a5SSteve French int
cifs_handle_standard(struct TCP_Server_Info * server,struct mid_q_entry * mid)108938c8a9a5SSteve French cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
109038c8a9a5SSteve French {
109138c8a9a5SSteve French char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
109238c8a9a5SSteve French int rc;
109338c8a9a5SSteve French
109438c8a9a5SSteve French /*
109538c8a9a5SSteve French * We know that we received enough to get to the MID as we
109638c8a9a5SSteve French * checked the pdu_length earlier. Now check to see
109738c8a9a5SSteve French * if the rest of the header is OK.
109838c8a9a5SSteve French *
109938c8a9a5SSteve French * 48 bytes is enough to display the header and a little bit
110038c8a9a5SSteve French * into the payload for debugging purposes.
110138c8a9a5SSteve French */
110238c8a9a5SSteve French rc = server->ops->check_message(buf, server->total_read, server);
110338c8a9a5SSteve French if (rc)
110438c8a9a5SSteve French cifs_dump_mem("Bad SMB: ", buf,
110538c8a9a5SSteve French min_t(unsigned int, server->total_read, 48));
110638c8a9a5SSteve French
110738c8a9a5SSteve French if (server->ops->is_session_expired &&
110838c8a9a5SSteve French server->ops->is_session_expired(buf)) {
110938c8a9a5SSteve French cifs_reconnect(server, true);
111038c8a9a5SSteve French return -1;
111138c8a9a5SSteve French }
111238c8a9a5SSteve French
111338c8a9a5SSteve French if (server->ops->is_status_pending &&
111438c8a9a5SSteve French server->ops->is_status_pending(buf, server))
111538c8a9a5SSteve French return -1;
111638c8a9a5SSteve French
111738c8a9a5SSteve French if (!mid)
111838c8a9a5SSteve French return rc;
111938c8a9a5SSteve French
112038c8a9a5SSteve French handle_mid(mid, server, buf, rc);
112138c8a9a5SSteve French return 0;
112238c8a9a5SSteve French }
112338c8a9a5SSteve French
112438c8a9a5SSteve French static void
smb2_add_credits_from_hdr(char * buffer,struct TCP_Server_Info * server)112538c8a9a5SSteve French smb2_add_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
112638c8a9a5SSteve French {
112738c8a9a5SSteve French struct smb2_hdr *shdr = (struct smb2_hdr *)buffer;
112838c8a9a5SSteve French int scredits, in_flight;
112938c8a9a5SSteve French
113038c8a9a5SSteve French /*
113138c8a9a5SSteve French * SMB1 does not use credits.
113238c8a9a5SSteve French */
113338c8a9a5SSteve French if (is_smb1(server))
113438c8a9a5SSteve French return;
113538c8a9a5SSteve French
113638c8a9a5SSteve French if (shdr->CreditRequest) {
113738c8a9a5SSteve French spin_lock(&server->req_lock);
113838c8a9a5SSteve French server->credits += le16_to_cpu(shdr->CreditRequest);
113938c8a9a5SSteve French scredits = server->credits;
114038c8a9a5SSteve French in_flight = server->in_flight;
114138c8a9a5SSteve French spin_unlock(&server->req_lock);
114238c8a9a5SSteve French wake_up(&server->request_q);
114338c8a9a5SSteve French
114438c8a9a5SSteve French trace_smb3_hdr_credits(server->CurrentMid,
114538c8a9a5SSteve French server->conn_id, server->hostname, scredits,
114638c8a9a5SSteve French le16_to_cpu(shdr->CreditRequest), in_flight);
114738c8a9a5SSteve French cifs_server_dbg(FYI, "%s: added %u credits total=%d\n",
114838c8a9a5SSteve French __func__, le16_to_cpu(shdr->CreditRequest),
114938c8a9a5SSteve French scredits);
115038c8a9a5SSteve French }
115138c8a9a5SSteve French }
115238c8a9a5SSteve French
115338c8a9a5SSteve French
115438c8a9a5SSteve French static int
cifs_demultiplex_thread(void * p)115538c8a9a5SSteve French cifs_demultiplex_thread(void *p)
115638c8a9a5SSteve French {
115738c8a9a5SSteve French int i, num_mids, length;
115838c8a9a5SSteve French struct TCP_Server_Info *server = p;
115938c8a9a5SSteve French unsigned int pdu_length;
116038c8a9a5SSteve French unsigned int next_offset;
116138c8a9a5SSteve French char *buf = NULL;
116238c8a9a5SSteve French struct task_struct *task_to_wake = NULL;
116338c8a9a5SSteve French struct mid_q_entry *mids[MAX_COMPOUND];
116438c8a9a5SSteve French char *bufs[MAX_COMPOUND];
116538c8a9a5SSteve French unsigned int noreclaim_flag, num_io_timeout = 0;
116669cba9d3SShyam Prasad N bool pending_reconnect = false;
116738c8a9a5SSteve French
116838c8a9a5SSteve French noreclaim_flag = memalloc_noreclaim_save();
116938c8a9a5SSteve French cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
117038c8a9a5SSteve French
117138c8a9a5SSteve French length = atomic_inc_return(&tcpSesAllocCount);
117238c8a9a5SSteve French if (length > 1)
117338c8a9a5SSteve French mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
117438c8a9a5SSteve French
117538c8a9a5SSteve French set_freezable();
117638c8a9a5SSteve French allow_kernel_signal(SIGKILL);
117738c8a9a5SSteve French while (server->tcpStatus != CifsExiting) {
117838c8a9a5SSteve French if (try_to_freeze())
117938c8a9a5SSteve French continue;
118038c8a9a5SSteve French
118138c8a9a5SSteve French if (!allocate_buffers(server))
118238c8a9a5SSteve French continue;
118338c8a9a5SSteve French
118438c8a9a5SSteve French server->large_buf = false;
118538c8a9a5SSteve French buf = server->smallbuf;
118638c8a9a5SSteve French pdu_length = 4; /* enough to get RFC1001 header */
118738c8a9a5SSteve French
118838c8a9a5SSteve French length = cifs_read_from_socket(server, buf, pdu_length);
118938c8a9a5SSteve French if (length < 0)
119038c8a9a5SSteve French continue;
119138c8a9a5SSteve French
119238c8a9a5SSteve French if (is_smb1(server))
119338c8a9a5SSteve French server->total_read = length;
119438c8a9a5SSteve French else
119538c8a9a5SSteve French server->total_read = 0;
119638c8a9a5SSteve French
119738c8a9a5SSteve French /*
119838c8a9a5SSteve French * The right amount was read from socket - 4 bytes,
119938c8a9a5SSteve French * so we can now interpret the length field.
120038c8a9a5SSteve French */
120138c8a9a5SSteve French pdu_length = get_rfc1002_length(buf);
120238c8a9a5SSteve French
120338c8a9a5SSteve French cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
120438c8a9a5SSteve French if (!is_smb_response(server, buf[0]))
120538c8a9a5SSteve French continue;
120669cba9d3SShyam Prasad N
120769cba9d3SShyam Prasad N pending_reconnect = false;
120838c8a9a5SSteve French next_pdu:
120938c8a9a5SSteve French server->pdu_size = pdu_length;
121038c8a9a5SSteve French
121138c8a9a5SSteve French /* make sure we have enough to get to the MID */
121238c8a9a5SSteve French if (server->pdu_size < MID_HEADER_SIZE(server)) {
121338c8a9a5SSteve French cifs_server_dbg(VFS, "SMB response too short (%u bytes)\n",
121438c8a9a5SSteve French server->pdu_size);
121538c8a9a5SSteve French cifs_reconnect(server, true);
121638c8a9a5SSteve French continue;
121738c8a9a5SSteve French }
121838c8a9a5SSteve French
121938c8a9a5SSteve French /* read down to the MID */
122038c8a9a5SSteve French length = cifs_read_from_socket(server,
122138c8a9a5SSteve French buf + HEADER_PREAMBLE_SIZE(server),
122238c8a9a5SSteve French MID_HEADER_SIZE(server));
122338c8a9a5SSteve French if (length < 0)
122438c8a9a5SSteve French continue;
122538c8a9a5SSteve French server->total_read += length;
122638c8a9a5SSteve French
122738c8a9a5SSteve French if (server->ops->next_header) {
1228c0e98de9SPaulo Alcantara if (server->ops->next_header(server, buf, &next_offset)) {
1229c0e98de9SPaulo Alcantara cifs_dbg(VFS, "%s: malformed response (next_offset=%u)\n",
1230c0e98de9SPaulo Alcantara __func__, next_offset);
1231c0e98de9SPaulo Alcantara cifs_reconnect(server, true);
1232c0e98de9SPaulo Alcantara continue;
1233c0e98de9SPaulo Alcantara }
123438c8a9a5SSteve French if (next_offset)
123538c8a9a5SSteve French server->pdu_size = next_offset;
123638c8a9a5SSteve French }
123738c8a9a5SSteve French
123838c8a9a5SSteve French memset(mids, 0, sizeof(mids));
123938c8a9a5SSteve French memset(bufs, 0, sizeof(bufs));
124038c8a9a5SSteve French num_mids = 0;
124138c8a9a5SSteve French
124238c8a9a5SSteve French if (server->ops->is_transform_hdr &&
124338c8a9a5SSteve French server->ops->receive_transform &&
124438c8a9a5SSteve French server->ops->is_transform_hdr(buf)) {
124538c8a9a5SSteve French length = server->ops->receive_transform(server,
124638c8a9a5SSteve French mids,
124738c8a9a5SSteve French bufs,
124838c8a9a5SSteve French &num_mids);
124938c8a9a5SSteve French } else {
125038c8a9a5SSteve French mids[0] = server->ops->find_mid(server, buf);
125138c8a9a5SSteve French bufs[0] = buf;
125238c8a9a5SSteve French num_mids = 1;
125338c8a9a5SSteve French
125438c8a9a5SSteve French if (!mids[0] || !mids[0]->receive)
125538c8a9a5SSteve French length = standard_receive3(server, mids[0]);
125638c8a9a5SSteve French else
125738c8a9a5SSteve French length = mids[0]->receive(server, mids[0]);
125838c8a9a5SSteve French }
125938c8a9a5SSteve French
126038c8a9a5SSteve French if (length < 0) {
126138c8a9a5SSteve French for (i = 0; i < num_mids; i++)
126238c8a9a5SSteve French if (mids[i])
126338c8a9a5SSteve French release_mid(mids[i]);
126438c8a9a5SSteve French continue;
126538c8a9a5SSteve French }
126638c8a9a5SSteve French
126738c8a9a5SSteve French if (server->ops->is_status_io_timeout &&
126838c8a9a5SSteve French server->ops->is_status_io_timeout(buf)) {
126938c8a9a5SSteve French num_io_timeout++;
127069cba9d3SShyam Prasad N if (num_io_timeout > MAX_STATUS_IO_TIMEOUT) {
127169cba9d3SShyam Prasad N cifs_server_dbg(VFS,
127269cba9d3SShyam Prasad N "Number of request timeouts exceeded %d. Reconnecting",
127369cba9d3SShyam Prasad N MAX_STATUS_IO_TIMEOUT);
127469cba9d3SShyam Prasad N
127569cba9d3SShyam Prasad N pending_reconnect = true;
127638c8a9a5SSteve French num_io_timeout = 0;
127738c8a9a5SSteve French }
127838c8a9a5SSteve French }
127938c8a9a5SSteve French
128038c8a9a5SSteve French server->lstrp = jiffies;
128138c8a9a5SSteve French
128238c8a9a5SSteve French for (i = 0; i < num_mids; i++) {
128338c8a9a5SSteve French if (mids[i] != NULL) {
128438c8a9a5SSteve French mids[i]->resp_buf_size = server->pdu_size;
128538c8a9a5SSteve French
1286c071b34fSShyam Prasad N if (bufs[i] != NULL) {
1287c071b34fSShyam Prasad N if (server->ops->is_network_name_deleted &&
128838c8a9a5SSteve French server->ops->is_network_name_deleted(bufs[i],
1289c071b34fSShyam Prasad N server)) {
1290c071b34fSShyam Prasad N cifs_server_dbg(FYI,
1291c071b34fSShyam Prasad N "Share deleted. Reconnect needed");
1292c071b34fSShyam Prasad N }
1293c071b34fSShyam Prasad N }
129438c8a9a5SSteve French
129538c8a9a5SSteve French if (!mids[i]->multiRsp || mids[i]->multiEnd)
129638c8a9a5SSteve French mids[i]->callback(mids[i]);
129738c8a9a5SSteve French
129838c8a9a5SSteve French release_mid(mids[i]);
129938c8a9a5SSteve French } else if (server->ops->is_oplock_break &&
130038c8a9a5SSteve French server->ops->is_oplock_break(bufs[i],
130138c8a9a5SSteve French server)) {
130238c8a9a5SSteve French smb2_add_credits_from_hdr(bufs[i], server);
130338c8a9a5SSteve French cifs_dbg(FYI, "Received oplock break\n");
130438c8a9a5SSteve French } else {
130538c8a9a5SSteve French cifs_server_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
130638c8a9a5SSteve French atomic_read(&mid_count));
130738c8a9a5SSteve French cifs_dump_mem("Received Data is: ", bufs[i],
130838c8a9a5SSteve French HEADER_SIZE(server));
130938c8a9a5SSteve French smb2_add_credits_from_hdr(bufs[i], server);
131038c8a9a5SSteve French #ifdef CONFIG_CIFS_DEBUG2
131138c8a9a5SSteve French if (server->ops->dump_detail)
131238c8a9a5SSteve French server->ops->dump_detail(bufs[i],
131338c8a9a5SSteve French server);
131438c8a9a5SSteve French cifs_dump_mids(server);
131538c8a9a5SSteve French #endif /* CIFS_DEBUG2 */
131638c8a9a5SSteve French }
131738c8a9a5SSteve French }
131838c8a9a5SSteve French
131938c8a9a5SSteve French if (pdu_length > server->pdu_size) {
132038c8a9a5SSteve French if (!allocate_buffers(server))
132138c8a9a5SSteve French continue;
132238c8a9a5SSteve French pdu_length -= server->pdu_size;
132338c8a9a5SSteve French server->total_read = 0;
132438c8a9a5SSteve French server->large_buf = false;
132538c8a9a5SSteve French buf = server->smallbuf;
132638c8a9a5SSteve French goto next_pdu;
132738c8a9a5SSteve French }
132869cba9d3SShyam Prasad N
132969cba9d3SShyam Prasad N /* do this reconnect at the very end after processing all MIDs */
133069cba9d3SShyam Prasad N if (pending_reconnect)
133169cba9d3SShyam Prasad N cifs_reconnect(server, true);
133269cba9d3SShyam Prasad N
133338c8a9a5SSteve French } /* end while !EXITING */
133438c8a9a5SSteve French
133538c8a9a5SSteve French /* buffer usually freed in free_mid - need to free it here on exit */
133638c8a9a5SSteve French cifs_buf_release(server->bigbuf);
133738c8a9a5SSteve French if (server->smallbuf) /* no sense logging a debug message if NULL */
133838c8a9a5SSteve French cifs_small_buf_release(server->smallbuf);
133938c8a9a5SSteve French
134038c8a9a5SSteve French task_to_wake = xchg(&server->tsk, NULL);
134138c8a9a5SSteve French clean_demultiplex_info(server);
134238c8a9a5SSteve French
134338c8a9a5SSteve French /* if server->tsk was NULL then wait for a signal before exiting */
134438c8a9a5SSteve French if (!task_to_wake) {
134538c8a9a5SSteve French set_current_state(TASK_INTERRUPTIBLE);
134638c8a9a5SSteve French while (!signal_pending(current)) {
134738c8a9a5SSteve French schedule();
134838c8a9a5SSteve French set_current_state(TASK_INTERRUPTIBLE);
134938c8a9a5SSteve French }
135038c8a9a5SSteve French set_current_state(TASK_RUNNING);
135138c8a9a5SSteve French }
135238c8a9a5SSteve French
135338c8a9a5SSteve French memalloc_noreclaim_restore(noreclaim_flag);
135438c8a9a5SSteve French module_put_and_kthread_exit(0);
135538c8a9a5SSteve French }
135638c8a9a5SSteve French
13572991b774SShyam Prasad N int
cifs_ipaddr_cmp(struct sockaddr * srcaddr,struct sockaddr * rhs)13582991b774SShyam Prasad N cifs_ipaddr_cmp(struct sockaddr *srcaddr, struct sockaddr *rhs)
13592991b774SShyam Prasad N {
13602991b774SShyam Prasad N struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
13612991b774SShyam Prasad N struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
13622991b774SShyam Prasad N struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
13632991b774SShyam Prasad N struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
13642991b774SShyam Prasad N
13652991b774SShyam Prasad N switch (srcaddr->sa_family) {
13662991b774SShyam Prasad N case AF_UNSPEC:
13672991b774SShyam Prasad N switch (rhs->sa_family) {
13682991b774SShyam Prasad N case AF_UNSPEC:
13692991b774SShyam Prasad N return 0;
13702991b774SShyam Prasad N case AF_INET:
13712991b774SShyam Prasad N case AF_INET6:
13722991b774SShyam Prasad N return 1;
13732991b774SShyam Prasad N default:
13742991b774SShyam Prasad N return -1;
13752991b774SShyam Prasad N }
13762991b774SShyam Prasad N case AF_INET: {
13772991b774SShyam Prasad N switch (rhs->sa_family) {
13782991b774SShyam Prasad N case AF_UNSPEC:
13792991b774SShyam Prasad N return -1;
13802991b774SShyam Prasad N case AF_INET:
13812991b774SShyam Prasad N return memcmp(saddr4, vaddr4,
13822991b774SShyam Prasad N sizeof(struct sockaddr_in));
13832991b774SShyam Prasad N case AF_INET6:
13842991b774SShyam Prasad N return 1;
13852991b774SShyam Prasad N default:
13862991b774SShyam Prasad N return -1;
13872991b774SShyam Prasad N }
13882991b774SShyam Prasad N }
13892991b774SShyam Prasad N case AF_INET6: {
13902991b774SShyam Prasad N switch (rhs->sa_family) {
13912991b774SShyam Prasad N case AF_UNSPEC:
13922991b774SShyam Prasad N case AF_INET:
13932991b774SShyam Prasad N return -1;
13942991b774SShyam Prasad N case AF_INET6:
13952991b774SShyam Prasad N return memcmp(saddr6,
13962991b774SShyam Prasad N vaddr6,
13972991b774SShyam Prasad N sizeof(struct sockaddr_in6));
13982991b774SShyam Prasad N default:
13992991b774SShyam Prasad N return -1;
14002991b774SShyam Prasad N }
14012991b774SShyam Prasad N }
14022991b774SShyam Prasad N default:
14032991b774SShyam Prasad N return -1; /* don't expect to be here */
14042991b774SShyam Prasad N }
14052991b774SShyam Prasad N }
14062991b774SShyam Prasad N
140738c8a9a5SSteve French /*
140838c8a9a5SSteve French * Returns true if srcaddr isn't specified and rhs isn't specified, or
140938c8a9a5SSteve French * if srcaddr is specified and matches the IP address of the rhs argument
141038c8a9a5SSteve French */
141138c8a9a5SSteve French bool
cifs_match_ipaddr(struct sockaddr * srcaddr,struct sockaddr * rhs)141238c8a9a5SSteve French cifs_match_ipaddr(struct sockaddr *srcaddr, struct sockaddr *rhs)
141338c8a9a5SSteve French {
141438c8a9a5SSteve French switch (srcaddr->sa_family) {
141538c8a9a5SSteve French case AF_UNSPEC:
141638c8a9a5SSteve French return (rhs->sa_family == AF_UNSPEC);
141738c8a9a5SSteve French case AF_INET: {
141838c8a9a5SSteve French struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
141938c8a9a5SSteve French struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1420da70c1d3SPierre Mariani
142138c8a9a5SSteve French return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
142238c8a9a5SSteve French }
142338c8a9a5SSteve French case AF_INET6: {
142438c8a9a5SSteve French struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
142538c8a9a5SSteve French struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1426da70c1d3SPierre Mariani
142738c8a9a5SSteve French return (ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr)
142838c8a9a5SSteve French && saddr6->sin6_scope_id == vaddr6->sin6_scope_id);
142938c8a9a5SSteve French }
143038c8a9a5SSteve French default:
143138c8a9a5SSteve French WARN_ON(1);
143238c8a9a5SSteve French return false; /* don't expect to be here */
143338c8a9a5SSteve French }
143438c8a9a5SSteve French }
143538c8a9a5SSteve French
143638c8a9a5SSteve French /*
143738c8a9a5SSteve French * If no port is specified in addr structure, we try to match with 445 port
143838c8a9a5SSteve French * and if it fails - with 139 ports. It should be called only if address
143938c8a9a5SSteve French * families of server and addr are equal.
144038c8a9a5SSteve French */
144138c8a9a5SSteve French static bool
match_port(struct TCP_Server_Info * server,struct sockaddr * addr)144238c8a9a5SSteve French match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
144338c8a9a5SSteve French {
144438c8a9a5SSteve French __be16 port, *sport;
144538c8a9a5SSteve French
144638c8a9a5SSteve French /* SMBDirect manages its own ports, don't match it here */
144738c8a9a5SSteve French if (server->rdma)
144838c8a9a5SSteve French return true;
144938c8a9a5SSteve French
145038c8a9a5SSteve French switch (addr->sa_family) {
145138c8a9a5SSteve French case AF_INET:
145238c8a9a5SSteve French sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
145338c8a9a5SSteve French port = ((struct sockaddr_in *) addr)->sin_port;
145438c8a9a5SSteve French break;
145538c8a9a5SSteve French case AF_INET6:
145638c8a9a5SSteve French sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
145738c8a9a5SSteve French port = ((struct sockaddr_in6 *) addr)->sin6_port;
145838c8a9a5SSteve French break;
145938c8a9a5SSteve French default:
146038c8a9a5SSteve French WARN_ON(1);
146138c8a9a5SSteve French return false;
146238c8a9a5SSteve French }
146338c8a9a5SSteve French
146438c8a9a5SSteve French if (!port) {
146538c8a9a5SSteve French port = htons(CIFS_PORT);
146638c8a9a5SSteve French if (port == *sport)
146738c8a9a5SSteve French return true;
146838c8a9a5SSteve French
146938c8a9a5SSteve French port = htons(RFC1001_PORT);
147038c8a9a5SSteve French }
147138c8a9a5SSteve French
147238c8a9a5SSteve French return port == *sport;
147338c8a9a5SSteve French }
147438c8a9a5SSteve French
match_server_address(struct TCP_Server_Info * server,struct sockaddr * addr)147538c8a9a5SSteve French static bool match_server_address(struct TCP_Server_Info *server, struct sockaddr *addr)
147638c8a9a5SSteve French {
147738c8a9a5SSteve French if (!cifs_match_ipaddr(addr, (struct sockaddr *)&server->dstaddr))
147838c8a9a5SSteve French return false;
147938c8a9a5SSteve French
148038c8a9a5SSteve French return true;
148138c8a9a5SSteve French }
148238c8a9a5SSteve French
148338c8a9a5SSteve French static bool
match_security(struct TCP_Server_Info * server,struct smb3_fs_context * ctx)148438c8a9a5SSteve French match_security(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
148538c8a9a5SSteve French {
148638c8a9a5SSteve French /*
148738c8a9a5SSteve French * The select_sectype function should either return the ctx->sectype
148838c8a9a5SSteve French * that was specified, or "Unspecified" if that sectype was not
148938c8a9a5SSteve French * compatible with the given NEGOTIATE request.
149038c8a9a5SSteve French */
149138c8a9a5SSteve French if (server->ops->select_sectype(server, ctx->sectype)
149238c8a9a5SSteve French == Unspecified)
149338c8a9a5SSteve French return false;
149438c8a9a5SSteve French
149538c8a9a5SSteve French /*
149638c8a9a5SSteve French * Now check if signing mode is acceptable. No need to check
149738c8a9a5SSteve French * global_secflags at this point since if MUST_SIGN is set then
149838c8a9a5SSteve French * the server->sign had better be too.
149938c8a9a5SSteve French */
150038c8a9a5SSteve French if (ctx->sign && !server->sign)
150138c8a9a5SSteve French return false;
150238c8a9a5SSteve French
150338c8a9a5SSteve French return true;
150438c8a9a5SSteve French }
150538c8a9a5SSteve French
150638c8a9a5SSteve French /* this function must be called with srv_lock held */
match_server(struct TCP_Server_Info * server,struct smb3_fs_context * ctx,bool match_super)15073ae872deSPaulo Alcantara static int match_server(struct TCP_Server_Info *server,
15083ae872deSPaulo Alcantara struct smb3_fs_context *ctx,
15093ae872deSPaulo Alcantara bool match_super)
151038c8a9a5SSteve French {
151138c8a9a5SSteve French struct sockaddr *addr = (struct sockaddr *)&ctx->dstaddr;
151238c8a9a5SSteve French
151338c8a9a5SSteve French lockdep_assert_held(&server->srv_lock);
151438c8a9a5SSteve French
151538c8a9a5SSteve French if (ctx->nosharesock)
151638c8a9a5SSteve French return 0;
151738c8a9a5SSteve French
151838c8a9a5SSteve French /* this server does not share socket */
151938c8a9a5SSteve French if (server->nosharesock)
152038c8a9a5SSteve French return 0;
152138c8a9a5SSteve French
152238c8a9a5SSteve French /* If multidialect negotiation see if existing sessions match one */
152338c8a9a5SSteve French if (strcmp(ctx->vals->version_string, SMB3ANY_VERSION_STRING) == 0) {
152438c8a9a5SSteve French if (server->vals->protocol_id < SMB30_PROT_ID)
152538c8a9a5SSteve French return 0;
152638c8a9a5SSteve French } else if (strcmp(ctx->vals->version_string,
152738c8a9a5SSteve French SMBDEFAULT_VERSION_STRING) == 0) {
152838c8a9a5SSteve French if (server->vals->protocol_id < SMB21_PROT_ID)
152938c8a9a5SSteve French return 0;
153038c8a9a5SSteve French } else if ((server->vals != ctx->vals) || (server->ops != ctx->ops))
153138c8a9a5SSteve French return 0;
153238c8a9a5SSteve French
153338c8a9a5SSteve French if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
153438c8a9a5SSteve French return 0;
153538c8a9a5SSteve French
153638c8a9a5SSteve French if (!cifs_match_ipaddr((struct sockaddr *)&ctx->srcaddr,
153738c8a9a5SSteve French (struct sockaddr *)&server->srcaddr))
153838c8a9a5SSteve French return 0;
153938c8a9a5SSteve French /*
15403ae872deSPaulo Alcantara * When matching cifs.ko superblocks (@match_super == true), we can't
15413ae872deSPaulo Alcantara * really match either @server->leaf_fullpath or @server->dstaddr
15423ae872deSPaulo Alcantara * directly since this @server might belong to a completely different
15433ae872deSPaulo Alcantara * server -- in case of domain-based DFS referrals or DFS links -- as
15443ae872deSPaulo Alcantara * provided earlier by mount(2) through 'source' and 'ip' options.
15453ae872deSPaulo Alcantara *
15463ae872deSPaulo Alcantara * Otherwise, match the DFS referral in @server->leaf_fullpath or the
15473ae872deSPaulo Alcantara * destination address in @server->dstaddr.
15483ae872deSPaulo Alcantara *
15493ae872deSPaulo Alcantara * When using 'nodfs' mount option, we avoid sharing it with DFS
15503ae872deSPaulo Alcantara * connections as they might failover.
155138c8a9a5SSteve French */
15523ae872deSPaulo Alcantara if (!match_super) {
155338c8a9a5SSteve French if (!ctx->nodfs) {
15543ae872deSPaulo Alcantara if (server->leaf_fullpath) {
155538c8a9a5SSteve French if (!ctx->leaf_fullpath ||
155638c8a9a5SSteve French strcasecmp(server->leaf_fullpath,
155738c8a9a5SSteve French ctx->leaf_fullpath))
155838c8a9a5SSteve French return 0;
155938c8a9a5SSteve French } else if (ctx->leaf_fullpath) {
156038c8a9a5SSteve French return 0;
156138c8a9a5SSteve French }
15623ae872deSPaulo Alcantara } else if (server->leaf_fullpath) {
156338c8a9a5SSteve French return 0;
156438c8a9a5SSteve French }
15653ae872deSPaulo Alcantara }
156638c8a9a5SSteve French
156738c8a9a5SSteve French /*
156838c8a9a5SSteve French * Match for a regular connection (address/hostname/port) which has no
156938c8a9a5SSteve French * DFS referrals set.
157038c8a9a5SSteve French */
15713ae872deSPaulo Alcantara if (!server->leaf_fullpath &&
157238c8a9a5SSteve French (strcasecmp(server->hostname, ctx->server_hostname) ||
157338c8a9a5SSteve French !match_server_address(server, addr) ||
157438c8a9a5SSteve French !match_port(server, addr)))
157538c8a9a5SSteve French return 0;
157638c8a9a5SSteve French
157738c8a9a5SSteve French if (!match_security(server, ctx))
157838c8a9a5SSteve French return 0;
157938c8a9a5SSteve French
158038c8a9a5SSteve French if (server->echo_interval != ctx->echo_interval * HZ)
158138c8a9a5SSteve French return 0;
158238c8a9a5SSteve French
158338c8a9a5SSteve French if (server->rdma != ctx->rdma)
158438c8a9a5SSteve French return 0;
158538c8a9a5SSteve French
158638c8a9a5SSteve French if (server->ignore_signature != ctx->ignore_signature)
158738c8a9a5SSteve French return 0;
158838c8a9a5SSteve French
158938c8a9a5SSteve French if (server->min_offload != ctx->min_offload)
159038c8a9a5SSteve French return 0;
159138c8a9a5SSteve French
1592b4ca2942SShyam Prasad N if (server->retrans != ctx->retrans)
1593b4ca2942SShyam Prasad N return 0;
1594b4ca2942SShyam Prasad N
159538c8a9a5SSteve French return 1;
159638c8a9a5SSteve French }
159738c8a9a5SSteve French
159838c8a9a5SSteve French struct TCP_Server_Info *
cifs_find_tcp_session(struct smb3_fs_context * ctx)159938c8a9a5SSteve French cifs_find_tcp_session(struct smb3_fs_context *ctx)
160038c8a9a5SSteve French {
160138c8a9a5SSteve French struct TCP_Server_Info *server;
160238c8a9a5SSteve French
160338c8a9a5SSteve French spin_lock(&cifs_tcp_ses_lock);
160438c8a9a5SSteve French list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
160538c8a9a5SSteve French spin_lock(&server->srv_lock);
160638c8a9a5SSteve French /*
160738c8a9a5SSteve French * Skip ses channels since they're only handled in lower layers
160838c8a9a5SSteve French * (e.g. cifs_send_recv).
160938c8a9a5SSteve French */
1610b3773b19SSteve French if (SERVER_IS_CHAN(server) ||
16113ae872deSPaulo Alcantara !match_server(server, ctx, false)) {
161238c8a9a5SSteve French spin_unlock(&server->srv_lock);
161338c8a9a5SSteve French continue;
161438c8a9a5SSteve French }
161538c8a9a5SSteve French spin_unlock(&server->srv_lock);
161638c8a9a5SSteve French
161738c8a9a5SSteve French ++server->srv_count;
161838c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
161938c8a9a5SSteve French cifs_dbg(FYI, "Existing tcp session with server found\n");
162038c8a9a5SSteve French return server;
162138c8a9a5SSteve French }
162238c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
162338c8a9a5SSteve French return NULL;
162438c8a9a5SSteve French }
162538c8a9a5SSteve French
162638c8a9a5SSteve French void
cifs_put_tcp_session(struct TCP_Server_Info * server,int from_reconnect)162738c8a9a5SSteve French cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
162838c8a9a5SSteve French {
162938c8a9a5SSteve French struct task_struct *task;
163038c8a9a5SSteve French
163138c8a9a5SSteve French spin_lock(&cifs_tcp_ses_lock);
163238c8a9a5SSteve French if (--server->srv_count > 0) {
163338c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
163438c8a9a5SSteve French return;
163538c8a9a5SSteve French }
163638c8a9a5SSteve French
163738c8a9a5SSteve French /* srv_count can never go negative */
163838c8a9a5SSteve French WARN_ON(server->srv_count < 0);
163938c8a9a5SSteve French
164038c8a9a5SSteve French put_net(cifs_net_ns(server));
164138c8a9a5SSteve French
164238c8a9a5SSteve French list_del_init(&server->tcp_ses_list);
164338c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
164438c8a9a5SSteve French
164538c8a9a5SSteve French cancel_delayed_work_sync(&server->echo);
164638c8a9a5SSteve French
16473a0ef868SShyam Prasad N if (from_reconnect)
164838c8a9a5SSteve French /*
164938c8a9a5SSteve French * Avoid deadlock here: reconnect work calls
165038c8a9a5SSteve French * cifs_put_tcp_session() at its end. Need to be sure
165138c8a9a5SSteve French * that reconnect work does nothing with server pointer after
165238c8a9a5SSteve French * that step.
165338c8a9a5SSteve French */
16543a0ef868SShyam Prasad N cancel_delayed_work(&server->reconnect);
16553a0ef868SShyam Prasad N else
16563a0ef868SShyam Prasad N cancel_delayed_work_sync(&server->reconnect);
165738c8a9a5SSteve French
165807e86408SShyam Prasad N /* For secondary channels, we pick up ref-count on the primary server */
165907e86408SShyam Prasad N if (SERVER_IS_CHAN(server))
166007e86408SShyam Prasad N cifs_put_tcp_session(server->primary_server, from_reconnect);
166107e86408SShyam Prasad N
166238c8a9a5SSteve French spin_lock(&server->srv_lock);
166338c8a9a5SSteve French server->tcpStatus = CifsExiting;
166438c8a9a5SSteve French spin_unlock(&server->srv_lock);
166538c8a9a5SSteve French
166638c8a9a5SSteve French cifs_crypto_secmech_release(server);
166738c8a9a5SSteve French
166838c8a9a5SSteve French kfree_sensitive(server->session_key.response);
166938c8a9a5SSteve French server->session_key.response = NULL;
167038c8a9a5SSteve French server->session_key.len = 0;
167138c8a9a5SSteve French kfree(server->hostname);
167238c8a9a5SSteve French server->hostname = NULL;
167338c8a9a5SSteve French
167438c8a9a5SSteve French task = xchg(&server->tsk, NULL);
167538c8a9a5SSteve French if (task)
167638c8a9a5SSteve French send_sig(SIGKILL, task, 1);
167738c8a9a5SSteve French }
167838c8a9a5SSteve French
167938c8a9a5SSteve French struct TCP_Server_Info *
cifs_get_tcp_session(struct smb3_fs_context * ctx,struct TCP_Server_Info * primary_server)168038c8a9a5SSteve French cifs_get_tcp_session(struct smb3_fs_context *ctx,
168138c8a9a5SSteve French struct TCP_Server_Info *primary_server)
168238c8a9a5SSteve French {
168338c8a9a5SSteve French struct TCP_Server_Info *tcp_ses = NULL;
168438c8a9a5SSteve French int rc;
168538c8a9a5SSteve French
168638c8a9a5SSteve French cifs_dbg(FYI, "UNC: %s\n", ctx->UNC);
168738c8a9a5SSteve French
168838c8a9a5SSteve French /* see if we already have a matching tcp_ses */
168938c8a9a5SSteve French tcp_ses = cifs_find_tcp_session(ctx);
169038c8a9a5SSteve French if (tcp_ses)
169138c8a9a5SSteve French return tcp_ses;
169238c8a9a5SSteve French
169338c8a9a5SSteve French tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
169438c8a9a5SSteve French if (!tcp_ses) {
169538c8a9a5SSteve French rc = -ENOMEM;
169638c8a9a5SSteve French goto out_err;
169738c8a9a5SSteve French }
169838c8a9a5SSteve French
169938c8a9a5SSteve French tcp_ses->hostname = kstrdup(ctx->server_hostname, GFP_KERNEL);
170038c8a9a5SSteve French if (!tcp_ses->hostname) {
170138c8a9a5SSteve French rc = -ENOMEM;
170238c8a9a5SSteve French goto out_err;
170338c8a9a5SSteve French }
170438c8a9a5SSteve French
170538c8a9a5SSteve French if (ctx->leaf_fullpath) {
170638c8a9a5SSteve French tcp_ses->leaf_fullpath = kstrdup(ctx->leaf_fullpath, GFP_KERNEL);
170738c8a9a5SSteve French if (!tcp_ses->leaf_fullpath) {
170838c8a9a5SSteve French rc = -ENOMEM;
170938c8a9a5SSteve French goto out_err;
171038c8a9a5SSteve French }
171138c8a9a5SSteve French }
171238c8a9a5SSteve French
171338c8a9a5SSteve French if (ctx->nosharesock)
171438c8a9a5SSteve French tcp_ses->nosharesock = true;
171538c8a9a5SSteve French
171638c8a9a5SSteve French tcp_ses->ops = ctx->ops;
171738c8a9a5SSteve French tcp_ses->vals = ctx->vals;
171838c8a9a5SSteve French cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
171938c8a9a5SSteve French
172038c8a9a5SSteve French tcp_ses->conn_id = atomic_inc_return(&tcpSesNextId);
172138c8a9a5SSteve French tcp_ses->noblockcnt = ctx->rootfs;
172238c8a9a5SSteve French tcp_ses->noblocksnd = ctx->noblocksnd || ctx->rootfs;
172338c8a9a5SSteve French tcp_ses->noautotune = ctx->noautotune;
172438c8a9a5SSteve French tcp_ses->tcp_nodelay = ctx->sockopt_tcp_nodelay;
172538c8a9a5SSteve French tcp_ses->rdma = ctx->rdma;
172638c8a9a5SSteve French tcp_ses->in_flight = 0;
172738c8a9a5SSteve French tcp_ses->max_in_flight = 0;
172838c8a9a5SSteve French tcp_ses->credits = 1;
172938c8a9a5SSteve French if (primary_server) {
173038c8a9a5SSteve French spin_lock(&cifs_tcp_ses_lock);
173138c8a9a5SSteve French ++primary_server->srv_count;
173238c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
173338c8a9a5SSteve French tcp_ses->primary_server = primary_server;
173438c8a9a5SSteve French }
173538c8a9a5SSteve French init_waitqueue_head(&tcp_ses->response_q);
173638c8a9a5SSteve French init_waitqueue_head(&tcp_ses->request_q);
173738c8a9a5SSteve French INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
173838c8a9a5SSteve French mutex_init(&tcp_ses->_srv_mutex);
173938c8a9a5SSteve French memcpy(tcp_ses->workstation_RFC1001_name,
174038c8a9a5SSteve French ctx->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
174138c8a9a5SSteve French memcpy(tcp_ses->server_RFC1001_name,
174238c8a9a5SSteve French ctx->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
174338c8a9a5SSteve French tcp_ses->session_estab = false;
174438c8a9a5SSteve French tcp_ses->sequence_number = 0;
174509ee7a3bSSteve French tcp_ses->channel_sequence_num = 0; /* only tracked for primary channel */
174638c8a9a5SSteve French tcp_ses->reconnect_instance = 1;
174738c8a9a5SSteve French tcp_ses->lstrp = jiffies;
1748e8aee4f4SEnzo Matsumiya tcp_ses->compression.requested = ctx->compress;
174938c8a9a5SSteve French spin_lock_init(&tcp_ses->req_lock);
175038c8a9a5SSteve French spin_lock_init(&tcp_ses->srv_lock);
175138c8a9a5SSteve French spin_lock_init(&tcp_ses->mid_lock);
175238c8a9a5SSteve French INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
175338c8a9a5SSteve French INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
175438c8a9a5SSteve French INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
175538c8a9a5SSteve French INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
175638c8a9a5SSteve French mutex_init(&tcp_ses->reconnect_mutex);
175738c8a9a5SSteve French #ifdef CONFIG_CIFS_DFS_UPCALL
175838c8a9a5SSteve French mutex_init(&tcp_ses->refpath_lock);
175938c8a9a5SSteve French #endif
176038c8a9a5SSteve French memcpy(&tcp_ses->srcaddr, &ctx->srcaddr,
176138c8a9a5SSteve French sizeof(tcp_ses->srcaddr));
176238c8a9a5SSteve French memcpy(&tcp_ses->dstaddr, &ctx->dstaddr,
176338c8a9a5SSteve French sizeof(tcp_ses->dstaddr));
176438c8a9a5SSteve French if (ctx->use_client_guid)
176538c8a9a5SSteve French memcpy(tcp_ses->client_guid, ctx->client_guid,
176638c8a9a5SSteve French SMB2_CLIENT_GUID_SIZE);
176738c8a9a5SSteve French else
176838c8a9a5SSteve French generate_random_uuid(tcp_ses->client_guid);
176938c8a9a5SSteve French /*
177038c8a9a5SSteve French * at this point we are the only ones with the pointer
177138c8a9a5SSteve French * to the struct since the kernel thread not created yet
177238c8a9a5SSteve French * no need to spinlock this init of tcpStatus or srv_count
177338c8a9a5SSteve French */
177438c8a9a5SSteve French tcp_ses->tcpStatus = CifsNew;
177538c8a9a5SSteve French ++tcp_ses->srv_count;
177638c8a9a5SSteve French
177738c8a9a5SSteve French if (ctx->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
177838c8a9a5SSteve French ctx->echo_interval <= SMB_ECHO_INTERVAL_MAX)
177938c8a9a5SSteve French tcp_ses->echo_interval = ctx->echo_interval * HZ;
178038c8a9a5SSteve French else
178138c8a9a5SSteve French tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
178238c8a9a5SSteve French if (tcp_ses->rdma) {
178338c8a9a5SSteve French #ifndef CONFIG_CIFS_SMB_DIRECT
178438c8a9a5SSteve French cifs_dbg(VFS, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
178538c8a9a5SSteve French rc = -ENOENT;
178638c8a9a5SSteve French goto out_err_crypto_release;
178738c8a9a5SSteve French #endif
178838c8a9a5SSteve French tcp_ses->smbd_conn = smbd_get_connection(
178938c8a9a5SSteve French tcp_ses, (struct sockaddr *)&ctx->dstaddr);
179038c8a9a5SSteve French if (tcp_ses->smbd_conn) {
179138c8a9a5SSteve French cifs_dbg(VFS, "RDMA transport established\n");
179238c8a9a5SSteve French rc = 0;
179338c8a9a5SSteve French goto smbd_connected;
179438c8a9a5SSteve French } else {
179538c8a9a5SSteve French rc = -ENOENT;
179638c8a9a5SSteve French goto out_err_crypto_release;
179738c8a9a5SSteve French }
179838c8a9a5SSteve French }
179938c8a9a5SSteve French rc = ip_connect(tcp_ses);
180038c8a9a5SSteve French if (rc < 0) {
180138c8a9a5SSteve French cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
180238c8a9a5SSteve French goto out_err_crypto_release;
180338c8a9a5SSteve French }
180438c8a9a5SSteve French smbd_connected:
180538c8a9a5SSteve French /*
180638c8a9a5SSteve French * since we're in a cifs function already, we know that
180738c8a9a5SSteve French * this will succeed. No need for try_module_get().
180838c8a9a5SSteve French */
180938c8a9a5SSteve French __module_get(THIS_MODULE);
181038c8a9a5SSteve French tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
181138c8a9a5SSteve French tcp_ses, "cifsd");
181238c8a9a5SSteve French if (IS_ERR(tcp_ses->tsk)) {
181338c8a9a5SSteve French rc = PTR_ERR(tcp_ses->tsk);
181438c8a9a5SSteve French cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
181538c8a9a5SSteve French module_put(THIS_MODULE);
181638c8a9a5SSteve French goto out_err_crypto_release;
181738c8a9a5SSteve French }
181838c8a9a5SSteve French tcp_ses->min_offload = ctx->min_offload;
1819b4ca2942SShyam Prasad N tcp_ses->retrans = ctx->retrans;
182038c8a9a5SSteve French /*
182138c8a9a5SSteve French * at this point we are the only ones with the pointer
182238c8a9a5SSteve French * to the struct since the kernel thread not created yet
182338c8a9a5SSteve French * no need to spinlock this update of tcpStatus
182438c8a9a5SSteve French */
182538c8a9a5SSteve French spin_lock(&tcp_ses->srv_lock);
182638c8a9a5SSteve French tcp_ses->tcpStatus = CifsNeedNegotiate;
182738c8a9a5SSteve French spin_unlock(&tcp_ses->srv_lock);
182838c8a9a5SSteve French
182938c8a9a5SSteve French if ((ctx->max_credits < 20) || (ctx->max_credits > 60000))
183038c8a9a5SSteve French tcp_ses->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
183138c8a9a5SSteve French else
183238c8a9a5SSteve French tcp_ses->max_credits = ctx->max_credits;
183338c8a9a5SSteve French
183438c8a9a5SSteve French tcp_ses->nr_targets = 1;
183538c8a9a5SSteve French tcp_ses->ignore_signature = ctx->ignore_signature;
183638c8a9a5SSteve French /* thread spawned, put it on the list */
183738c8a9a5SSteve French spin_lock(&cifs_tcp_ses_lock);
183838c8a9a5SSteve French list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
183938c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
184038c8a9a5SSteve French
184138c8a9a5SSteve French /* queue echo request delayed work */
184238c8a9a5SSteve French queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
184338c8a9a5SSteve French
184438c8a9a5SSteve French return tcp_ses;
184538c8a9a5SSteve French
184638c8a9a5SSteve French out_err_crypto_release:
184738c8a9a5SSteve French cifs_crypto_secmech_release(tcp_ses);
184838c8a9a5SSteve French
184938c8a9a5SSteve French put_net(cifs_net_ns(tcp_ses));
185038c8a9a5SSteve French
185138c8a9a5SSteve French out_err:
185238c8a9a5SSteve French if (tcp_ses) {
1853b3773b19SSteve French if (SERVER_IS_CHAN(tcp_ses))
185438c8a9a5SSteve French cifs_put_tcp_session(tcp_ses->primary_server, false);
185538c8a9a5SSteve French kfree(tcp_ses->hostname);
185638c8a9a5SSteve French kfree(tcp_ses->leaf_fullpath);
185738c8a9a5SSteve French if (tcp_ses->ssocket)
185838c8a9a5SSteve French sock_release(tcp_ses->ssocket);
185938c8a9a5SSteve French kfree(tcp_ses);
186038c8a9a5SSteve French }
186138c8a9a5SSteve French return ERR_PTR(rc);
186238c8a9a5SSteve French }
186338c8a9a5SSteve French
186438c8a9a5SSteve French /* this function must be called with ses_lock and chan_lock held */
match_session(struct cifs_ses * ses,struct smb3_fs_context * ctx)186538c8a9a5SSteve French static int match_session(struct cifs_ses *ses, struct smb3_fs_context *ctx)
186638c8a9a5SSteve French {
186738c8a9a5SSteve French if (ctx->sectype != Unspecified &&
186838c8a9a5SSteve French ctx->sectype != ses->sectype)
186938c8a9a5SSteve French return 0;
187038c8a9a5SSteve French
1871645f332cSPaulo Alcantara if (ctx->dfs_root_ses != ses->dfs_root_ses)
1872645f332cSPaulo Alcantara return 0;
1873645f332cSPaulo Alcantara
187438c8a9a5SSteve French /*
187538c8a9a5SSteve French * If an existing session is limited to less channels than
187638c8a9a5SSteve French * requested, it should not be reused
187738c8a9a5SSteve French */
187838c8a9a5SSteve French if (ses->chan_max < ctx->max_channels)
187938c8a9a5SSteve French return 0;
188038c8a9a5SSteve French
188138c8a9a5SSteve French switch (ses->sectype) {
188238c8a9a5SSteve French case Kerberos:
188338c8a9a5SSteve French if (!uid_eq(ctx->cred_uid, ses->cred_uid))
188438c8a9a5SSteve French return 0;
188538c8a9a5SSteve French break;
188638c8a9a5SSteve French default:
188738c8a9a5SSteve French /* NULL username means anonymous session */
188838c8a9a5SSteve French if (ses->user_name == NULL) {
188938c8a9a5SSteve French if (!ctx->nullauth)
189038c8a9a5SSteve French return 0;
189138c8a9a5SSteve French break;
189238c8a9a5SSteve French }
189338c8a9a5SSteve French
189438c8a9a5SSteve French /* anything else takes username/password */
189538c8a9a5SSteve French if (strncmp(ses->user_name,
189638c8a9a5SSteve French ctx->username ? ctx->username : "",
189738c8a9a5SSteve French CIFS_MAX_USERNAME_LEN))
189838c8a9a5SSteve French return 0;
189938c8a9a5SSteve French if ((ctx->username && strlen(ctx->username) != 0) &&
190038c8a9a5SSteve French ses->password != NULL &&
190138c8a9a5SSteve French strncmp(ses->password,
190238c8a9a5SSteve French ctx->password ? ctx->password : "",
190338c8a9a5SSteve French CIFS_MAX_PASSWORD_LEN))
190438c8a9a5SSteve French return 0;
190538c8a9a5SSteve French }
1906a43f95fdSWinston Wen
1907a43f95fdSWinston Wen if (strcmp(ctx->local_nls->charset, ses->local_nls->charset))
1908a43f95fdSWinston Wen return 0;
1909a43f95fdSWinston Wen
191038c8a9a5SSteve French return 1;
191138c8a9a5SSteve French }
191238c8a9a5SSteve French
191338c8a9a5SSteve French /**
191438c8a9a5SSteve French * cifs_setup_ipc - helper to setup the IPC tcon for the session
191538c8a9a5SSteve French * @ses: smb session to issue the request on
191638c8a9a5SSteve French * @ctx: the superblock configuration context to use for building the
191738c8a9a5SSteve French * new tree connection for the IPC (interprocess communication RPC)
191838c8a9a5SSteve French *
191938c8a9a5SSteve French * A new IPC connection is made and stored in the session
192038c8a9a5SSteve French * tcon_ipc. The IPC tcon has the same lifetime as the session.
192138c8a9a5SSteve French */
192238c8a9a5SSteve French static int
cifs_setup_ipc(struct cifs_ses * ses,struct smb3_fs_context * ctx)192338c8a9a5SSteve French cifs_setup_ipc(struct cifs_ses *ses, struct smb3_fs_context *ctx)
192438c8a9a5SSteve French {
192538c8a9a5SSteve French int rc = 0, xid;
192638c8a9a5SSteve French struct cifs_tcon *tcon;
192738c8a9a5SSteve French char unc[SERVER_NAME_LENGTH + sizeof("//x/IPC$")] = {0};
192838c8a9a5SSteve French bool seal = false;
192938c8a9a5SSteve French struct TCP_Server_Info *server = ses->server;
193038c8a9a5SSteve French
193138c8a9a5SSteve French /*
193238c8a9a5SSteve French * If the mount request that resulted in the creation of the
193338c8a9a5SSteve French * session requires encryption, force IPC to be encrypted too.
193438c8a9a5SSteve French */
193538c8a9a5SSteve French if (ctx->seal) {
193638c8a9a5SSteve French if (server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)
193738c8a9a5SSteve French seal = true;
193838c8a9a5SSteve French else {
193938c8a9a5SSteve French cifs_server_dbg(VFS,
194038c8a9a5SSteve French "IPC: server doesn't support encryption\n");
194138c8a9a5SSteve French return -EOPNOTSUPP;
194238c8a9a5SSteve French }
194338c8a9a5SSteve French }
194438c8a9a5SSteve French
19452da338ffSSteve French /* no need to setup directory caching on IPC share, so pass in false */
194607e76ea1SDavid Howells tcon = tcon_info_alloc(false, netfs_trace_tcon_ref_new_ipc);
194738c8a9a5SSteve French if (tcon == NULL)
194838c8a9a5SSteve French return -ENOMEM;
194938c8a9a5SSteve French
195038c8a9a5SSteve French spin_lock(&server->srv_lock);
195138c8a9a5SSteve French scnprintf(unc, sizeof(unc), "\\\\%s\\IPC$", server->hostname);
195238c8a9a5SSteve French spin_unlock(&server->srv_lock);
195338c8a9a5SSteve French
195438c8a9a5SSteve French xid = get_xid();
195538c8a9a5SSteve French tcon->ses = ses;
195638c8a9a5SSteve French tcon->ipc = true;
195738c8a9a5SSteve French tcon->seal = seal;
195838c8a9a5SSteve French rc = server->ops->tree_connect(xid, ses, unc, tcon, ctx->local_nls);
195938c8a9a5SSteve French free_xid(xid);
196038c8a9a5SSteve French
196138c8a9a5SSteve French if (rc) {
196238c8a9a5SSteve French cifs_server_dbg(VFS, "failed to connect to IPC (rc=%d)\n", rc);
196307e76ea1SDavid Howells tconInfoFree(tcon, netfs_trace_tcon_ref_free_ipc_fail);
196438c8a9a5SSteve French goto out;
196538c8a9a5SSteve French }
196638c8a9a5SSteve French
196738c8a9a5SSteve French cifs_dbg(FYI, "IPC tcon rc=%d ipc tid=0x%x\n", rc, tcon->tid);
196838c8a9a5SSteve French
196938c8a9a5SSteve French spin_lock(&tcon->tc_lock);
197038c8a9a5SSteve French tcon->status = TID_GOOD;
197138c8a9a5SSteve French spin_unlock(&tcon->tc_lock);
197238c8a9a5SSteve French ses->tcon_ipc = tcon;
197338c8a9a5SSteve French out:
197438c8a9a5SSteve French return rc;
197538c8a9a5SSteve French }
197638c8a9a5SSteve French
197738c8a9a5SSteve French static struct cifs_ses *
cifs_find_smb_ses(struct TCP_Server_Info * server,struct smb3_fs_context * ctx)197838c8a9a5SSteve French cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
197938c8a9a5SSteve French {
198038c8a9a5SSteve French struct cifs_ses *ses, *ret = NULL;
198138c8a9a5SSteve French
198238c8a9a5SSteve French spin_lock(&cifs_tcp_ses_lock);
198338c8a9a5SSteve French list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
198438c8a9a5SSteve French spin_lock(&ses->ses_lock);
198538c8a9a5SSteve French if (ses->ses_status == SES_EXITING) {
198638c8a9a5SSteve French spin_unlock(&ses->ses_lock);
198738c8a9a5SSteve French continue;
198838c8a9a5SSteve French }
198938c8a9a5SSteve French spin_lock(&ses->chan_lock);
199038c8a9a5SSteve French if (match_session(ses, ctx)) {
199138c8a9a5SSteve French spin_unlock(&ses->chan_lock);
199238c8a9a5SSteve French spin_unlock(&ses->ses_lock);
199338c8a9a5SSteve French ret = ses;
199438c8a9a5SSteve French break;
199538c8a9a5SSteve French }
199638c8a9a5SSteve French spin_unlock(&ses->chan_lock);
199738c8a9a5SSteve French spin_unlock(&ses->ses_lock);
199838c8a9a5SSteve French }
199938c8a9a5SSteve French if (ret)
200038c8a9a5SSteve French cifs_smb_ses_inc_refcount(ret);
200138c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
200238c8a9a5SSteve French return ret;
200338c8a9a5SSteve French }
200438c8a9a5SSteve French
__cifs_put_smb_ses(struct cifs_ses * ses)200538c8a9a5SSteve French void __cifs_put_smb_ses(struct cifs_ses *ses)
200638c8a9a5SSteve French {
200738c8a9a5SSteve French struct TCP_Server_Info *server = ses->server;
20086202996aSPaulo Alcantara struct cifs_tcon *tcon;
2009fe1bad73SPaulo Alcantara unsigned int xid;
2010fe1bad73SPaulo Alcantara size_t i;
20116202996aSPaulo Alcantara bool do_logoff;
2012fe1bad73SPaulo Alcantara int rc;
201338c8a9a5SSteve French
201438c8a9a5SSteve French spin_lock(&cifs_tcp_ses_lock);
20156202996aSPaulo Alcantara spin_lock(&ses->ses_lock);
20166202996aSPaulo Alcantara cifs_dbg(FYI, "%s: id=0x%llx ses_count=%d ses_status=%u ipc=%s\n",
20176202996aSPaulo Alcantara __func__, ses->Suid, ses->ses_count, ses->ses_status,
20186202996aSPaulo Alcantara ses->tcon_ipc ? ses->tcon_ipc->tree_name : "none");
20196202996aSPaulo Alcantara if (ses->ses_status == SES_EXITING || --ses->ses_count > 0) {
20206202996aSPaulo Alcantara spin_unlock(&ses->ses_lock);
202138c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
202238c8a9a5SSteve French return;
202338c8a9a5SSteve French }
202438c8a9a5SSteve French /* ses_count can never go negative */
202538c8a9a5SSteve French WARN_ON(ses->ses_count < 0);
202638c8a9a5SSteve French
20276202996aSPaulo Alcantara spin_lock(&ses->chan_lock);
20286202996aSPaulo Alcantara cifs_chan_clear_need_reconnect(ses, server);
20296202996aSPaulo Alcantara spin_unlock(&ses->chan_lock);
20306202996aSPaulo Alcantara
20316202996aSPaulo Alcantara do_logoff = ses->ses_status == SES_GOOD && server->ops->logoff;
20326202996aSPaulo Alcantara ses->ses_status = SES_EXITING;
20336202996aSPaulo Alcantara tcon = ses->tcon_ipc;
20346202996aSPaulo Alcantara ses->tcon_ipc = NULL;
203538c8a9a5SSteve French spin_unlock(&ses->ses_lock);
20366202996aSPaulo Alcantara spin_unlock(&cifs_tcp_ses_lock);
20376202996aSPaulo Alcantara
20386202996aSPaulo Alcantara /*
20396202996aSPaulo Alcantara * On session close, the IPC is closed and the server must release all
20406202996aSPaulo Alcantara * tcons of the session. No need to send a tree disconnect here.
20416202996aSPaulo Alcantara *
20426202996aSPaulo Alcantara * Besides, it will make the server to not close durable and resilient
20436202996aSPaulo Alcantara * files on session close, as specified in MS-SMB2 3.3.5.6 Receiving an
20446202996aSPaulo Alcantara * SMB2 LOGOFF Request.
20456202996aSPaulo Alcantara */
204607e76ea1SDavid Howells tconInfoFree(tcon, netfs_trace_tcon_ref_free_ipc);
20476202996aSPaulo Alcantara if (do_logoff) {
204838c8a9a5SSteve French xid = get_xid();
204938c8a9a5SSteve French rc = server->ops->logoff(xid, ses);
205038c8a9a5SSteve French if (rc)
205138c8a9a5SSteve French cifs_server_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
205238c8a9a5SSteve French __func__, rc);
205338c8a9a5SSteve French _free_xid(xid);
205438c8a9a5SSteve French }
205538c8a9a5SSteve French
205638c8a9a5SSteve French spin_lock(&cifs_tcp_ses_lock);
205738c8a9a5SSteve French list_del_init(&ses->smb_ses_list);
205838c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
205938c8a9a5SSteve French
206038c8a9a5SSteve French /* close any extra channels */
2061fe1bad73SPaulo Alcantara for (i = 1; i < ses->chan_count; i++) {
206238c8a9a5SSteve French if (ses->chans[i].iface) {
206338c8a9a5SSteve French kref_put(&ses->chans[i].iface->refcount, release_iface);
206438c8a9a5SSteve French ses->chans[i].iface = NULL;
206538c8a9a5SSteve French }
206638c8a9a5SSteve French cifs_put_tcp_session(ses->chans[i].server, 0);
206738c8a9a5SSteve French ses->chans[i].server = NULL;
206838c8a9a5SSteve French }
206938c8a9a5SSteve French
20704875ef3eSShyam Prasad N /* we now account for primary channel in iface->refcount */
20714875ef3eSShyam Prasad N if (ses->chans[0].iface) {
20724875ef3eSShyam Prasad N kref_put(&ses->chans[0].iface->refcount, release_iface);
20734875ef3eSShyam Prasad N ses->chans[0].server = NULL;
20744875ef3eSShyam Prasad N }
20754875ef3eSShyam Prasad N
207638c8a9a5SSteve French sesInfoFree(ses);
207738c8a9a5SSteve French cifs_put_tcp_session(server, 0);
207838c8a9a5SSteve French }
207938c8a9a5SSteve French
208038c8a9a5SSteve French #ifdef CONFIG_KEYS
208138c8a9a5SSteve French
208238c8a9a5SSteve French /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
208338c8a9a5SSteve French #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
208438c8a9a5SSteve French
208538c8a9a5SSteve French /* Populate username and pw fields from keyring if possible */
208638c8a9a5SSteve French static int
cifs_set_cifscreds(struct smb3_fs_context * ctx,struct cifs_ses * ses)208738c8a9a5SSteve French cifs_set_cifscreds(struct smb3_fs_context *ctx, struct cifs_ses *ses)
208838c8a9a5SSteve French {
208938c8a9a5SSteve French int rc = 0;
209038c8a9a5SSteve French int is_domain = 0;
209138c8a9a5SSteve French const char *delim, *payload;
209238c8a9a5SSteve French char *desc;
209338c8a9a5SSteve French ssize_t len;
209438c8a9a5SSteve French struct key *key;
209538c8a9a5SSteve French struct TCP_Server_Info *server = ses->server;
209638c8a9a5SSteve French struct sockaddr_in *sa;
209738c8a9a5SSteve French struct sockaddr_in6 *sa6;
209838c8a9a5SSteve French const struct user_key_payload *upayload;
209938c8a9a5SSteve French
210038c8a9a5SSteve French desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
210138c8a9a5SSteve French if (!desc)
210238c8a9a5SSteve French return -ENOMEM;
210338c8a9a5SSteve French
210438c8a9a5SSteve French /* try to find an address key first */
210538c8a9a5SSteve French switch (server->dstaddr.ss_family) {
210638c8a9a5SSteve French case AF_INET:
210738c8a9a5SSteve French sa = (struct sockaddr_in *)&server->dstaddr;
210838c8a9a5SSteve French sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
210938c8a9a5SSteve French break;
211038c8a9a5SSteve French case AF_INET6:
211138c8a9a5SSteve French sa6 = (struct sockaddr_in6 *)&server->dstaddr;
211238c8a9a5SSteve French sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
211338c8a9a5SSteve French break;
211438c8a9a5SSteve French default:
211538c8a9a5SSteve French cifs_dbg(FYI, "Bad ss_family (%hu)\n",
211638c8a9a5SSteve French server->dstaddr.ss_family);
211738c8a9a5SSteve French rc = -EINVAL;
211838c8a9a5SSteve French goto out_err;
211938c8a9a5SSteve French }
212038c8a9a5SSteve French
212138c8a9a5SSteve French cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
212238c8a9a5SSteve French key = request_key(&key_type_logon, desc, "");
212338c8a9a5SSteve French if (IS_ERR(key)) {
212438c8a9a5SSteve French if (!ses->domainName) {
212538c8a9a5SSteve French cifs_dbg(FYI, "domainName is NULL\n");
212638c8a9a5SSteve French rc = PTR_ERR(key);
212738c8a9a5SSteve French goto out_err;
212838c8a9a5SSteve French }
212938c8a9a5SSteve French
213038c8a9a5SSteve French /* didn't work, try to find a domain key */
213138c8a9a5SSteve French sprintf(desc, "cifs:d:%s", ses->domainName);
213238c8a9a5SSteve French cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
213338c8a9a5SSteve French key = request_key(&key_type_logon, desc, "");
213438c8a9a5SSteve French if (IS_ERR(key)) {
213538c8a9a5SSteve French rc = PTR_ERR(key);
213638c8a9a5SSteve French goto out_err;
213738c8a9a5SSteve French }
213838c8a9a5SSteve French is_domain = 1;
213938c8a9a5SSteve French }
214038c8a9a5SSteve French
214138c8a9a5SSteve French down_read(&key->sem);
214238c8a9a5SSteve French upayload = user_key_payload_locked(key);
214338c8a9a5SSteve French if (IS_ERR_OR_NULL(upayload)) {
214438c8a9a5SSteve French rc = upayload ? PTR_ERR(upayload) : -EINVAL;
214538c8a9a5SSteve French goto out_key_put;
214638c8a9a5SSteve French }
214738c8a9a5SSteve French
214838c8a9a5SSteve French /* find first : in payload */
214938c8a9a5SSteve French payload = upayload->data;
215038c8a9a5SSteve French delim = strnchr(payload, upayload->datalen, ':');
215138c8a9a5SSteve French cifs_dbg(FYI, "payload=%s\n", payload);
215238c8a9a5SSteve French if (!delim) {
215338c8a9a5SSteve French cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
215438c8a9a5SSteve French upayload->datalen);
215538c8a9a5SSteve French rc = -EINVAL;
215638c8a9a5SSteve French goto out_key_put;
215738c8a9a5SSteve French }
215838c8a9a5SSteve French
215938c8a9a5SSteve French len = delim - payload;
216038c8a9a5SSteve French if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
216138c8a9a5SSteve French cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
216238c8a9a5SSteve French len);
216338c8a9a5SSteve French rc = -EINVAL;
216438c8a9a5SSteve French goto out_key_put;
216538c8a9a5SSteve French }
216638c8a9a5SSteve French
216738c8a9a5SSteve French ctx->username = kstrndup(payload, len, GFP_KERNEL);
216838c8a9a5SSteve French if (!ctx->username) {
216938c8a9a5SSteve French cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
217038c8a9a5SSteve French len);
217138c8a9a5SSteve French rc = -ENOMEM;
217238c8a9a5SSteve French goto out_key_put;
217338c8a9a5SSteve French }
217438c8a9a5SSteve French cifs_dbg(FYI, "%s: username=%s\n", __func__, ctx->username);
217538c8a9a5SSteve French
217638c8a9a5SSteve French len = key->datalen - (len + 1);
217738c8a9a5SSteve French if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
217838c8a9a5SSteve French cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
217938c8a9a5SSteve French rc = -EINVAL;
218038c8a9a5SSteve French kfree(ctx->username);
218138c8a9a5SSteve French ctx->username = NULL;
218238c8a9a5SSteve French goto out_key_put;
218338c8a9a5SSteve French }
218438c8a9a5SSteve French
218538c8a9a5SSteve French ++delim;
218608bedfbcSSteve French /* BB consider adding support for password2 (Key Rotation) for multiuser in future */
218738c8a9a5SSteve French ctx->password = kstrndup(delim, len, GFP_KERNEL);
218838c8a9a5SSteve French if (!ctx->password) {
218938c8a9a5SSteve French cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
219038c8a9a5SSteve French len);
219138c8a9a5SSteve French rc = -ENOMEM;
219238c8a9a5SSteve French kfree(ctx->username);
219338c8a9a5SSteve French ctx->username = NULL;
219438c8a9a5SSteve French goto out_key_put;
219538c8a9a5SSteve French }
219638c8a9a5SSteve French
219738c8a9a5SSteve French /*
219838c8a9a5SSteve French * If we have a domain key then we must set the domainName in the
219938c8a9a5SSteve French * for the request.
220038c8a9a5SSteve French */
220138c8a9a5SSteve French if (is_domain && ses->domainName) {
220238c8a9a5SSteve French ctx->domainname = kstrdup(ses->domainName, GFP_KERNEL);
220338c8a9a5SSteve French if (!ctx->domainname) {
220438c8a9a5SSteve French cifs_dbg(FYI, "Unable to allocate %zd bytes for domain\n",
220538c8a9a5SSteve French len);
220638c8a9a5SSteve French rc = -ENOMEM;
220738c8a9a5SSteve French kfree(ctx->username);
220838c8a9a5SSteve French ctx->username = NULL;
220938c8a9a5SSteve French kfree_sensitive(ctx->password);
221008bedfbcSSteve French /* no need to free ctx->password2 since not allocated in this path */
221138c8a9a5SSteve French ctx->password = NULL;
221238c8a9a5SSteve French goto out_key_put;
221338c8a9a5SSteve French }
221438c8a9a5SSteve French }
221538c8a9a5SSteve French
221638c8a9a5SSteve French strscpy(ctx->workstation_name, ses->workstation_name, sizeof(ctx->workstation_name));
221738c8a9a5SSteve French
221838c8a9a5SSteve French out_key_put:
221938c8a9a5SSteve French up_read(&key->sem);
222038c8a9a5SSteve French key_put(key);
222138c8a9a5SSteve French out_err:
222238c8a9a5SSteve French kfree(desc);
222338c8a9a5SSteve French cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
222438c8a9a5SSteve French return rc;
222538c8a9a5SSteve French }
222638c8a9a5SSteve French #else /* ! CONFIG_KEYS */
222738c8a9a5SSteve French static inline int
cifs_set_cifscreds(struct smb3_fs_context * ctx,struct cifs_ses * ses)222838c8a9a5SSteve French cifs_set_cifscreds(struct smb3_fs_context *ctx __attribute__((unused)),
222938c8a9a5SSteve French struct cifs_ses *ses __attribute__((unused)))
223038c8a9a5SSteve French {
223138c8a9a5SSteve French return -ENOSYS;
223238c8a9a5SSteve French }
223338c8a9a5SSteve French #endif /* CONFIG_KEYS */
223438c8a9a5SSteve French
223538c8a9a5SSteve French /**
223638c8a9a5SSteve French * cifs_get_smb_ses - get a session matching @ctx data from @server
223738c8a9a5SSteve French * @server: server to setup the session to
223838c8a9a5SSteve French * @ctx: superblock configuration context to use to setup the session
223938c8a9a5SSteve French *
224038c8a9a5SSteve French * This function assumes it is being called from cifs_mount() where we
224138c8a9a5SSteve French * already got a server reference (server refcount +1). See
224238c8a9a5SSteve French * cifs_get_tcon() for refcount explanations.
224338c8a9a5SSteve French */
224438c8a9a5SSteve French struct cifs_ses *
cifs_get_smb_ses(struct TCP_Server_Info * server,struct smb3_fs_context * ctx)224538c8a9a5SSteve French cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb3_fs_context *ctx)
224638c8a9a5SSteve French {
224738c8a9a5SSteve French int rc = 0;
224838c8a9a5SSteve French unsigned int xid;
224938c8a9a5SSteve French struct cifs_ses *ses;
225038c8a9a5SSteve French struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
225138c8a9a5SSteve French struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
225238c8a9a5SSteve French
225338c8a9a5SSteve French xid = get_xid();
225438c8a9a5SSteve French
225538c8a9a5SSteve French ses = cifs_find_smb_ses(server, ctx);
225638c8a9a5SSteve French if (ses) {
225738c8a9a5SSteve French cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
225838c8a9a5SSteve French ses->ses_status);
225938c8a9a5SSteve French
226038c8a9a5SSteve French spin_lock(&ses->chan_lock);
226138c8a9a5SSteve French if (cifs_chan_needs_reconnect(ses, server)) {
226238c8a9a5SSteve French spin_unlock(&ses->chan_lock);
226338c8a9a5SSteve French cifs_dbg(FYI, "Session needs reconnect\n");
226438c8a9a5SSteve French
226538c8a9a5SSteve French mutex_lock(&ses->session_mutex);
226638c8a9a5SSteve French rc = cifs_negotiate_protocol(xid, ses, server);
226738c8a9a5SSteve French if (rc) {
226838c8a9a5SSteve French mutex_unlock(&ses->session_mutex);
226938c8a9a5SSteve French /* problem -- put our ses reference */
227038c8a9a5SSteve French cifs_put_smb_ses(ses);
227138c8a9a5SSteve French free_xid(xid);
227238c8a9a5SSteve French return ERR_PTR(rc);
227338c8a9a5SSteve French }
227438c8a9a5SSteve French
227538c8a9a5SSteve French rc = cifs_setup_session(xid, ses, server,
227638c8a9a5SSteve French ctx->local_nls);
227738c8a9a5SSteve French if (rc) {
227838c8a9a5SSteve French mutex_unlock(&ses->session_mutex);
227938c8a9a5SSteve French /* problem -- put our reference */
228038c8a9a5SSteve French cifs_put_smb_ses(ses);
228138c8a9a5SSteve French free_xid(xid);
228238c8a9a5SSteve French return ERR_PTR(rc);
228338c8a9a5SSteve French }
228438c8a9a5SSteve French mutex_unlock(&ses->session_mutex);
228538c8a9a5SSteve French
228638c8a9a5SSteve French spin_lock(&ses->chan_lock);
228738c8a9a5SSteve French }
228838c8a9a5SSteve French spin_unlock(&ses->chan_lock);
228938c8a9a5SSteve French
229038c8a9a5SSteve French /* existing SMB ses has a server reference already */
229138c8a9a5SSteve French cifs_put_tcp_session(server, 0);
229238c8a9a5SSteve French free_xid(xid);
229338c8a9a5SSteve French return ses;
229438c8a9a5SSteve French }
229538c8a9a5SSteve French
229638c8a9a5SSteve French rc = -ENOMEM;
229738c8a9a5SSteve French
229838c8a9a5SSteve French cifs_dbg(FYI, "Existing smb sess not found\n");
229938c8a9a5SSteve French ses = sesInfoAlloc();
230038c8a9a5SSteve French if (ses == NULL)
230138c8a9a5SSteve French goto get_ses_fail;
230238c8a9a5SSteve French
230338c8a9a5SSteve French /* new SMB session uses our server ref */
230438c8a9a5SSteve French ses->server = server;
230538c8a9a5SSteve French if (server->dstaddr.ss_family == AF_INET6)
230638c8a9a5SSteve French sprintf(ses->ip_addr, "%pI6", &addr6->sin6_addr);
230738c8a9a5SSteve French else
230838c8a9a5SSteve French sprintf(ses->ip_addr, "%pI4", &addr->sin_addr);
230938c8a9a5SSteve French
231038c8a9a5SSteve French if (ctx->username) {
231138c8a9a5SSteve French ses->user_name = kstrdup(ctx->username, GFP_KERNEL);
231238c8a9a5SSteve French if (!ses->user_name)
231338c8a9a5SSteve French goto get_ses_fail;
231438c8a9a5SSteve French }
231538c8a9a5SSteve French
231638c8a9a5SSteve French /* ctx->password freed at unmount */
231738c8a9a5SSteve French if (ctx->password) {
231838c8a9a5SSteve French ses->password = kstrdup(ctx->password, GFP_KERNEL);
231938c8a9a5SSteve French if (!ses->password)
232038c8a9a5SSteve French goto get_ses_fail;
232138c8a9a5SSteve French }
232208bedfbcSSteve French /* ctx->password freed at unmount */
232308bedfbcSSteve French if (ctx->password2) {
232408bedfbcSSteve French ses->password2 = kstrdup(ctx->password2, GFP_KERNEL);
232508bedfbcSSteve French if (!ses->password2)
232608bedfbcSSteve French goto get_ses_fail;
232708bedfbcSSteve French }
232838c8a9a5SSteve French if (ctx->domainname) {
232938c8a9a5SSteve French ses->domainName = kstrdup(ctx->domainname, GFP_KERNEL);
233038c8a9a5SSteve French if (!ses->domainName)
233138c8a9a5SSteve French goto get_ses_fail;
233238c8a9a5SSteve French }
233338c8a9a5SSteve French
233438c8a9a5SSteve French strscpy(ses->workstation_name, ctx->workstation_name, sizeof(ses->workstation_name));
233538c8a9a5SSteve French
233638c8a9a5SSteve French if (ctx->domainauto)
233738c8a9a5SSteve French ses->domainAuto = ctx->domainauto;
233838c8a9a5SSteve French ses->cred_uid = ctx->cred_uid;
233938c8a9a5SSteve French ses->linux_uid = ctx->linux_uid;
234038c8a9a5SSteve French
234138c8a9a5SSteve French ses->sectype = ctx->sectype;
234238c8a9a5SSteve French ses->sign = ctx->sign;
2343a43f95fdSWinston Wen ses->local_nls = load_nls(ctx->local_nls->charset);
234438c8a9a5SSteve French
234538c8a9a5SSteve French /* add server as first channel */
234638c8a9a5SSteve French spin_lock(&ses->chan_lock);
234738c8a9a5SSteve French ses->chans[0].server = server;
234838c8a9a5SSteve French ses->chan_count = 1;
234938c8a9a5SSteve French ses->chan_max = ctx->multichannel ? ctx->max_channels:1;
235038c8a9a5SSteve French ses->chans_need_reconnect = 1;
235138c8a9a5SSteve French spin_unlock(&ses->chan_lock);
235238c8a9a5SSteve French
235338c8a9a5SSteve French mutex_lock(&ses->session_mutex);
235438c8a9a5SSteve French rc = cifs_negotiate_protocol(xid, ses, server);
235538c8a9a5SSteve French if (!rc)
235638c8a9a5SSteve French rc = cifs_setup_session(xid, ses, server, ctx->local_nls);
235738c8a9a5SSteve French mutex_unlock(&ses->session_mutex);
235838c8a9a5SSteve French
235938c8a9a5SSteve French /* each channel uses a different signing key */
236038c8a9a5SSteve French spin_lock(&ses->chan_lock);
236138c8a9a5SSteve French memcpy(ses->chans[0].signkey, ses->smb3signingkey,
236238c8a9a5SSteve French sizeof(ses->smb3signingkey));
236338c8a9a5SSteve French spin_unlock(&ses->chan_lock);
236438c8a9a5SSteve French
236538c8a9a5SSteve French if (rc)
236638c8a9a5SSteve French goto get_ses_fail;
236738c8a9a5SSteve French
236838c8a9a5SSteve French /*
236938c8a9a5SSteve French * success, put it on the list and add it as first channel
237038c8a9a5SSteve French * note: the session becomes active soon after this. So you'll
237138c8a9a5SSteve French * need to lock before changing something in the session.
237238c8a9a5SSteve French */
237338c8a9a5SSteve French spin_lock(&cifs_tcp_ses_lock);
2374645f332cSPaulo Alcantara if (ctx->dfs_root_ses)
2375645f332cSPaulo Alcantara cifs_smb_ses_inc_refcount(ctx->dfs_root_ses);
237638c8a9a5SSteve French ses->dfs_root_ses = ctx->dfs_root_ses;
237738c8a9a5SSteve French list_add(&ses->smb_ses_list, &server->smb_ses_list);
237838c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
237938c8a9a5SSteve French
238038c8a9a5SSteve French cifs_setup_ipc(ses, ctx);
238138c8a9a5SSteve French
238238c8a9a5SSteve French free_xid(xid);
238338c8a9a5SSteve French
238438c8a9a5SSteve French return ses;
238538c8a9a5SSteve French
238638c8a9a5SSteve French get_ses_fail:
238738c8a9a5SSteve French sesInfoFree(ses);
238838c8a9a5SSteve French free_xid(xid);
238938c8a9a5SSteve French return ERR_PTR(rc);
239038c8a9a5SSteve French }
239138c8a9a5SSteve French
239238c8a9a5SSteve French /* this function must be called with tc_lock held */
match_tcon(struct cifs_tcon * tcon,struct smb3_fs_context * ctx)239338c8a9a5SSteve French static int match_tcon(struct cifs_tcon *tcon, struct smb3_fs_context *ctx)
239438c8a9a5SSteve French {
239538c8a9a5SSteve French struct TCP_Server_Info *server = tcon->ses->server;
239638c8a9a5SSteve French
239738c8a9a5SSteve French if (tcon->status == TID_EXITING)
239838c8a9a5SSteve French return 0;
23993ae872deSPaulo Alcantara
24003ae872deSPaulo Alcantara if (tcon->origin_fullpath) {
24013ae872deSPaulo Alcantara if (!ctx->source ||
24023ae872deSPaulo Alcantara !dfs_src_pathname_equal(ctx->source,
24033ae872deSPaulo Alcantara tcon->origin_fullpath))
240438c8a9a5SSteve French return 0;
24053ae872deSPaulo Alcantara } else if (!server->leaf_fullpath &&
24063ae872deSPaulo Alcantara strncmp(tcon->tree_name, ctx->UNC, MAX_TREE_SIZE)) {
24073ae872deSPaulo Alcantara return 0;
24083ae872deSPaulo Alcantara }
240938c8a9a5SSteve French if (tcon->seal != ctx->seal)
241038c8a9a5SSteve French return 0;
241138c8a9a5SSteve French if (tcon->snapshot_time != ctx->snapshot_time)
241238c8a9a5SSteve French return 0;
241338c8a9a5SSteve French if (tcon->handle_timeout != ctx->handle_timeout)
241438c8a9a5SSteve French return 0;
241538c8a9a5SSteve French if (tcon->no_lease != ctx->no_lease)
241638c8a9a5SSteve French return 0;
241738c8a9a5SSteve French if (tcon->nodelete != ctx->nodelete)
241838c8a9a5SSteve French return 0;
241938c8a9a5SSteve French return 1;
242038c8a9a5SSteve French }
242138c8a9a5SSteve French
242238c8a9a5SSteve French static struct cifs_tcon *
cifs_find_tcon(struct cifs_ses * ses,struct smb3_fs_context * ctx)242338c8a9a5SSteve French cifs_find_tcon(struct cifs_ses *ses, struct smb3_fs_context *ctx)
242438c8a9a5SSteve French {
242538c8a9a5SSteve French struct cifs_tcon *tcon;
242638c8a9a5SSteve French
242738c8a9a5SSteve French spin_lock(&cifs_tcp_ses_lock);
242838c8a9a5SSteve French list_for_each_entry(tcon, &ses->tcon_list, tcon_list) {
242938c8a9a5SSteve French spin_lock(&tcon->tc_lock);
243038c8a9a5SSteve French if (!match_tcon(tcon, ctx)) {
243138c8a9a5SSteve French spin_unlock(&tcon->tc_lock);
243238c8a9a5SSteve French continue;
243338c8a9a5SSteve French }
243438c8a9a5SSteve French ++tcon->tc_count;
243507e76ea1SDavid Howells trace_smb3_tcon_ref(tcon->debug_id, tcon->tc_count,
243607e76ea1SDavid Howells netfs_trace_tcon_ref_get_find);
243738c8a9a5SSteve French spin_unlock(&tcon->tc_lock);
243838c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
243938c8a9a5SSteve French return tcon;
244038c8a9a5SSteve French }
244138c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
244238c8a9a5SSteve French return NULL;
244338c8a9a5SSteve French }
244438c8a9a5SSteve French
244538c8a9a5SSteve French void
cifs_put_tcon(struct cifs_tcon * tcon,enum smb3_tcon_ref_trace trace)244607e76ea1SDavid Howells cifs_put_tcon(struct cifs_tcon *tcon, enum smb3_tcon_ref_trace trace)
244738c8a9a5SSteve French {
244838c8a9a5SSteve French unsigned int xid;
244938c8a9a5SSteve French struct cifs_ses *ses;
245038c8a9a5SSteve French
245138c8a9a5SSteve French /*
245238c8a9a5SSteve French * IPC tcon share the lifetime of their session and are
245338c8a9a5SSteve French * destroyed in the session put function
245438c8a9a5SSteve French */
245538c8a9a5SSteve French if (tcon == NULL || tcon->ipc)
245638c8a9a5SSteve French return;
245738c8a9a5SSteve French
245838c8a9a5SSteve French ses = tcon->ses;
245938c8a9a5SSteve French cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
246038c8a9a5SSteve French spin_lock(&cifs_tcp_ses_lock);
246138c8a9a5SSteve French spin_lock(&tcon->tc_lock);
246207e76ea1SDavid Howells trace_smb3_tcon_ref(tcon->debug_id, tcon->tc_count - 1, trace);
246338c8a9a5SSteve French if (--tcon->tc_count > 0) {
246438c8a9a5SSteve French spin_unlock(&tcon->tc_lock);
246538c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
246638c8a9a5SSteve French return;
246738c8a9a5SSteve French }
246838c8a9a5SSteve French
246938c8a9a5SSteve French /* tc_count can never go negative */
247038c8a9a5SSteve French WARN_ON(tcon->tc_count < 0);
247138c8a9a5SSteve French
247238c8a9a5SSteve French list_del_init(&tcon->tcon_list);
247338c8a9a5SSteve French tcon->status = TID_EXITING;
247438c8a9a5SSteve French spin_unlock(&tcon->tc_lock);
247538c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
247638c8a9a5SSteve French
247738c8a9a5SSteve French /* cancel polling of interfaces */
247838c8a9a5SSteve French cancel_delayed_work_sync(&tcon->query_interfaces);
247938c8a9a5SSteve French #ifdef CONFIG_CIFS_DFS_UPCALL
248038c8a9a5SSteve French cancel_delayed_work_sync(&tcon->dfs_cache_work);
248138c8a9a5SSteve French #endif
248238c8a9a5SSteve French
248338c8a9a5SSteve French if (tcon->use_witness) {
248438c8a9a5SSteve French int rc;
248538c8a9a5SSteve French
248638c8a9a5SSteve French rc = cifs_swn_unregister(tcon);
248738c8a9a5SSteve French if (rc < 0) {
248838c8a9a5SSteve French cifs_dbg(VFS, "%s: Failed to unregister for witness notifications: %d\n",
248938c8a9a5SSteve French __func__, rc);
249038c8a9a5SSteve French }
249138c8a9a5SSteve French }
249238c8a9a5SSteve French
249338c8a9a5SSteve French xid = get_xid();
249438c8a9a5SSteve French if (ses->server->ops->tree_disconnect)
249538c8a9a5SSteve French ses->server->ops->tree_disconnect(xid, tcon);
249638c8a9a5SSteve French _free_xid(xid);
249738c8a9a5SSteve French
249838c8a9a5SSteve French cifs_fscache_release_super_cookie(tcon);
249907e76ea1SDavid Howells tconInfoFree(tcon, netfs_trace_tcon_ref_free);
250038c8a9a5SSteve French cifs_put_smb_ses(ses);
250138c8a9a5SSteve French }
250238c8a9a5SSteve French
250338c8a9a5SSteve French /**
250438c8a9a5SSteve French * cifs_get_tcon - get a tcon matching @ctx data from @ses
250538c8a9a5SSteve French * @ses: smb session to issue the request on
250638c8a9a5SSteve French * @ctx: the superblock configuration context to use for building the
250738c8a9a5SSteve French *
250838c8a9a5SSteve French * - tcon refcount is the number of mount points using the tcon.
250938c8a9a5SSteve French * - ses refcount is the number of tcon using the session.
251038c8a9a5SSteve French *
251138c8a9a5SSteve French * 1. This function assumes it is being called from cifs_mount() where
251238c8a9a5SSteve French * we already got a session reference (ses refcount +1).
251338c8a9a5SSteve French *
251438c8a9a5SSteve French * 2. Since we're in the context of adding a mount point, the end
251538c8a9a5SSteve French * result should be either:
251638c8a9a5SSteve French *
251738c8a9a5SSteve French * a) a new tcon already allocated with refcount=1 (1 mount point) and
251838c8a9a5SSteve French * its session refcount incremented (1 new tcon). This +1 was
251938c8a9a5SSteve French * already done in (1).
252038c8a9a5SSteve French *
252138c8a9a5SSteve French * b) an existing tcon with refcount+1 (add a mount point to it) and
252238c8a9a5SSteve French * identical ses refcount (no new tcon). Because of (1) we need to
252338c8a9a5SSteve French * decrement the ses refcount.
252438c8a9a5SSteve French */
252538c8a9a5SSteve French static struct cifs_tcon *
cifs_get_tcon(struct cifs_ses * ses,struct smb3_fs_context * ctx)252638c8a9a5SSteve French cifs_get_tcon(struct cifs_ses *ses, struct smb3_fs_context *ctx)
252738c8a9a5SSteve French {
252838c8a9a5SSteve French struct cifs_tcon *tcon;
25293b8bb317SPaulo Alcantara bool nohandlecache;
25303b8bb317SPaulo Alcantara int rc, xid;
253138c8a9a5SSteve French
253238c8a9a5SSteve French tcon = cifs_find_tcon(ses, ctx);
253338c8a9a5SSteve French if (tcon) {
253438c8a9a5SSteve French /*
253538c8a9a5SSteve French * tcon has refcount already incremented but we need to
253638c8a9a5SSteve French * decrement extra ses reference gotten by caller (case b)
253738c8a9a5SSteve French */
253838c8a9a5SSteve French cifs_dbg(FYI, "Found match on UNC path\n");
253938c8a9a5SSteve French cifs_put_smb_ses(ses);
254038c8a9a5SSteve French return tcon;
254138c8a9a5SSteve French }
254238c8a9a5SSteve French
254338c8a9a5SSteve French if (!ses->server->ops->tree_connect) {
254438c8a9a5SSteve French rc = -ENOSYS;
254538c8a9a5SSteve French goto out_fail;
254638c8a9a5SSteve French }
254738c8a9a5SSteve French
25483b8bb317SPaulo Alcantara if (ses->server->dialect >= SMB20_PROT_ID &&
25493b8bb317SPaulo Alcantara (ses->server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING))
25503b8bb317SPaulo Alcantara nohandlecache = ctx->nohandlecache;
25512da338ffSSteve French else
25523b8bb317SPaulo Alcantara nohandlecache = true;
255307e76ea1SDavid Howells tcon = tcon_info_alloc(!nohandlecache, netfs_trace_tcon_ref_new);
255438c8a9a5SSteve French if (tcon == NULL) {
255538c8a9a5SSteve French rc = -ENOMEM;
255638c8a9a5SSteve French goto out_fail;
255738c8a9a5SSteve French }
25583b8bb317SPaulo Alcantara tcon->nohandlecache = nohandlecache;
255938c8a9a5SSteve French
256038c8a9a5SSteve French if (ctx->snapshot_time) {
256138c8a9a5SSteve French if (ses->server->vals->protocol_id == 0) {
256238c8a9a5SSteve French cifs_dbg(VFS,
256338c8a9a5SSteve French "Use SMB2 or later for snapshot mount option\n");
256438c8a9a5SSteve French rc = -EOPNOTSUPP;
256538c8a9a5SSteve French goto out_fail;
256638c8a9a5SSteve French } else
256738c8a9a5SSteve French tcon->snapshot_time = ctx->snapshot_time;
256838c8a9a5SSteve French }
256938c8a9a5SSteve French
257038c8a9a5SSteve French if (ctx->handle_timeout) {
257138c8a9a5SSteve French if (ses->server->vals->protocol_id == 0) {
257238c8a9a5SSteve French cifs_dbg(VFS,
257338c8a9a5SSteve French "Use SMB2.1 or later for handle timeout option\n");
257438c8a9a5SSteve French rc = -EOPNOTSUPP;
257538c8a9a5SSteve French goto out_fail;
257638c8a9a5SSteve French } else
257738c8a9a5SSteve French tcon->handle_timeout = ctx->handle_timeout;
257838c8a9a5SSteve French }
257938c8a9a5SSteve French
258038c8a9a5SSteve French tcon->ses = ses;
258138c8a9a5SSteve French if (ctx->password) {
258238c8a9a5SSteve French tcon->password = kstrdup(ctx->password, GFP_KERNEL);
258338c8a9a5SSteve French if (!tcon->password) {
258438c8a9a5SSteve French rc = -ENOMEM;
258538c8a9a5SSteve French goto out_fail;
258638c8a9a5SSteve French }
258738c8a9a5SSteve French }
258838c8a9a5SSteve French
258938c8a9a5SSteve French if (ctx->seal) {
259038c8a9a5SSteve French if (ses->server->vals->protocol_id == 0) {
259138c8a9a5SSteve French cifs_dbg(VFS,
259238c8a9a5SSteve French "SMB3 or later required for encryption\n");
259338c8a9a5SSteve French rc = -EOPNOTSUPP;
259438c8a9a5SSteve French goto out_fail;
259538c8a9a5SSteve French } else if (tcon->ses->server->capabilities &
259638c8a9a5SSteve French SMB2_GLOBAL_CAP_ENCRYPTION)
259738c8a9a5SSteve French tcon->seal = true;
259838c8a9a5SSteve French else {
259938c8a9a5SSteve French cifs_dbg(VFS, "Encryption is not supported on share\n");
260038c8a9a5SSteve French rc = -EOPNOTSUPP;
260138c8a9a5SSteve French goto out_fail;
260238c8a9a5SSteve French }
260338c8a9a5SSteve French }
260438c8a9a5SSteve French
260538c8a9a5SSteve French if (ctx->linux_ext) {
260638c8a9a5SSteve French if (ses->server->posix_ext_supported) {
260738c8a9a5SSteve French tcon->posix_extensions = true;
260838c8a9a5SSteve French pr_warn_once("SMB3.11 POSIX Extensions are experimental\n");
260938c8a9a5SSteve French } else if ((ses->server->vals->protocol_id == SMB311_PROT_ID) ||
261038c8a9a5SSteve French (strcmp(ses->server->vals->version_string,
261138c8a9a5SSteve French SMB3ANY_VERSION_STRING) == 0) ||
261238c8a9a5SSteve French (strcmp(ses->server->vals->version_string,
261338c8a9a5SSteve French SMBDEFAULT_VERSION_STRING) == 0)) {
261438c8a9a5SSteve French cifs_dbg(VFS, "Server does not support mounting with posix SMB3.11 extensions\n");
261538c8a9a5SSteve French rc = -EOPNOTSUPP;
261638c8a9a5SSteve French goto out_fail;
261738c8a9a5SSteve French } else {
2618da70c1d3SPierre Mariani cifs_dbg(VFS,
2619da70c1d3SPierre Mariani "Check vers= mount option. SMB3.11 disabled but required for POSIX extensions\n");
262038c8a9a5SSteve French rc = -EOPNOTSUPP;
262138c8a9a5SSteve French goto out_fail;
262238c8a9a5SSteve French }
262338c8a9a5SSteve French }
262438c8a9a5SSteve French
262538c8a9a5SSteve French xid = get_xid();
262638c8a9a5SSteve French rc = ses->server->ops->tree_connect(xid, ses, ctx->UNC, tcon,
262738c8a9a5SSteve French ctx->local_nls);
262838c8a9a5SSteve French free_xid(xid);
262938c8a9a5SSteve French cifs_dbg(FYI, "Tcon rc = %d\n", rc);
263038c8a9a5SSteve French if (rc)
263138c8a9a5SSteve French goto out_fail;
263238c8a9a5SSteve French
263338c8a9a5SSteve French tcon->use_persistent = false;
263438c8a9a5SSteve French /* check if SMB2 or later, CIFS does not support persistent handles */
263538c8a9a5SSteve French if (ctx->persistent) {
263638c8a9a5SSteve French if (ses->server->vals->protocol_id == 0) {
263738c8a9a5SSteve French cifs_dbg(VFS,
263838c8a9a5SSteve French "SMB3 or later required for persistent handles\n");
263938c8a9a5SSteve French rc = -EOPNOTSUPP;
264038c8a9a5SSteve French goto out_fail;
264138c8a9a5SSteve French } else if (ses->server->capabilities &
264238c8a9a5SSteve French SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
264338c8a9a5SSteve French tcon->use_persistent = true;
264438c8a9a5SSteve French else /* persistent handles requested but not supported */ {
264538c8a9a5SSteve French cifs_dbg(VFS,
264638c8a9a5SSteve French "Persistent handles not supported on share\n");
264738c8a9a5SSteve French rc = -EOPNOTSUPP;
264838c8a9a5SSteve French goto out_fail;
264938c8a9a5SSteve French }
265038c8a9a5SSteve French } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
265138c8a9a5SSteve French && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
265238c8a9a5SSteve French && (ctx->nopersistent == false)) {
265338c8a9a5SSteve French cifs_dbg(FYI, "enabling persistent handles\n");
265438c8a9a5SSteve French tcon->use_persistent = true;
265538c8a9a5SSteve French } else if (ctx->resilient) {
265638c8a9a5SSteve French if (ses->server->vals->protocol_id == 0) {
265738c8a9a5SSteve French cifs_dbg(VFS,
265838c8a9a5SSteve French "SMB2.1 or later required for resilient handles\n");
265938c8a9a5SSteve French rc = -EOPNOTSUPP;
266038c8a9a5SSteve French goto out_fail;
266138c8a9a5SSteve French }
266238c8a9a5SSteve French tcon->use_resilient = true;
266338c8a9a5SSteve French }
266438c8a9a5SSteve French
266538c8a9a5SSteve French tcon->use_witness = false;
266638c8a9a5SSteve French if (IS_ENABLED(CONFIG_CIFS_SWN_UPCALL) && ctx->witness) {
266738c8a9a5SSteve French if (ses->server->vals->protocol_id >= SMB30_PROT_ID) {
266838c8a9a5SSteve French if (tcon->capabilities & SMB2_SHARE_CAP_CLUSTER) {
266938c8a9a5SSteve French /*
267038c8a9a5SSteve French * Set witness in use flag in first place
267138c8a9a5SSteve French * to retry registration in the echo task
267238c8a9a5SSteve French */
267338c8a9a5SSteve French tcon->use_witness = true;
267438c8a9a5SSteve French /* And try to register immediately */
267538c8a9a5SSteve French rc = cifs_swn_register(tcon);
267638c8a9a5SSteve French if (rc < 0) {
267738c8a9a5SSteve French cifs_dbg(VFS, "Failed to register for witness notifications: %d\n", rc);
267838c8a9a5SSteve French goto out_fail;
267938c8a9a5SSteve French }
268038c8a9a5SSteve French } else {
268138c8a9a5SSteve French /* TODO: try to extend for non-cluster uses (eg multichannel) */
268238c8a9a5SSteve French cifs_dbg(VFS, "witness requested on mount but no CLUSTER capability on share\n");
268338c8a9a5SSteve French rc = -EOPNOTSUPP;
268438c8a9a5SSteve French goto out_fail;
268538c8a9a5SSteve French }
268638c8a9a5SSteve French } else {
268738c8a9a5SSteve French cifs_dbg(VFS, "SMB3 or later required for witness option\n");
268838c8a9a5SSteve French rc = -EOPNOTSUPP;
268938c8a9a5SSteve French goto out_fail;
269038c8a9a5SSteve French }
269138c8a9a5SSteve French }
269238c8a9a5SSteve French
269338c8a9a5SSteve French /* If the user really knows what they are doing they can override */
269438c8a9a5SSteve French if (tcon->share_flags & SMB2_SHAREFLAG_NO_CACHING) {
269538c8a9a5SSteve French if (ctx->cache_ro)
269638c8a9a5SSteve French cifs_dbg(VFS, "cache=ro requested on mount but NO_CACHING flag set on share\n");
269738c8a9a5SSteve French else if (ctx->cache_rw)
269838c8a9a5SSteve French cifs_dbg(VFS, "cache=singleclient requested on mount but NO_CACHING flag set on share\n");
269938c8a9a5SSteve French }
270038c8a9a5SSteve French
270138c8a9a5SSteve French if (ctx->no_lease) {
270238c8a9a5SSteve French if (ses->server->vals->protocol_id == 0) {
270338c8a9a5SSteve French cifs_dbg(VFS,
270438c8a9a5SSteve French "SMB2 or later required for nolease option\n");
270538c8a9a5SSteve French rc = -EOPNOTSUPP;
270638c8a9a5SSteve French goto out_fail;
270738c8a9a5SSteve French } else
270838c8a9a5SSteve French tcon->no_lease = ctx->no_lease;
270938c8a9a5SSteve French }
271038c8a9a5SSteve French
271138c8a9a5SSteve French /*
271238c8a9a5SSteve French * We can have only one retry value for a connection to a share so for
271338c8a9a5SSteve French * resources mounted more than once to the same server share the last
271438c8a9a5SSteve French * value passed in for the retry flag is used.
271538c8a9a5SSteve French */
271638c8a9a5SSteve French tcon->retry = ctx->retry;
271738c8a9a5SSteve French tcon->nocase = ctx->nocase;
271838c8a9a5SSteve French tcon->broken_sparse_sup = ctx->no_sparse;
27196a50d71dSSteve French tcon->max_cached_dirs = ctx->max_cached_dirs;
272038c8a9a5SSteve French tcon->nodelete = ctx->nodelete;
272138c8a9a5SSteve French tcon->local_lease = ctx->local_lease;
272238c8a9a5SSteve French INIT_LIST_HEAD(&tcon->pending_opens);
272338c8a9a5SSteve French tcon->status = TID_GOOD;
272438c8a9a5SSteve French
272538c8a9a5SSteve French INIT_DELAYED_WORK(&tcon->query_interfaces,
272638c8a9a5SSteve French smb2_query_server_interfaces);
272738c8a9a5SSteve French if (ses->server->dialect >= SMB30_PROT_ID &&
272838c8a9a5SSteve French (ses->server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL)) {
272938c8a9a5SSteve French /* schedule query interfaces poll */
273038c8a9a5SSteve French queue_delayed_work(cifsiod_wq, &tcon->query_interfaces,
273138c8a9a5SSteve French (SMB_INTERFACE_POLL_INTERVAL * HZ));
273238c8a9a5SSteve French }
273338c8a9a5SSteve French #ifdef CONFIG_CIFS_DFS_UPCALL
273438c8a9a5SSteve French INIT_DELAYED_WORK(&tcon->dfs_cache_work, dfs_cache_refresh);
273538c8a9a5SSteve French #endif
273638c8a9a5SSteve French spin_lock(&cifs_tcp_ses_lock);
273738c8a9a5SSteve French list_add(&tcon->tcon_list, &ses->tcon_list);
273838c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
273938c8a9a5SSteve French
274038c8a9a5SSteve French return tcon;
274138c8a9a5SSteve French
274238c8a9a5SSteve French out_fail:
274307e76ea1SDavid Howells tconInfoFree(tcon, netfs_trace_tcon_ref_free_fail);
274438c8a9a5SSteve French return ERR_PTR(rc);
274538c8a9a5SSteve French }
274638c8a9a5SSteve French
274738c8a9a5SSteve French void
cifs_put_tlink(struct tcon_link * tlink)274838c8a9a5SSteve French cifs_put_tlink(struct tcon_link *tlink)
274938c8a9a5SSteve French {
275038c8a9a5SSteve French if (!tlink || IS_ERR(tlink))
275138c8a9a5SSteve French return;
275238c8a9a5SSteve French
275338c8a9a5SSteve French if (!atomic_dec_and_test(&tlink->tl_count) ||
275438c8a9a5SSteve French test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
275538c8a9a5SSteve French tlink->tl_time = jiffies;
275638c8a9a5SSteve French return;
275738c8a9a5SSteve French }
275838c8a9a5SSteve French
275938c8a9a5SSteve French if (!IS_ERR(tlink_tcon(tlink)))
276007e76ea1SDavid Howells cifs_put_tcon(tlink_tcon(tlink), netfs_trace_tcon_ref_put_tlink);
276138c8a9a5SSteve French kfree(tlink);
276238c8a9a5SSteve French }
276338c8a9a5SSteve French
276438c8a9a5SSteve French static int
compare_mount_options(struct super_block * sb,struct cifs_mnt_data * mnt_data)276538c8a9a5SSteve French compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
276638c8a9a5SSteve French {
276738c8a9a5SSteve French struct cifs_sb_info *old = CIFS_SB(sb);
276838c8a9a5SSteve French struct cifs_sb_info *new = mnt_data->cifs_sb;
276938c8a9a5SSteve French unsigned int oldflags = old->mnt_cifs_flags & CIFS_MOUNT_MASK;
277038c8a9a5SSteve French unsigned int newflags = new->mnt_cifs_flags & CIFS_MOUNT_MASK;
277138c8a9a5SSteve French
277238c8a9a5SSteve French if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
277338c8a9a5SSteve French return 0;
277438c8a9a5SSteve French
277538c8a9a5SSteve French if (old->mnt_cifs_serverino_autodisabled)
277638c8a9a5SSteve French newflags &= ~CIFS_MOUNT_SERVER_INUM;
277738c8a9a5SSteve French
277838c8a9a5SSteve French if (oldflags != newflags)
277938c8a9a5SSteve French return 0;
278038c8a9a5SSteve French
278138c8a9a5SSteve French /*
278238c8a9a5SSteve French * We want to share sb only if we don't specify an r/wsize or
278338c8a9a5SSteve French * specified r/wsize is greater than or equal to existing one.
278438c8a9a5SSteve French */
278538c8a9a5SSteve French if (new->ctx->wsize && new->ctx->wsize < old->ctx->wsize)
278638c8a9a5SSteve French return 0;
278738c8a9a5SSteve French
278838c8a9a5SSteve French if (new->ctx->rsize && new->ctx->rsize < old->ctx->rsize)
278938c8a9a5SSteve French return 0;
279038c8a9a5SSteve French
279138c8a9a5SSteve French if (!uid_eq(old->ctx->linux_uid, new->ctx->linux_uid) ||
279238c8a9a5SSteve French !gid_eq(old->ctx->linux_gid, new->ctx->linux_gid))
279338c8a9a5SSteve French return 0;
279438c8a9a5SSteve French
279538c8a9a5SSteve French if (old->ctx->file_mode != new->ctx->file_mode ||
279638c8a9a5SSteve French old->ctx->dir_mode != new->ctx->dir_mode)
279738c8a9a5SSteve French return 0;
279838c8a9a5SSteve French
279938c8a9a5SSteve French if (strcmp(old->local_nls->charset, new->local_nls->charset))
280038c8a9a5SSteve French return 0;
280138c8a9a5SSteve French
280238c8a9a5SSteve French if (old->ctx->acregmax != new->ctx->acregmax)
280338c8a9a5SSteve French return 0;
280438c8a9a5SSteve French if (old->ctx->acdirmax != new->ctx->acdirmax)
280538c8a9a5SSteve French return 0;
280638c8a9a5SSteve French if (old->ctx->closetimeo != new->ctx->closetimeo)
280738c8a9a5SSteve French return 0;
2808c1468c7eSPaulo Alcantara if (old->ctx->reparse_type != new->ctx->reparse_type)
2809c1468c7eSPaulo Alcantara return 0;
281038c8a9a5SSteve French
281138c8a9a5SSteve French return 1;
281238c8a9a5SSteve French }
281338c8a9a5SSteve French
match_prepath(struct super_block * sb,struct cifs_tcon * tcon,struct cifs_mnt_data * mnt_data)281438c8a9a5SSteve French static int match_prepath(struct super_block *sb,
28153ae872deSPaulo Alcantara struct cifs_tcon *tcon,
281638c8a9a5SSteve French struct cifs_mnt_data *mnt_data)
281738c8a9a5SSteve French {
281838c8a9a5SSteve French struct smb3_fs_context *ctx = mnt_data->ctx;
281938c8a9a5SSteve French struct cifs_sb_info *old = CIFS_SB(sb);
282038c8a9a5SSteve French struct cifs_sb_info *new = mnt_data->cifs_sb;
282138c8a9a5SSteve French bool old_set = (old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
282238c8a9a5SSteve French old->prepath;
282338c8a9a5SSteve French bool new_set = (new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
282438c8a9a5SSteve French new->prepath;
282538c8a9a5SSteve French
28263ae872deSPaulo Alcantara if (tcon->origin_fullpath &&
28273ae872deSPaulo Alcantara dfs_src_pathname_equal(tcon->origin_fullpath, ctx->source))
282838c8a9a5SSteve French return 1;
282938c8a9a5SSteve French
283038c8a9a5SSteve French if (old_set && new_set && !strcmp(new->prepath, old->prepath))
283138c8a9a5SSteve French return 1;
283238c8a9a5SSteve French else if (!old_set && !new_set)
283338c8a9a5SSteve French return 1;
283438c8a9a5SSteve French
283538c8a9a5SSteve French return 0;
283638c8a9a5SSteve French }
283738c8a9a5SSteve French
283838c8a9a5SSteve French int
cifs_match_super(struct super_block * sb,void * data)283938c8a9a5SSteve French cifs_match_super(struct super_block *sb, void *data)
284038c8a9a5SSteve French {
284138c8a9a5SSteve French struct cifs_mnt_data *mnt_data = data;
284238c8a9a5SSteve French struct smb3_fs_context *ctx;
284338c8a9a5SSteve French struct cifs_sb_info *cifs_sb;
284438c8a9a5SSteve French struct TCP_Server_Info *tcp_srv;
284538c8a9a5SSteve French struct cifs_ses *ses;
284638c8a9a5SSteve French struct cifs_tcon *tcon;
284738c8a9a5SSteve French struct tcon_link *tlink;
284838c8a9a5SSteve French int rc = 0;
284938c8a9a5SSteve French
285038c8a9a5SSteve French spin_lock(&cifs_tcp_ses_lock);
285138c8a9a5SSteve French cifs_sb = CIFS_SB(sb);
285238c8a9a5SSteve French
285338c8a9a5SSteve French /* We do not want to use a superblock that has been shutdown */
285438c8a9a5SSteve French if (CIFS_MOUNT_SHUTDOWN & cifs_sb->mnt_cifs_flags) {
285538c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
285638c8a9a5SSteve French return 0;
285738c8a9a5SSteve French }
285838c8a9a5SSteve French
285938c8a9a5SSteve French tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2860fc1bd51dSPaulo Alcantara if (IS_ERR_OR_NULL(tlink)) {
2861fc1bd51dSPaulo Alcantara pr_warn_once("%s: skip super matching due to bad tlink(%p)\n",
2862fc1bd51dSPaulo Alcantara __func__, tlink);
286338c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
286438c8a9a5SSteve French return 0;
286538c8a9a5SSteve French }
286638c8a9a5SSteve French tcon = tlink_tcon(tlink);
286738c8a9a5SSteve French ses = tcon->ses;
286838c8a9a5SSteve French tcp_srv = ses->server;
286938c8a9a5SSteve French
287038c8a9a5SSteve French ctx = mnt_data->ctx;
287138c8a9a5SSteve French
287238c8a9a5SSteve French spin_lock(&tcp_srv->srv_lock);
287338c8a9a5SSteve French spin_lock(&ses->ses_lock);
287438c8a9a5SSteve French spin_lock(&ses->chan_lock);
287538c8a9a5SSteve French spin_lock(&tcon->tc_lock);
28763ae872deSPaulo Alcantara if (!match_server(tcp_srv, ctx, true) ||
287738c8a9a5SSteve French !match_session(ses, ctx) ||
287838c8a9a5SSteve French !match_tcon(tcon, ctx) ||
28793ae872deSPaulo Alcantara !match_prepath(sb, tcon, mnt_data)) {
288038c8a9a5SSteve French rc = 0;
288138c8a9a5SSteve French goto out;
288238c8a9a5SSteve French }
288338c8a9a5SSteve French
288438c8a9a5SSteve French rc = compare_mount_options(sb, mnt_data);
288538c8a9a5SSteve French out:
288638c8a9a5SSteve French spin_unlock(&tcon->tc_lock);
288738c8a9a5SSteve French spin_unlock(&ses->chan_lock);
288838c8a9a5SSteve French spin_unlock(&ses->ses_lock);
288938c8a9a5SSteve French spin_unlock(&tcp_srv->srv_lock);
289038c8a9a5SSteve French
289138c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
289238c8a9a5SSteve French cifs_put_tlink(tlink);
289338c8a9a5SSteve French return rc;
289438c8a9a5SSteve French }
289538c8a9a5SSteve French
289638c8a9a5SSteve French #ifdef CONFIG_DEBUG_LOCK_ALLOC
289738c8a9a5SSteve French static struct lock_class_key cifs_key[2];
289838c8a9a5SSteve French static struct lock_class_key cifs_slock_key[2];
289938c8a9a5SSteve French
290038c8a9a5SSteve French static inline void
cifs_reclassify_socket4(struct socket * sock)290138c8a9a5SSteve French cifs_reclassify_socket4(struct socket *sock)
290238c8a9a5SSteve French {
290338c8a9a5SSteve French struct sock *sk = sock->sk;
2904da70c1d3SPierre Mariani
290538c8a9a5SSteve French BUG_ON(!sock_allow_reclassification(sk));
290638c8a9a5SSteve French sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
290738c8a9a5SSteve French &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
290838c8a9a5SSteve French }
290938c8a9a5SSteve French
291038c8a9a5SSteve French static inline void
cifs_reclassify_socket6(struct socket * sock)291138c8a9a5SSteve French cifs_reclassify_socket6(struct socket *sock)
291238c8a9a5SSteve French {
291338c8a9a5SSteve French struct sock *sk = sock->sk;
2914da70c1d3SPierre Mariani
291538c8a9a5SSteve French BUG_ON(!sock_allow_reclassification(sk));
291638c8a9a5SSteve French sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
291738c8a9a5SSteve French &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
291838c8a9a5SSteve French }
291938c8a9a5SSteve French #else
292038c8a9a5SSteve French static inline void
cifs_reclassify_socket4(struct socket * sock)292138c8a9a5SSteve French cifs_reclassify_socket4(struct socket *sock)
292238c8a9a5SSteve French {
292338c8a9a5SSteve French }
292438c8a9a5SSteve French
292538c8a9a5SSteve French static inline void
cifs_reclassify_socket6(struct socket * sock)292638c8a9a5SSteve French cifs_reclassify_socket6(struct socket *sock)
292738c8a9a5SSteve French {
292838c8a9a5SSteve French }
292938c8a9a5SSteve French #endif
293038c8a9a5SSteve French
293138c8a9a5SSteve French /* See RFC1001 section 14 on representation of Netbios names */
rfc1002mangle(char * target,char * source,unsigned int length)293238c8a9a5SSteve French static void rfc1002mangle(char *target, char *source, unsigned int length)
293338c8a9a5SSteve French {
293438c8a9a5SSteve French unsigned int i, j;
293538c8a9a5SSteve French
293638c8a9a5SSteve French for (i = 0, j = 0; i < (length); i++) {
293738c8a9a5SSteve French /* mask a nibble at a time and encode */
293838c8a9a5SSteve French target[j] = 'A' + (0x0F & (source[i] >> 4));
293938c8a9a5SSteve French target[j+1] = 'A' + (0x0F & source[i]);
294038c8a9a5SSteve French j += 2;
294138c8a9a5SSteve French }
294238c8a9a5SSteve French
294338c8a9a5SSteve French }
294438c8a9a5SSteve French
294538c8a9a5SSteve French static int
bind_socket(struct TCP_Server_Info * server)294638c8a9a5SSteve French bind_socket(struct TCP_Server_Info *server)
294738c8a9a5SSteve French {
294838c8a9a5SSteve French int rc = 0;
2949da70c1d3SPierre Mariani
295038c8a9a5SSteve French if (server->srcaddr.ss_family != AF_UNSPEC) {
295138c8a9a5SSteve French /* Bind to the specified local IP address */
295238c8a9a5SSteve French struct socket *socket = server->ssocket;
2953da70c1d3SPierre Mariani
2954cedc019bSJordan Rife rc = kernel_bind(socket,
295538c8a9a5SSteve French (struct sockaddr *) &server->srcaddr,
295638c8a9a5SSteve French sizeof(server->srcaddr));
295738c8a9a5SSteve French if (rc < 0) {
295838c8a9a5SSteve French struct sockaddr_in *saddr4;
295938c8a9a5SSteve French struct sockaddr_in6 *saddr6;
2960da70c1d3SPierre Mariani
296138c8a9a5SSteve French saddr4 = (struct sockaddr_in *)&server->srcaddr;
296238c8a9a5SSteve French saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
296338c8a9a5SSteve French if (saddr6->sin6_family == AF_INET6)
296438c8a9a5SSteve French cifs_server_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
296538c8a9a5SSteve French &saddr6->sin6_addr, rc);
296638c8a9a5SSteve French else
296738c8a9a5SSteve French cifs_server_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
296838c8a9a5SSteve French &saddr4->sin_addr.s_addr, rc);
296938c8a9a5SSteve French }
297038c8a9a5SSteve French }
297138c8a9a5SSteve French return rc;
297238c8a9a5SSteve French }
297338c8a9a5SSteve French
297438c8a9a5SSteve French static int
ip_rfc1001_connect(struct TCP_Server_Info * server)297538c8a9a5SSteve French ip_rfc1001_connect(struct TCP_Server_Info *server)
297638c8a9a5SSteve French {
297738c8a9a5SSteve French int rc = 0;
297838c8a9a5SSteve French /*
297938c8a9a5SSteve French * some servers require RFC1001 sessinit before sending
298038c8a9a5SSteve French * negprot - BB check reconnection in case where second
298138c8a9a5SSteve French * sessinit is sent but no second negprot
298238c8a9a5SSteve French */
298338c8a9a5SSteve French struct rfc1002_session_packet req = {};
298438c8a9a5SSteve French struct smb_hdr *smb_buf = (struct smb_hdr *)&req;
298538c8a9a5SSteve French unsigned int len;
298638c8a9a5SSteve French
298738c8a9a5SSteve French req.trailer.session_req.called_len = sizeof(req.trailer.session_req.called_name);
298838c8a9a5SSteve French
298938c8a9a5SSteve French if (server->server_RFC1001_name[0] != 0)
299038c8a9a5SSteve French rfc1002mangle(req.trailer.session_req.called_name,
299138c8a9a5SSteve French server->server_RFC1001_name,
299238c8a9a5SSteve French RFC1001_NAME_LEN_WITH_NULL);
299338c8a9a5SSteve French else
299438c8a9a5SSteve French rfc1002mangle(req.trailer.session_req.called_name,
299538c8a9a5SSteve French DEFAULT_CIFS_CALLED_NAME,
299638c8a9a5SSteve French RFC1001_NAME_LEN_WITH_NULL);
299738c8a9a5SSteve French
299838c8a9a5SSteve French req.trailer.session_req.calling_len = sizeof(req.trailer.session_req.calling_name);
299938c8a9a5SSteve French
300038c8a9a5SSteve French /* calling name ends in null (byte 16) from old smb convention */
300138c8a9a5SSteve French if (server->workstation_RFC1001_name[0] != 0)
300238c8a9a5SSteve French rfc1002mangle(req.trailer.session_req.calling_name,
300338c8a9a5SSteve French server->workstation_RFC1001_name,
300438c8a9a5SSteve French RFC1001_NAME_LEN_WITH_NULL);
300538c8a9a5SSteve French else
300638c8a9a5SSteve French rfc1002mangle(req.trailer.session_req.calling_name,
300738c8a9a5SSteve French "LINUX_CIFS_CLNT",
300838c8a9a5SSteve French RFC1001_NAME_LEN_WITH_NULL);
300938c8a9a5SSteve French
301038c8a9a5SSteve French /*
301138c8a9a5SSteve French * As per rfc1002, @len must be the number of bytes that follows the
301238c8a9a5SSteve French * length field of a rfc1002 session request payload.
301338c8a9a5SSteve French */
301438c8a9a5SSteve French len = sizeof(req) - offsetof(struct rfc1002_session_packet, trailer.session_req);
301538c8a9a5SSteve French
301638c8a9a5SSteve French smb_buf->smb_buf_length = cpu_to_be32((RFC1002_SESSION_REQUEST << 24) | len);
301738c8a9a5SSteve French rc = smb_send(server, smb_buf, len);
301838c8a9a5SSteve French /*
301938c8a9a5SSteve French * RFC1001 layer in at least one server requires very short break before
302038c8a9a5SSteve French * negprot presumably because not expecting negprot to follow so fast.
302138c8a9a5SSteve French * This is a simple solution that works without complicating the code
302238c8a9a5SSteve French * and causes no significant slowing down on mount for everyone else
302338c8a9a5SSteve French */
302438c8a9a5SSteve French usleep_range(1000, 2000);
302538c8a9a5SSteve French
302638c8a9a5SSteve French return rc;
302738c8a9a5SSteve French }
302838c8a9a5SSteve French
302938c8a9a5SSteve French static int
generic_ip_connect(struct TCP_Server_Info * server)303038c8a9a5SSteve French generic_ip_connect(struct TCP_Server_Info *server)
303138c8a9a5SSteve French {
303238c8a9a5SSteve French struct sockaddr *saddr;
3033f0b6a834SPaulo Alcantara struct socket *socket;
3034f0b6a834SPaulo Alcantara int slen, sfamily;
3035f0b6a834SPaulo Alcantara __be16 sport;
3036f0b6a834SPaulo Alcantara int rc = 0;
303738c8a9a5SSteve French
303838c8a9a5SSteve French saddr = (struct sockaddr *) &server->dstaddr;
303938c8a9a5SSteve French
304038c8a9a5SSteve French if (server->dstaddr.ss_family == AF_INET6) {
304138c8a9a5SSteve French struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)&server->dstaddr;
304238c8a9a5SSteve French
304338c8a9a5SSteve French sport = ipv6->sin6_port;
304438c8a9a5SSteve French slen = sizeof(struct sockaddr_in6);
304538c8a9a5SSteve French sfamily = AF_INET6;
304638c8a9a5SSteve French cifs_dbg(FYI, "%s: connecting to [%pI6]:%d\n", __func__, &ipv6->sin6_addr,
304738c8a9a5SSteve French ntohs(sport));
304838c8a9a5SSteve French } else {
304938c8a9a5SSteve French struct sockaddr_in *ipv4 = (struct sockaddr_in *)&server->dstaddr;
305038c8a9a5SSteve French
305138c8a9a5SSteve French sport = ipv4->sin_port;
305238c8a9a5SSteve French slen = sizeof(struct sockaddr_in);
305338c8a9a5SSteve French sfamily = AF_INET;
305438c8a9a5SSteve French cifs_dbg(FYI, "%s: connecting to %pI4:%d\n", __func__, &ipv4->sin_addr,
305538c8a9a5SSteve French ntohs(sport));
305638c8a9a5SSteve French }
305738c8a9a5SSteve French
3058f0b6a834SPaulo Alcantara if (server->ssocket) {
3059f0b6a834SPaulo Alcantara socket = server->ssocket;
3060f0b6a834SPaulo Alcantara } else {
306138c8a9a5SSteve French rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3062f0b6a834SPaulo Alcantara IPPROTO_TCP, &server->ssocket, 1);
306338c8a9a5SSteve French if (rc < 0) {
306438c8a9a5SSteve French cifs_server_dbg(VFS, "Error %d creating socket\n", rc);
306538c8a9a5SSteve French return rc;
306638c8a9a5SSteve French }
306738c8a9a5SSteve French
306838c8a9a5SSteve French /* BB other socket options to set KEEPALIVE, NODELAY? */
306938c8a9a5SSteve French cifs_dbg(FYI, "Socket created\n");
3070f0b6a834SPaulo Alcantara socket = server->ssocket;
307138c8a9a5SSteve French socket->sk->sk_allocation = GFP_NOFS;
307238c8a9a5SSteve French socket->sk->sk_use_task_frag = false;
307338c8a9a5SSteve French if (sfamily == AF_INET6)
307438c8a9a5SSteve French cifs_reclassify_socket6(socket);
307538c8a9a5SSteve French else
307638c8a9a5SSteve French cifs_reclassify_socket4(socket);
307738c8a9a5SSteve French }
307838c8a9a5SSteve French
307938c8a9a5SSteve French rc = bind_socket(server);
308038c8a9a5SSteve French if (rc < 0)
308138c8a9a5SSteve French return rc;
308238c8a9a5SSteve French
308338c8a9a5SSteve French /*
308438c8a9a5SSteve French * Eventually check for other socket options to change from
308538c8a9a5SSteve French * the default. sock_setsockopt not used because it expects
308638c8a9a5SSteve French * user space buffer
308738c8a9a5SSteve French */
308838c8a9a5SSteve French socket->sk->sk_rcvtimeo = 7 * HZ;
308938c8a9a5SSteve French socket->sk->sk_sndtimeo = 5 * HZ;
309038c8a9a5SSteve French
309138c8a9a5SSteve French /* make the bufsizes depend on wsize/rsize and max requests */
309238c8a9a5SSteve French if (server->noautotune) {
309338c8a9a5SSteve French if (socket->sk->sk_sndbuf < (200 * 1024))
309438c8a9a5SSteve French socket->sk->sk_sndbuf = 200 * 1024;
309538c8a9a5SSteve French if (socket->sk->sk_rcvbuf < (140 * 1024))
309638c8a9a5SSteve French socket->sk->sk_rcvbuf = 140 * 1024;
309738c8a9a5SSteve French }
309838c8a9a5SSteve French
309938c8a9a5SSteve French if (server->tcp_nodelay)
310038c8a9a5SSteve French tcp_sock_set_nodelay(socket->sk);
310138c8a9a5SSteve French
310238c8a9a5SSteve French cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
310338c8a9a5SSteve French socket->sk->sk_sndbuf,
310438c8a9a5SSteve French socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
310538c8a9a5SSteve French
3106cedc019bSJordan Rife rc = kernel_connect(socket, saddr, slen,
310738c8a9a5SSteve French server->noblockcnt ? O_NONBLOCK : 0);
310838c8a9a5SSteve French /*
310938c8a9a5SSteve French * When mounting SMB root file systems, we do not want to block in
311038c8a9a5SSteve French * connect. Otherwise bail out and then let cifs_reconnect() perform
311138c8a9a5SSteve French * reconnect failover - if possible.
311238c8a9a5SSteve French */
311338c8a9a5SSteve French if (server->noblockcnt && rc == -EINPROGRESS)
311438c8a9a5SSteve French rc = 0;
311538c8a9a5SSteve French if (rc < 0) {
311638c8a9a5SSteve French cifs_dbg(FYI, "Error %d connecting to server\n", rc);
311738c8a9a5SSteve French trace_smb3_connect_err(server->hostname, server->conn_id, &server->dstaddr, rc);
311838c8a9a5SSteve French sock_release(socket);
311938c8a9a5SSteve French server->ssocket = NULL;
312038c8a9a5SSteve French return rc;
312138c8a9a5SSteve French }
312238c8a9a5SSteve French trace_smb3_connect_done(server->hostname, server->conn_id, &server->dstaddr);
312338c8a9a5SSteve French if (sport == htons(RFC1001_PORT))
312438c8a9a5SSteve French rc = ip_rfc1001_connect(server);
312538c8a9a5SSteve French
312638c8a9a5SSteve French return rc;
312738c8a9a5SSteve French }
312838c8a9a5SSteve French
312938c8a9a5SSteve French static int
ip_connect(struct TCP_Server_Info * server)313038c8a9a5SSteve French ip_connect(struct TCP_Server_Info *server)
313138c8a9a5SSteve French {
313238c8a9a5SSteve French __be16 *sport;
313338c8a9a5SSteve French struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
313438c8a9a5SSteve French struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
313538c8a9a5SSteve French
313638c8a9a5SSteve French if (server->dstaddr.ss_family == AF_INET6)
313738c8a9a5SSteve French sport = &addr6->sin6_port;
313838c8a9a5SSteve French else
313938c8a9a5SSteve French sport = &addr->sin_port;
314038c8a9a5SSteve French
314138c8a9a5SSteve French if (*sport == 0) {
314238c8a9a5SSteve French int rc;
314338c8a9a5SSteve French
314438c8a9a5SSteve French /* try with 445 port at first */
314538c8a9a5SSteve French *sport = htons(CIFS_PORT);
314638c8a9a5SSteve French
314738c8a9a5SSteve French rc = generic_ip_connect(server);
314838c8a9a5SSteve French if (rc >= 0)
314938c8a9a5SSteve French return rc;
315038c8a9a5SSteve French
315138c8a9a5SSteve French /* if it failed, try with 139 port */
315238c8a9a5SSteve French *sport = htons(RFC1001_PORT);
315338c8a9a5SSteve French }
315438c8a9a5SSteve French
315538c8a9a5SSteve French return generic_ip_connect(server);
315638c8a9a5SSteve French }
315738c8a9a5SSteve French
315838c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
reset_cifs_unix_caps(unsigned int xid,struct cifs_tcon * tcon,struct cifs_sb_info * cifs_sb,struct smb3_fs_context * ctx)315938c8a9a5SSteve French void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
316038c8a9a5SSteve French struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx)
316138c8a9a5SSteve French {
316238c8a9a5SSteve French /*
316338c8a9a5SSteve French * If we are reconnecting then should we check to see if
316438c8a9a5SSteve French * any requested capabilities changed locally e.g. via
316538c8a9a5SSteve French * remount but we can not do much about it here
316638c8a9a5SSteve French * if they have (even if we could detect it by the following)
316738c8a9a5SSteve French * Perhaps we could add a backpointer to array of sb from tcon
316838c8a9a5SSteve French * or if we change to make all sb to same share the same
316938c8a9a5SSteve French * sb as NFS - then we only have one backpointer to sb.
317038c8a9a5SSteve French * What if we wanted to mount the server share twice once with
317138c8a9a5SSteve French * and once without posixacls or posix paths?
317238c8a9a5SSteve French */
317338c8a9a5SSteve French __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
317438c8a9a5SSteve French
317538c8a9a5SSteve French if (ctx && ctx->no_linux_ext) {
317638c8a9a5SSteve French tcon->fsUnixInfo.Capability = 0;
317738c8a9a5SSteve French tcon->unix_ext = 0; /* Unix Extensions disabled */
317838c8a9a5SSteve French cifs_dbg(FYI, "Linux protocol extensions disabled\n");
317938c8a9a5SSteve French return;
318038c8a9a5SSteve French } else if (ctx)
318138c8a9a5SSteve French tcon->unix_ext = 1; /* Unix Extensions supported */
318238c8a9a5SSteve French
318338c8a9a5SSteve French if (!tcon->unix_ext) {
318438c8a9a5SSteve French cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
318538c8a9a5SSteve French return;
318638c8a9a5SSteve French }
318738c8a9a5SSteve French
318838c8a9a5SSteve French if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
318938c8a9a5SSteve French __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3190da70c1d3SPierre Mariani
319138c8a9a5SSteve French cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
319238c8a9a5SSteve French /*
319338c8a9a5SSteve French * check for reconnect case in which we do not
319438c8a9a5SSteve French * want to change the mount behavior if we can avoid it
319538c8a9a5SSteve French */
319638c8a9a5SSteve French if (ctx == NULL) {
319738c8a9a5SSteve French /*
319838c8a9a5SSteve French * turn off POSIX ACL and PATHNAMES if not set
319938c8a9a5SSteve French * originally at mount time
320038c8a9a5SSteve French */
320138c8a9a5SSteve French if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
320238c8a9a5SSteve French cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
320338c8a9a5SSteve French if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
320438c8a9a5SSteve French if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
320538c8a9a5SSteve French cifs_dbg(VFS, "POSIXPATH support change\n");
320638c8a9a5SSteve French cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
320738c8a9a5SSteve French } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
320838c8a9a5SSteve French cifs_dbg(VFS, "possible reconnect error\n");
320938c8a9a5SSteve French cifs_dbg(VFS, "server disabled POSIX path support\n");
321038c8a9a5SSteve French }
321138c8a9a5SSteve French }
321238c8a9a5SSteve French
321338c8a9a5SSteve French if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
321438c8a9a5SSteve French cifs_dbg(VFS, "per-share encryption not supported yet\n");
321538c8a9a5SSteve French
321638c8a9a5SSteve French cap &= CIFS_UNIX_CAP_MASK;
321738c8a9a5SSteve French if (ctx && ctx->no_psx_acl)
321838c8a9a5SSteve French cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
321938c8a9a5SSteve French else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
322038c8a9a5SSteve French cifs_dbg(FYI, "negotiated posix acl support\n");
322138c8a9a5SSteve French if (cifs_sb)
322238c8a9a5SSteve French cifs_sb->mnt_cifs_flags |=
322338c8a9a5SSteve French CIFS_MOUNT_POSIXACL;
322438c8a9a5SSteve French }
322538c8a9a5SSteve French
322638c8a9a5SSteve French if (ctx && ctx->posix_paths == 0)
322738c8a9a5SSteve French cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
322838c8a9a5SSteve French else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
322938c8a9a5SSteve French cifs_dbg(FYI, "negotiate posix pathnames\n");
323038c8a9a5SSteve French if (cifs_sb)
323138c8a9a5SSteve French cifs_sb->mnt_cifs_flags |=
323238c8a9a5SSteve French CIFS_MOUNT_POSIX_PATHS;
323338c8a9a5SSteve French }
323438c8a9a5SSteve French
323538c8a9a5SSteve French cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
323638c8a9a5SSteve French #ifdef CONFIG_CIFS_DEBUG2
323738c8a9a5SSteve French if (cap & CIFS_UNIX_FCNTL_CAP)
323838c8a9a5SSteve French cifs_dbg(FYI, "FCNTL cap\n");
323938c8a9a5SSteve French if (cap & CIFS_UNIX_EXTATTR_CAP)
324038c8a9a5SSteve French cifs_dbg(FYI, "EXTATTR cap\n");
324138c8a9a5SSteve French if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
324238c8a9a5SSteve French cifs_dbg(FYI, "POSIX path cap\n");
324338c8a9a5SSteve French if (cap & CIFS_UNIX_XATTR_CAP)
324438c8a9a5SSteve French cifs_dbg(FYI, "XATTR cap\n");
324538c8a9a5SSteve French if (cap & CIFS_UNIX_POSIX_ACL_CAP)
324638c8a9a5SSteve French cifs_dbg(FYI, "POSIX ACL cap\n");
324738c8a9a5SSteve French if (cap & CIFS_UNIX_LARGE_READ_CAP)
324838c8a9a5SSteve French cifs_dbg(FYI, "very large read cap\n");
324938c8a9a5SSteve French if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
325038c8a9a5SSteve French cifs_dbg(FYI, "very large write cap\n");
325138c8a9a5SSteve French if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
325238c8a9a5SSteve French cifs_dbg(FYI, "transport encryption cap\n");
325338c8a9a5SSteve French if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
325438c8a9a5SSteve French cifs_dbg(FYI, "mandatory transport encryption cap\n");
325538c8a9a5SSteve French #endif /* CIFS_DEBUG2 */
325638c8a9a5SSteve French if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
325738c8a9a5SSteve French if (ctx == NULL)
325838c8a9a5SSteve French cifs_dbg(FYI, "resetting capabilities failed\n");
325938c8a9a5SSteve French else
326038c8a9a5SSteve French 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");
326138c8a9a5SSteve French
326238c8a9a5SSteve French }
326338c8a9a5SSteve French }
326438c8a9a5SSteve French }
326538c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
326638c8a9a5SSteve French
cifs_setup_cifs_sb(struct cifs_sb_info * cifs_sb)326738c8a9a5SSteve French int cifs_setup_cifs_sb(struct cifs_sb_info *cifs_sb)
326838c8a9a5SSteve French {
326938c8a9a5SSteve French struct smb3_fs_context *ctx = cifs_sb->ctx;
327038c8a9a5SSteve French
327138c8a9a5SSteve French INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
327238c8a9a5SSteve French
327338c8a9a5SSteve French spin_lock_init(&cifs_sb->tlink_tree_lock);
327438c8a9a5SSteve French cifs_sb->tlink_tree = RB_ROOT;
327538c8a9a5SSteve French
327638c8a9a5SSteve French cifs_dbg(FYI, "file mode: %04ho dir mode: %04ho\n",
327738c8a9a5SSteve French ctx->file_mode, ctx->dir_mode);
327838c8a9a5SSteve French
327938c8a9a5SSteve French /* this is needed for ASCII cp to Unicode converts */
328038c8a9a5SSteve French if (ctx->iocharset == NULL) {
328138c8a9a5SSteve French /* load_nls_default cannot return null */
328238c8a9a5SSteve French cifs_sb->local_nls = load_nls_default();
328338c8a9a5SSteve French } else {
328438c8a9a5SSteve French cifs_sb->local_nls = load_nls(ctx->iocharset);
328538c8a9a5SSteve French if (cifs_sb->local_nls == NULL) {
328638c8a9a5SSteve French cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
328738c8a9a5SSteve French ctx->iocharset);
328838c8a9a5SSteve French return -ELIBACC;
328938c8a9a5SSteve French }
329038c8a9a5SSteve French }
329138c8a9a5SSteve French ctx->local_nls = cifs_sb->local_nls;
329238c8a9a5SSteve French
329338c8a9a5SSteve French smb3_update_mnt_flags(cifs_sb);
329438c8a9a5SSteve French
329538c8a9a5SSteve French if (ctx->direct_io)
329638c8a9a5SSteve French cifs_dbg(FYI, "mounting share using direct i/o\n");
329738c8a9a5SSteve French if (ctx->cache_ro) {
329838c8a9a5SSteve French cifs_dbg(VFS, "mounting share with read only caching. Ensure that the share will not be modified while in use.\n");
329938c8a9a5SSteve French cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RO_CACHE;
330038c8a9a5SSteve French } else if (ctx->cache_rw) {
330138c8a9a5SSteve French cifs_dbg(VFS, "mounting share in single client RW caching mode. Ensure that no other systems will be accessing the share.\n");
330238c8a9a5SSteve French cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_RO_CACHE |
330338c8a9a5SSteve French CIFS_MOUNT_RW_CACHE);
330438c8a9a5SSteve French }
330538c8a9a5SSteve French
330638c8a9a5SSteve French if ((ctx->cifs_acl) && (ctx->dynperm))
330738c8a9a5SSteve French cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
330838c8a9a5SSteve French
330938c8a9a5SSteve French if (ctx->prepath) {
331038c8a9a5SSteve French cifs_sb->prepath = kstrdup(ctx->prepath, GFP_KERNEL);
331138c8a9a5SSteve French if (cifs_sb->prepath == NULL)
331238c8a9a5SSteve French return -ENOMEM;
331338c8a9a5SSteve French cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
331438c8a9a5SSteve French }
331538c8a9a5SSteve French
331638c8a9a5SSteve French return 0;
331738c8a9a5SSteve French }
331838c8a9a5SSteve French
331938c8a9a5SSteve French /* Release all succeed connections */
cifs_mount_put_conns(struct cifs_mount_ctx * mnt_ctx)332038c8a9a5SSteve French void cifs_mount_put_conns(struct cifs_mount_ctx *mnt_ctx)
332138c8a9a5SSteve French {
332238c8a9a5SSteve French int rc = 0;
332338c8a9a5SSteve French
332438c8a9a5SSteve French if (mnt_ctx->tcon)
332507e76ea1SDavid Howells cifs_put_tcon(mnt_ctx->tcon, netfs_trace_tcon_ref_put_mnt_ctx);
332638c8a9a5SSteve French else if (mnt_ctx->ses)
332738c8a9a5SSteve French cifs_put_smb_ses(mnt_ctx->ses);
332838c8a9a5SSteve French else if (mnt_ctx->server)
332938c8a9a5SSteve French cifs_put_tcp_session(mnt_ctx->server, 0);
3330645f332cSPaulo Alcantara mnt_ctx->ses = NULL;
3331645f332cSPaulo Alcantara mnt_ctx->tcon = NULL;
3332645f332cSPaulo Alcantara mnt_ctx->server = NULL;
333338c8a9a5SSteve French mnt_ctx->cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
333438c8a9a5SSteve French free_xid(mnt_ctx->xid);
333538c8a9a5SSteve French }
333638c8a9a5SSteve French
cifs_mount_get_session(struct cifs_mount_ctx * mnt_ctx)333738c8a9a5SSteve French int cifs_mount_get_session(struct cifs_mount_ctx *mnt_ctx)
333838c8a9a5SSteve French {
333938c8a9a5SSteve French struct TCP_Server_Info *server = NULL;
334038c8a9a5SSteve French struct smb3_fs_context *ctx;
334138c8a9a5SSteve French struct cifs_ses *ses = NULL;
334238c8a9a5SSteve French unsigned int xid;
334338c8a9a5SSteve French int rc = 0;
334438c8a9a5SSteve French
334538c8a9a5SSteve French xid = get_xid();
334638c8a9a5SSteve French
334738c8a9a5SSteve French if (WARN_ON_ONCE(!mnt_ctx || !mnt_ctx->fs_ctx)) {
334838c8a9a5SSteve French rc = -EINVAL;
334938c8a9a5SSteve French goto out;
335038c8a9a5SSteve French }
335138c8a9a5SSteve French ctx = mnt_ctx->fs_ctx;
335238c8a9a5SSteve French
335338c8a9a5SSteve French /* get a reference to a tcp session */
335438c8a9a5SSteve French server = cifs_get_tcp_session(ctx, NULL);
335538c8a9a5SSteve French if (IS_ERR(server)) {
335638c8a9a5SSteve French rc = PTR_ERR(server);
335738c8a9a5SSteve French server = NULL;
335838c8a9a5SSteve French goto out;
335938c8a9a5SSteve French }
336038c8a9a5SSteve French
336138c8a9a5SSteve French /* get a reference to a SMB session */
336238c8a9a5SSteve French ses = cifs_get_smb_ses(server, ctx);
336338c8a9a5SSteve French if (IS_ERR(ses)) {
336438c8a9a5SSteve French rc = PTR_ERR(ses);
336538c8a9a5SSteve French ses = NULL;
336638c8a9a5SSteve French goto out;
336738c8a9a5SSteve French }
336838c8a9a5SSteve French
336938c8a9a5SSteve French if ((ctx->persistent == true) && (!(ses->server->capabilities &
337038c8a9a5SSteve French SMB2_GLOBAL_CAP_PERSISTENT_HANDLES))) {
337138c8a9a5SSteve French cifs_server_dbg(VFS, "persistent handles not supported by server\n");
337238c8a9a5SSteve French rc = -EOPNOTSUPP;
337338c8a9a5SSteve French }
337438c8a9a5SSteve French
337538c8a9a5SSteve French out:
337638c8a9a5SSteve French mnt_ctx->xid = xid;
337738c8a9a5SSteve French mnt_ctx->server = server;
337838c8a9a5SSteve French mnt_ctx->ses = ses;
337938c8a9a5SSteve French mnt_ctx->tcon = NULL;
338038c8a9a5SSteve French
338138c8a9a5SSteve French return rc;
338238c8a9a5SSteve French }
338338c8a9a5SSteve French
cifs_mount_get_tcon(struct cifs_mount_ctx * mnt_ctx)338438c8a9a5SSteve French int cifs_mount_get_tcon(struct cifs_mount_ctx *mnt_ctx)
338538c8a9a5SSteve French {
338638c8a9a5SSteve French struct TCP_Server_Info *server;
338738c8a9a5SSteve French struct cifs_sb_info *cifs_sb;
338838c8a9a5SSteve French struct smb3_fs_context *ctx;
338938c8a9a5SSteve French struct cifs_tcon *tcon = NULL;
339038c8a9a5SSteve French int rc = 0;
339138c8a9a5SSteve French
339238c8a9a5SSteve French if (WARN_ON_ONCE(!mnt_ctx || !mnt_ctx->server || !mnt_ctx->ses || !mnt_ctx->fs_ctx ||
339338c8a9a5SSteve French !mnt_ctx->cifs_sb)) {
339438c8a9a5SSteve French rc = -EINVAL;
339538c8a9a5SSteve French goto out;
339638c8a9a5SSteve French }
339738c8a9a5SSteve French server = mnt_ctx->server;
339838c8a9a5SSteve French ctx = mnt_ctx->fs_ctx;
339938c8a9a5SSteve French cifs_sb = mnt_ctx->cifs_sb;
340038c8a9a5SSteve French
340138c8a9a5SSteve French /* search for existing tcon to this server share */
340238c8a9a5SSteve French tcon = cifs_get_tcon(mnt_ctx->ses, ctx);
340338c8a9a5SSteve French if (IS_ERR(tcon)) {
340438c8a9a5SSteve French rc = PTR_ERR(tcon);
340538c8a9a5SSteve French tcon = NULL;
340638c8a9a5SSteve French goto out;
340738c8a9a5SSteve French }
340838c8a9a5SSteve French
340938c8a9a5SSteve French /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
341038c8a9a5SSteve French if (tcon->posix_extensions)
341138c8a9a5SSteve French cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
341238c8a9a5SSteve French
341338c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
341438c8a9a5SSteve French /* tell server which Unix caps we support */
341538c8a9a5SSteve French if (cap_unix(tcon->ses)) {
341638c8a9a5SSteve French /*
341738c8a9a5SSteve French * reset of caps checks mount to see if unix extensions disabled
341838c8a9a5SSteve French * for just this mount.
341938c8a9a5SSteve French */
342038c8a9a5SSteve French reset_cifs_unix_caps(mnt_ctx->xid, tcon, cifs_sb, ctx);
342138c8a9a5SSteve French spin_lock(&tcon->ses->server->srv_lock);
342238c8a9a5SSteve French if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
342338c8a9a5SSteve French (le64_to_cpu(tcon->fsUnixInfo.Capability) &
342438c8a9a5SSteve French CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
342538c8a9a5SSteve French spin_unlock(&tcon->ses->server->srv_lock);
342638c8a9a5SSteve French rc = -EACCES;
342738c8a9a5SSteve French goto out;
342838c8a9a5SSteve French }
342938c8a9a5SSteve French spin_unlock(&tcon->ses->server->srv_lock);
343038c8a9a5SSteve French } else
343138c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
343238c8a9a5SSteve French tcon->unix_ext = 0; /* server does not support them */
343338c8a9a5SSteve French
343438c8a9a5SSteve French /* do not care if a following call succeed - informational */
343538c8a9a5SSteve French if (!tcon->pipe && server->ops->qfs_tcon) {
343638c8a9a5SSteve French server->ops->qfs_tcon(mnt_ctx->xid, tcon, cifs_sb);
343738c8a9a5SSteve French if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE) {
343838c8a9a5SSteve French if (tcon->fsDevInfo.DeviceCharacteristics &
343938c8a9a5SSteve French cpu_to_le32(FILE_READ_ONLY_DEVICE))
344038c8a9a5SSteve French cifs_dbg(VFS, "mounted to read only share\n");
344138c8a9a5SSteve French else if ((cifs_sb->mnt_cifs_flags &
344238c8a9a5SSteve French CIFS_MOUNT_RW_CACHE) == 0)
344338c8a9a5SSteve French cifs_dbg(VFS, "read only mount of RW share\n");
344438c8a9a5SSteve French /* no need to log a RW mount of a typical RW share */
344538c8a9a5SSteve French }
344638c8a9a5SSteve French }
344738c8a9a5SSteve French
344838c8a9a5SSteve French /*
344938c8a9a5SSteve French * Clamp the rsize/wsize mount arguments if they are too big for the server
345038c8a9a5SSteve French * and set the rsize/wsize to the negotiated values if not passed in by
345138c8a9a5SSteve French * the user on mount
345238c8a9a5SSteve French */
345338c8a9a5SSteve French if ((cifs_sb->ctx->wsize == 0) ||
34544145ccffSSteve French (cifs_sb->ctx->wsize > server->ops->negotiate_wsize(tcon, ctx))) {
34554145ccffSSteve French cifs_sb->ctx->wsize =
34564145ccffSSteve French round_down(server->ops->negotiate_wsize(tcon, ctx), PAGE_SIZE);
34574145ccffSSteve French /*
34584145ccffSSteve French * in the very unlikely event that the server sent a max write size under PAGE_SIZE,
34594145ccffSSteve French * (which would get rounded down to 0) then reset wsize to absolute minimum eg 4096
34604145ccffSSteve French */
34614145ccffSSteve French if (cifs_sb->ctx->wsize == 0) {
34624145ccffSSteve French cifs_sb->ctx->wsize = PAGE_SIZE;
34634145ccffSSteve French cifs_dbg(VFS, "wsize too small, reset to minimum ie PAGE_SIZE, usually 4096\n");
34644145ccffSSteve French }
34654145ccffSSteve French }
346638c8a9a5SSteve French if ((cifs_sb->ctx->rsize == 0) ||
346738c8a9a5SSteve French (cifs_sb->ctx->rsize > server->ops->negotiate_rsize(tcon, ctx)))
346838c8a9a5SSteve French cifs_sb->ctx->rsize = server->ops->negotiate_rsize(tcon, ctx);
346938c8a9a5SSteve French
347038c8a9a5SSteve French /*
347138c8a9a5SSteve French * The cookie is initialized from volume info returned above.
347238c8a9a5SSteve French * Inside cifs_fscache_get_super_cookie it checks
347338c8a9a5SSteve French * that we do not get super cookie twice.
347438c8a9a5SSteve French */
347538c8a9a5SSteve French if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
347638c8a9a5SSteve French cifs_fscache_get_super_cookie(tcon);
347738c8a9a5SSteve French
347838c8a9a5SSteve French out:
347938c8a9a5SSteve French mnt_ctx->tcon = tcon;
348038c8a9a5SSteve French return rc;
348138c8a9a5SSteve French }
348238c8a9a5SSteve French
mount_setup_tlink(struct cifs_sb_info * cifs_sb,struct cifs_ses * ses,struct cifs_tcon * tcon)348338c8a9a5SSteve French static int mount_setup_tlink(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
348438c8a9a5SSteve French struct cifs_tcon *tcon)
348538c8a9a5SSteve French {
348638c8a9a5SSteve French struct tcon_link *tlink;
348738c8a9a5SSteve French
348838c8a9a5SSteve French /* hang the tcon off of the superblock */
348938c8a9a5SSteve French tlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
349038c8a9a5SSteve French if (tlink == NULL)
349138c8a9a5SSteve French return -ENOMEM;
349238c8a9a5SSteve French
349338c8a9a5SSteve French tlink->tl_uid = ses->linux_uid;
349438c8a9a5SSteve French tlink->tl_tcon = tcon;
349538c8a9a5SSteve French tlink->tl_time = jiffies;
349638c8a9a5SSteve French set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
349738c8a9a5SSteve French set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
349838c8a9a5SSteve French
349938c8a9a5SSteve French cifs_sb->master_tlink = tlink;
350038c8a9a5SSteve French spin_lock(&cifs_sb->tlink_tree_lock);
350138c8a9a5SSteve French tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
350238c8a9a5SSteve French spin_unlock(&cifs_sb->tlink_tree_lock);
350338c8a9a5SSteve French
350438c8a9a5SSteve French queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
350538c8a9a5SSteve French TLINK_IDLE_EXPIRE);
350638c8a9a5SSteve French return 0;
350738c8a9a5SSteve French }
350838c8a9a5SSteve French
350938c8a9a5SSteve French static int
cifs_are_all_path_components_accessible(struct TCP_Server_Info * server,unsigned int xid,struct cifs_tcon * tcon,struct cifs_sb_info * cifs_sb,char * full_path,int added_treename)351038c8a9a5SSteve French cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
351138c8a9a5SSteve French unsigned int xid,
351238c8a9a5SSteve French struct cifs_tcon *tcon,
351338c8a9a5SSteve French struct cifs_sb_info *cifs_sb,
351438c8a9a5SSteve French char *full_path,
351538c8a9a5SSteve French int added_treename)
351638c8a9a5SSteve French {
351738c8a9a5SSteve French int rc;
351838c8a9a5SSteve French char *s;
351938c8a9a5SSteve French char sep, tmp;
352038c8a9a5SSteve French int skip = added_treename ? 1 : 0;
352138c8a9a5SSteve French
352238c8a9a5SSteve French sep = CIFS_DIR_SEP(cifs_sb);
352338c8a9a5SSteve French s = full_path;
352438c8a9a5SSteve French
352538c8a9a5SSteve French rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
352638c8a9a5SSteve French while (rc == 0) {
352738c8a9a5SSteve French /* skip separators */
352838c8a9a5SSteve French while (*s == sep)
352938c8a9a5SSteve French s++;
353038c8a9a5SSteve French if (!*s)
353138c8a9a5SSteve French break;
353238c8a9a5SSteve French /* next separator */
353338c8a9a5SSteve French while (*s && *s != sep)
353438c8a9a5SSteve French s++;
353538c8a9a5SSteve French /*
353638c8a9a5SSteve French * if the treename is added, we then have to skip the first
353738c8a9a5SSteve French * part within the separators
353838c8a9a5SSteve French */
353938c8a9a5SSteve French if (skip) {
354038c8a9a5SSteve French skip = 0;
354138c8a9a5SSteve French continue;
354238c8a9a5SSteve French }
354338c8a9a5SSteve French /*
354438c8a9a5SSteve French * temporarily null-terminate the path at the end of
354538c8a9a5SSteve French * the current component
354638c8a9a5SSteve French */
354738c8a9a5SSteve French tmp = *s;
354838c8a9a5SSteve French *s = 0;
354938c8a9a5SSteve French rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
355038c8a9a5SSteve French full_path);
355138c8a9a5SSteve French *s = tmp;
355238c8a9a5SSteve French }
355338c8a9a5SSteve French return rc;
355438c8a9a5SSteve French }
355538c8a9a5SSteve French
355638c8a9a5SSteve French /*
355738c8a9a5SSteve French * Check if path is remote (i.e. a DFS share).
355838c8a9a5SSteve French *
355938c8a9a5SSteve French * Return -EREMOTE if it is, otherwise 0 or -errno.
356038c8a9a5SSteve French */
cifs_is_path_remote(struct cifs_mount_ctx * mnt_ctx)356138c8a9a5SSteve French int cifs_is_path_remote(struct cifs_mount_ctx *mnt_ctx)
356238c8a9a5SSteve French {
356338c8a9a5SSteve French int rc;
356438c8a9a5SSteve French struct cifs_sb_info *cifs_sb = mnt_ctx->cifs_sb;
356538c8a9a5SSteve French struct TCP_Server_Info *server = mnt_ctx->server;
356638c8a9a5SSteve French unsigned int xid = mnt_ctx->xid;
356738c8a9a5SSteve French struct cifs_tcon *tcon = mnt_ctx->tcon;
356838c8a9a5SSteve French struct smb3_fs_context *ctx = mnt_ctx->fs_ctx;
356938c8a9a5SSteve French char *full_path;
357038c8a9a5SSteve French
357138c8a9a5SSteve French if (!server->ops->is_path_accessible)
357238c8a9a5SSteve French return -EOPNOTSUPP;
357338c8a9a5SSteve French
357438c8a9a5SSteve French /*
357538c8a9a5SSteve French * cifs_build_path_to_root works only when we have a valid tcon
357638c8a9a5SSteve French */
357738c8a9a5SSteve French full_path = cifs_build_path_to_root(ctx, cifs_sb, tcon,
357838c8a9a5SSteve French tcon->Flags & SMB_SHARE_IS_IN_DFS);
357938c8a9a5SSteve French if (full_path == NULL)
358038c8a9a5SSteve French return -ENOMEM;
358138c8a9a5SSteve French
358238c8a9a5SSteve French cifs_dbg(FYI, "%s: full_path: %s\n", __func__, full_path);
358338c8a9a5SSteve French
358438c8a9a5SSteve French rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
358538c8a9a5SSteve French full_path);
358638c8a9a5SSteve French if (rc != 0 && rc != -EREMOTE)
358738c8a9a5SSteve French goto out;
358838c8a9a5SSteve French
358938c8a9a5SSteve French if (rc != -EREMOTE) {
359038c8a9a5SSteve French rc = cifs_are_all_path_components_accessible(server, xid, tcon,
359138c8a9a5SSteve French cifs_sb, full_path, tcon->Flags & SMB_SHARE_IS_IN_DFS);
359238c8a9a5SSteve French if (rc != 0) {
359338c8a9a5SSteve French cifs_server_dbg(VFS, "cannot query dirs between root and final path, enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
359438c8a9a5SSteve French cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
359538c8a9a5SSteve French rc = 0;
359638c8a9a5SSteve French }
359738c8a9a5SSteve French }
359838c8a9a5SSteve French
359938c8a9a5SSteve French out:
360038c8a9a5SSteve French kfree(full_path);
360138c8a9a5SSteve French return rc;
360238c8a9a5SSteve French }
360338c8a9a5SSteve French
360438c8a9a5SSteve French #ifdef CONFIG_CIFS_DFS_UPCALL
cifs_mount(struct cifs_sb_info * cifs_sb,struct smb3_fs_context * ctx)360538c8a9a5SSteve French int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx)
360638c8a9a5SSteve French {
360738c8a9a5SSteve French struct cifs_mount_ctx mnt_ctx = { .cifs_sb = cifs_sb, .fs_ctx = ctx, };
360838c8a9a5SSteve French bool isdfs;
360938c8a9a5SSteve French int rc;
361038c8a9a5SSteve French
361138c8a9a5SSteve French rc = dfs_mount_share(&mnt_ctx, &isdfs);
361238c8a9a5SSteve French if (rc)
361338c8a9a5SSteve French goto error;
361438c8a9a5SSteve French if (!isdfs)
361538c8a9a5SSteve French goto out;
361638c8a9a5SSteve French
361738c8a9a5SSteve French /*
361838c8a9a5SSteve French * After reconnecting to a different server, unique ids won't match anymore, so we disable
361938c8a9a5SSteve French * serverino. This prevents dentry revalidation to think the dentry are stale (ESTALE).
362038c8a9a5SSteve French */
362138c8a9a5SSteve French cifs_autodisable_serverino(cifs_sb);
362238c8a9a5SSteve French /*
362338c8a9a5SSteve French * Force the use of prefix path to support failover on DFS paths that resolve to targets
362438c8a9a5SSteve French * that have different prefix paths.
362538c8a9a5SSteve French */
362638c8a9a5SSteve French cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
362738c8a9a5SSteve French kfree(cifs_sb->prepath);
362838c8a9a5SSteve French cifs_sb->prepath = ctx->prepath;
362938c8a9a5SSteve French ctx->prepath = NULL;
363038c8a9a5SSteve French
363138c8a9a5SSteve French out:
3632739bf98cSShyam Prasad N cifs_try_adding_channels(mnt_ctx.ses);
363338c8a9a5SSteve French rc = mount_setup_tlink(cifs_sb, mnt_ctx.ses, mnt_ctx.tcon);
363438c8a9a5SSteve French if (rc)
363538c8a9a5SSteve French goto error;
363638c8a9a5SSteve French
363738c8a9a5SSteve French free_xid(mnt_ctx.xid);
363838c8a9a5SSteve French return rc;
363938c8a9a5SSteve French
364038c8a9a5SSteve French error:
364138c8a9a5SSteve French cifs_mount_put_conns(&mnt_ctx);
364238c8a9a5SSteve French return rc;
364338c8a9a5SSteve French }
364438c8a9a5SSteve French #else
cifs_mount(struct cifs_sb_info * cifs_sb,struct smb3_fs_context * ctx)364538c8a9a5SSteve French int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx)
364638c8a9a5SSteve French {
364738c8a9a5SSteve French int rc = 0;
364838c8a9a5SSteve French struct cifs_mount_ctx mnt_ctx = { .cifs_sb = cifs_sb, .fs_ctx = ctx, };
364938c8a9a5SSteve French
365038c8a9a5SSteve French rc = cifs_mount_get_session(&mnt_ctx);
365138c8a9a5SSteve French if (rc)
365238c8a9a5SSteve French goto error;
365338c8a9a5SSteve French
365438c8a9a5SSteve French rc = cifs_mount_get_tcon(&mnt_ctx);
3655645f332cSPaulo Alcantara if (!rc) {
3656645f332cSPaulo Alcantara /*
3657645f332cSPaulo Alcantara * Prevent superblock from being created with any missing
3658645f332cSPaulo Alcantara * connections.
3659645f332cSPaulo Alcantara */
3660645f332cSPaulo Alcantara if (WARN_ON(!mnt_ctx.server))
3661645f332cSPaulo Alcantara rc = -EHOSTDOWN;
3662645f332cSPaulo Alcantara else if (WARN_ON(!mnt_ctx.ses))
3663645f332cSPaulo Alcantara rc = -EACCES;
3664645f332cSPaulo Alcantara else if (WARN_ON(!mnt_ctx.tcon))
3665645f332cSPaulo Alcantara rc = -ENOENT;
3666645f332cSPaulo Alcantara }
366738c8a9a5SSteve French if (rc)
366838c8a9a5SSteve French goto error;
366938c8a9a5SSteve French
367038c8a9a5SSteve French rc = cifs_is_path_remote(&mnt_ctx);
367138c8a9a5SSteve French if (rc == -EREMOTE)
367238c8a9a5SSteve French rc = -EOPNOTSUPP;
367338c8a9a5SSteve French if (rc)
367438c8a9a5SSteve French goto error;
367538c8a9a5SSteve French
367638c8a9a5SSteve French rc = mount_setup_tlink(cifs_sb, mnt_ctx.ses, mnt_ctx.tcon);
367738c8a9a5SSteve French if (rc)
367838c8a9a5SSteve French goto error;
367938c8a9a5SSteve French
368038c8a9a5SSteve French free_xid(mnt_ctx.xid);
368138c8a9a5SSteve French return rc;
368238c8a9a5SSteve French
368338c8a9a5SSteve French error:
368438c8a9a5SSteve French cifs_mount_put_conns(&mnt_ctx);
368538c8a9a5SSteve French return rc;
368638c8a9a5SSteve French }
368738c8a9a5SSteve French #endif
368838c8a9a5SSteve French
368938c8a9a5SSteve French /*
369038c8a9a5SSteve French * Issue a TREE_CONNECT request.
369138c8a9a5SSteve French */
369238c8a9a5SSteve French int
CIFSTCon(const unsigned int xid,struct cifs_ses * ses,const char * tree,struct cifs_tcon * tcon,const struct nls_table * nls_codepage)369338c8a9a5SSteve French CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
369438c8a9a5SSteve French const char *tree, struct cifs_tcon *tcon,
369538c8a9a5SSteve French const struct nls_table *nls_codepage)
369638c8a9a5SSteve French {
369738c8a9a5SSteve French struct smb_hdr *smb_buffer;
369838c8a9a5SSteve French struct smb_hdr *smb_buffer_response;
369938c8a9a5SSteve French TCONX_REQ *pSMB;
370038c8a9a5SSteve French TCONX_RSP *pSMBr;
370138c8a9a5SSteve French unsigned char *bcc_ptr;
370238c8a9a5SSteve French int rc = 0;
370338c8a9a5SSteve French int length;
370438c8a9a5SSteve French __u16 bytes_left, count;
370538c8a9a5SSteve French
370638c8a9a5SSteve French if (ses == NULL)
370738c8a9a5SSteve French return -EIO;
370838c8a9a5SSteve French
370938c8a9a5SSteve French smb_buffer = cifs_buf_get();
371038c8a9a5SSteve French if (smb_buffer == NULL)
371138c8a9a5SSteve French return -ENOMEM;
371238c8a9a5SSteve French
371338c8a9a5SSteve French smb_buffer_response = smb_buffer;
371438c8a9a5SSteve French
371538c8a9a5SSteve French header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
371638c8a9a5SSteve French NULL /*no tid */, 4 /*wct */);
371738c8a9a5SSteve French
371838c8a9a5SSteve French smb_buffer->Mid = get_next_mid(ses->server);
371938c8a9a5SSteve French smb_buffer->Uid = ses->Suid;
372038c8a9a5SSteve French pSMB = (TCONX_REQ *) smb_buffer;
372138c8a9a5SSteve French pSMBr = (TCONX_RSP *) smb_buffer_response;
372238c8a9a5SSteve French
372338c8a9a5SSteve French pSMB->AndXCommand = 0xFF;
372438c8a9a5SSteve French pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
372538c8a9a5SSteve French bcc_ptr = &pSMB->Password[0];
372638c8a9a5SSteve French
372738c8a9a5SSteve French pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
372838c8a9a5SSteve French *bcc_ptr = 0; /* password is null byte */
372938c8a9a5SSteve French bcc_ptr++; /* skip password */
373038c8a9a5SSteve French /* already aligned so no need to do it below */
373138c8a9a5SSteve French
373238c8a9a5SSteve French if (ses->server->sign)
373338c8a9a5SSteve French smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
373438c8a9a5SSteve French
3735da70c1d3SPierre Mariani if (ses->capabilities & CAP_STATUS32)
373638c8a9a5SSteve French smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3737da70c1d3SPierre Mariani
3738da70c1d3SPierre Mariani if (ses->capabilities & CAP_DFS)
373938c8a9a5SSteve French smb_buffer->Flags2 |= SMBFLG2_DFS;
3740da70c1d3SPierre Mariani
374138c8a9a5SSteve French if (ses->capabilities & CAP_UNICODE) {
374238c8a9a5SSteve French smb_buffer->Flags2 |= SMBFLG2_UNICODE;
374338c8a9a5SSteve French length =
374438c8a9a5SSteve French cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
374538c8a9a5SSteve French 6 /* max utf8 char length in bytes */ *
374638c8a9a5SSteve French (/* server len*/ + 256 /* share len */), nls_codepage);
374738c8a9a5SSteve French bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
374838c8a9a5SSteve French bcc_ptr += 2; /* skip trailing null */
374938c8a9a5SSteve French } else { /* ASCII */
375038c8a9a5SSteve French strcpy(bcc_ptr, tree);
375138c8a9a5SSteve French bcc_ptr += strlen(tree) + 1;
375238c8a9a5SSteve French }
375338c8a9a5SSteve French strcpy(bcc_ptr, "?????");
375438c8a9a5SSteve French bcc_ptr += strlen("?????");
375538c8a9a5SSteve French bcc_ptr += 1;
375638c8a9a5SSteve French count = bcc_ptr - &pSMB->Password[0];
375738c8a9a5SSteve French be32_add_cpu(&pSMB->hdr.smb_buf_length, count);
375838c8a9a5SSteve French pSMB->ByteCount = cpu_to_le16(count);
375938c8a9a5SSteve French
376038c8a9a5SSteve French rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
376138c8a9a5SSteve French 0);
376238c8a9a5SSteve French
376338c8a9a5SSteve French /* above now done in SendReceive */
376438c8a9a5SSteve French if (rc == 0) {
376538c8a9a5SSteve French bool is_unicode;
376638c8a9a5SSteve French
376738c8a9a5SSteve French tcon->tid = smb_buffer_response->Tid;
376838c8a9a5SSteve French bcc_ptr = pByteArea(smb_buffer_response);
376938c8a9a5SSteve French bytes_left = get_bcc(smb_buffer_response);
377038c8a9a5SSteve French length = strnlen(bcc_ptr, bytes_left - 2);
377138c8a9a5SSteve French if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
377238c8a9a5SSteve French is_unicode = true;
377338c8a9a5SSteve French else
377438c8a9a5SSteve French is_unicode = false;
377538c8a9a5SSteve French
377638c8a9a5SSteve French
377738c8a9a5SSteve French /* skip service field (NB: this field is always ASCII) */
377838c8a9a5SSteve French if (length == 3) {
377938c8a9a5SSteve French if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
378038c8a9a5SSteve French (bcc_ptr[2] == 'C')) {
378138c8a9a5SSteve French cifs_dbg(FYI, "IPC connection\n");
378238c8a9a5SSteve French tcon->ipc = true;
378338c8a9a5SSteve French tcon->pipe = true;
378438c8a9a5SSteve French }
378538c8a9a5SSteve French } else if (length == 2) {
378638c8a9a5SSteve French if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
378738c8a9a5SSteve French /* the most common case */
378838c8a9a5SSteve French cifs_dbg(FYI, "disk share connection\n");
378938c8a9a5SSteve French }
379038c8a9a5SSteve French }
379138c8a9a5SSteve French bcc_ptr += length + 1;
379238c8a9a5SSteve French bytes_left -= (length + 1);
379338c8a9a5SSteve French strscpy(tcon->tree_name, tree, sizeof(tcon->tree_name));
379438c8a9a5SSteve French
379538c8a9a5SSteve French /* mostly informational -- no need to fail on error here */
379638c8a9a5SSteve French kfree(tcon->nativeFileSystem);
379738c8a9a5SSteve French tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
379838c8a9a5SSteve French bytes_left, is_unicode,
379938c8a9a5SSteve French nls_codepage);
380038c8a9a5SSteve French
380138c8a9a5SSteve French cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
380238c8a9a5SSteve French
380338c8a9a5SSteve French if ((smb_buffer_response->WordCount == 3) ||
380438c8a9a5SSteve French (smb_buffer_response->WordCount == 7))
380538c8a9a5SSteve French /* field is in same location */
380638c8a9a5SSteve French tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
380738c8a9a5SSteve French else
380838c8a9a5SSteve French tcon->Flags = 0;
380938c8a9a5SSteve French cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
381038c8a9a5SSteve French }
381138c8a9a5SSteve French
381238c8a9a5SSteve French cifs_buf_release(smb_buffer);
381338c8a9a5SSteve French return rc;
381438c8a9a5SSteve French }
381538c8a9a5SSteve French
delayed_free(struct rcu_head * p)381638c8a9a5SSteve French static void delayed_free(struct rcu_head *p)
381738c8a9a5SSteve French {
381838c8a9a5SSteve French struct cifs_sb_info *cifs_sb = container_of(p, struct cifs_sb_info, rcu);
381938c8a9a5SSteve French
382038c8a9a5SSteve French unload_nls(cifs_sb->local_nls);
382138c8a9a5SSteve French smb3_cleanup_fs_context(cifs_sb->ctx);
382238c8a9a5SSteve French kfree(cifs_sb);
382338c8a9a5SSteve French }
382438c8a9a5SSteve French
382538c8a9a5SSteve French void
cifs_umount(struct cifs_sb_info * cifs_sb)382638c8a9a5SSteve French cifs_umount(struct cifs_sb_info *cifs_sb)
382738c8a9a5SSteve French {
382838c8a9a5SSteve French struct rb_root *root = &cifs_sb->tlink_tree;
382938c8a9a5SSteve French struct rb_node *node;
383038c8a9a5SSteve French struct tcon_link *tlink;
383138c8a9a5SSteve French
383238c8a9a5SSteve French cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
383338c8a9a5SSteve French
383438c8a9a5SSteve French spin_lock(&cifs_sb->tlink_tree_lock);
383538c8a9a5SSteve French while ((node = rb_first(root))) {
383638c8a9a5SSteve French tlink = rb_entry(node, struct tcon_link, tl_rbnode);
383738c8a9a5SSteve French cifs_get_tlink(tlink);
383838c8a9a5SSteve French clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
383938c8a9a5SSteve French rb_erase(node, root);
384038c8a9a5SSteve French
384138c8a9a5SSteve French spin_unlock(&cifs_sb->tlink_tree_lock);
384238c8a9a5SSteve French cifs_put_tlink(tlink);
384338c8a9a5SSteve French spin_lock(&cifs_sb->tlink_tree_lock);
384438c8a9a5SSteve French }
384538c8a9a5SSteve French spin_unlock(&cifs_sb->tlink_tree_lock);
384638c8a9a5SSteve French
384738c8a9a5SSteve French kfree(cifs_sb->prepath);
384838c8a9a5SSteve French call_rcu(&cifs_sb->rcu, delayed_free);
384938c8a9a5SSteve French }
385038c8a9a5SSteve French
385138c8a9a5SSteve French int
cifs_negotiate_protocol(const unsigned int xid,struct cifs_ses * ses,struct TCP_Server_Info * server)385238c8a9a5SSteve French cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses,
385338c8a9a5SSteve French struct TCP_Server_Info *server)
385438c8a9a5SSteve French {
385538c8a9a5SSteve French int rc = 0;
385638c8a9a5SSteve French
385738c8a9a5SSteve French if (!server->ops->need_neg || !server->ops->negotiate)
385838c8a9a5SSteve French return -ENOSYS;
385938c8a9a5SSteve French
386038c8a9a5SSteve French /* only send once per connect */
386138c8a9a5SSteve French spin_lock(&server->srv_lock);
386238c8a9a5SSteve French if (server->tcpStatus != CifsGood &&
386338c8a9a5SSteve French server->tcpStatus != CifsNew &&
386438c8a9a5SSteve French server->tcpStatus != CifsNeedNegotiate) {
386538c8a9a5SSteve French spin_unlock(&server->srv_lock);
386638c8a9a5SSteve French return -EHOSTDOWN;
386738c8a9a5SSteve French }
386838c8a9a5SSteve French
386938c8a9a5SSteve French if (!server->ops->need_neg(server) &&
387038c8a9a5SSteve French server->tcpStatus == CifsGood) {
387138c8a9a5SSteve French spin_unlock(&server->srv_lock);
387238c8a9a5SSteve French return 0;
387338c8a9a5SSteve French }
387438c8a9a5SSteve French
387538c8a9a5SSteve French server->tcpStatus = CifsInNegotiate;
387638c8a9a5SSteve French spin_unlock(&server->srv_lock);
387738c8a9a5SSteve French
387838c8a9a5SSteve French rc = server->ops->negotiate(xid, ses, server);
387938c8a9a5SSteve French if (rc == 0) {
388038c8a9a5SSteve French spin_lock(&server->srv_lock);
388138c8a9a5SSteve French if (server->tcpStatus == CifsInNegotiate)
388238c8a9a5SSteve French server->tcpStatus = CifsGood;
388338c8a9a5SSteve French else
388438c8a9a5SSteve French rc = -EHOSTDOWN;
388538c8a9a5SSteve French spin_unlock(&server->srv_lock);
388638c8a9a5SSteve French } else {
388738c8a9a5SSteve French spin_lock(&server->srv_lock);
388838c8a9a5SSteve French if (server->tcpStatus == CifsInNegotiate)
388938c8a9a5SSteve French server->tcpStatus = CifsNeedNegotiate;
389038c8a9a5SSteve French spin_unlock(&server->srv_lock);
389138c8a9a5SSteve French }
389238c8a9a5SSteve French
389338c8a9a5SSteve French return rc;
389438c8a9a5SSteve French }
389538c8a9a5SSteve French
389638c8a9a5SSteve French int
cifs_setup_session(const unsigned int xid,struct cifs_ses * ses,struct TCP_Server_Info * server,struct nls_table * nls_info)389738c8a9a5SSteve French cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
389838c8a9a5SSteve French struct TCP_Server_Info *server,
389938c8a9a5SSteve French struct nls_table *nls_info)
390038c8a9a5SSteve French {
390138c8a9a5SSteve French int rc = -ENOSYS;
3902b3773b19SSteve French struct TCP_Server_Info *pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;
390338c8a9a5SSteve French struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&pserver->dstaddr;
390438c8a9a5SSteve French struct sockaddr_in *addr = (struct sockaddr_in *)&pserver->dstaddr;
390538c8a9a5SSteve French bool is_binding = false;
390638c8a9a5SSteve French
390738c8a9a5SSteve French spin_lock(&ses->ses_lock);
390838c8a9a5SSteve French cifs_dbg(FYI, "%s: channel connect bitmap: 0x%lx\n",
390938c8a9a5SSteve French __func__, ses->chans_need_reconnect);
391038c8a9a5SSteve French
391138c8a9a5SSteve French if (ses->ses_status != SES_GOOD &&
391238c8a9a5SSteve French ses->ses_status != SES_NEW &&
391338c8a9a5SSteve French ses->ses_status != SES_NEED_RECON) {
391438c8a9a5SSteve French spin_unlock(&ses->ses_lock);
391538c8a9a5SSteve French return -EHOSTDOWN;
391638c8a9a5SSteve French }
391738c8a9a5SSteve French
391838c8a9a5SSteve French /* only send once per connect */
391938c8a9a5SSteve French spin_lock(&ses->chan_lock);
392038c8a9a5SSteve French if (CIFS_ALL_CHANS_GOOD(ses)) {
392138c8a9a5SSteve French if (ses->ses_status == SES_NEED_RECON)
392238c8a9a5SSteve French ses->ses_status = SES_GOOD;
392338c8a9a5SSteve French spin_unlock(&ses->chan_lock);
392438c8a9a5SSteve French spin_unlock(&ses->ses_lock);
392538c8a9a5SSteve French return 0;
392638c8a9a5SSteve French }
392738c8a9a5SSteve French
392838c8a9a5SSteve French cifs_chan_set_in_reconnect(ses, server);
392938c8a9a5SSteve French is_binding = !CIFS_ALL_CHANS_NEED_RECONNECT(ses);
393038c8a9a5SSteve French spin_unlock(&ses->chan_lock);
393138c8a9a5SSteve French
3932aabf4851SShyam Prasad N if (!is_binding) {
393338c8a9a5SSteve French ses->ses_status = SES_IN_SETUP;
3934aabf4851SShyam Prasad N
3935aabf4851SShyam Prasad N /* force iface_list refresh */
3936aabf4851SShyam Prasad N ses->iface_last_update = 0;
3937aabf4851SShyam Prasad N }
393838c8a9a5SSteve French spin_unlock(&ses->ses_lock);
393938c8a9a5SSteve French
394038c8a9a5SSteve French /* update ses ip_addr only for primary chan */
394138c8a9a5SSteve French if (server == pserver) {
394238c8a9a5SSteve French if (server->dstaddr.ss_family == AF_INET6)
394338c8a9a5SSteve French scnprintf(ses->ip_addr, sizeof(ses->ip_addr), "%pI6", &addr6->sin6_addr);
394438c8a9a5SSteve French else
394538c8a9a5SSteve French scnprintf(ses->ip_addr, sizeof(ses->ip_addr), "%pI4", &addr->sin_addr);
394638c8a9a5SSteve French }
394738c8a9a5SSteve French
394838c8a9a5SSteve French if (!is_binding) {
394938c8a9a5SSteve French ses->capabilities = server->capabilities;
395038c8a9a5SSteve French if (!linuxExtEnabled)
395138c8a9a5SSteve French ses->capabilities &= (~server->vals->cap_unix);
395238c8a9a5SSteve French
395338c8a9a5SSteve French if (ses->auth_key.response) {
395438c8a9a5SSteve French cifs_dbg(FYI, "Free previous auth_key.response = %p\n",
395538c8a9a5SSteve French ses->auth_key.response);
395638c8a9a5SSteve French kfree_sensitive(ses->auth_key.response);
395738c8a9a5SSteve French ses->auth_key.response = NULL;
395838c8a9a5SSteve French ses->auth_key.len = 0;
395938c8a9a5SSteve French }
396038c8a9a5SSteve French }
396138c8a9a5SSteve French
396238c8a9a5SSteve French cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
396338c8a9a5SSteve French server->sec_mode, server->capabilities, server->timeAdj);
396438c8a9a5SSteve French
396538c8a9a5SSteve French if (server->ops->sess_setup)
396638c8a9a5SSteve French rc = server->ops->sess_setup(xid, ses, server, nls_info);
396738c8a9a5SSteve French
396838c8a9a5SSteve French if (rc) {
396938c8a9a5SSteve French cifs_server_dbg(VFS, "Send error in SessSetup = %d\n", rc);
397038c8a9a5SSteve French spin_lock(&ses->ses_lock);
397138c8a9a5SSteve French if (ses->ses_status == SES_IN_SETUP)
397238c8a9a5SSteve French ses->ses_status = SES_NEED_RECON;
397338c8a9a5SSteve French spin_lock(&ses->chan_lock);
397438c8a9a5SSteve French cifs_chan_clear_in_reconnect(ses, server);
397538c8a9a5SSteve French spin_unlock(&ses->chan_lock);
397638c8a9a5SSteve French spin_unlock(&ses->ses_lock);
397738c8a9a5SSteve French } else {
397838c8a9a5SSteve French spin_lock(&ses->ses_lock);
397938c8a9a5SSteve French if (ses->ses_status == SES_IN_SETUP)
398038c8a9a5SSteve French ses->ses_status = SES_GOOD;
398138c8a9a5SSteve French spin_lock(&ses->chan_lock);
398238c8a9a5SSteve French cifs_chan_clear_in_reconnect(ses, server);
398338c8a9a5SSteve French cifs_chan_clear_need_reconnect(ses, server);
398438c8a9a5SSteve French spin_unlock(&ses->chan_lock);
398538c8a9a5SSteve French spin_unlock(&ses->ses_lock);
398638c8a9a5SSteve French }
398738c8a9a5SSteve French
398838c8a9a5SSteve French return rc;
398938c8a9a5SSteve French }
399038c8a9a5SSteve French
399138c8a9a5SSteve French static int
cifs_set_vol_auth(struct smb3_fs_context * ctx,struct cifs_ses * ses)399238c8a9a5SSteve French cifs_set_vol_auth(struct smb3_fs_context *ctx, struct cifs_ses *ses)
399338c8a9a5SSteve French {
399438c8a9a5SSteve French ctx->sectype = ses->sectype;
399538c8a9a5SSteve French
399638c8a9a5SSteve French /* krb5 is special, since we don't need username or pw */
399738c8a9a5SSteve French if (ctx->sectype == Kerberos)
399838c8a9a5SSteve French return 0;
399938c8a9a5SSteve French
400038c8a9a5SSteve French return cifs_set_cifscreds(ctx, ses);
400138c8a9a5SSteve French }
400238c8a9a5SSteve French
400338c8a9a5SSteve French static struct cifs_tcon *
__cifs_construct_tcon(struct cifs_sb_info * cifs_sb,kuid_t fsuid)4004ba55f8a9SPaulo Alcantara __cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
400538c8a9a5SSteve French {
400638c8a9a5SSteve French int rc;
400738c8a9a5SSteve French struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
400838c8a9a5SSteve French struct cifs_ses *ses;
400938c8a9a5SSteve French struct cifs_tcon *tcon = NULL;
401038c8a9a5SSteve French struct smb3_fs_context *ctx;
40119b2ee27eSPaulo Alcantara char *origin_fullpath = NULL;
401238c8a9a5SSteve French
401338c8a9a5SSteve French ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
401438c8a9a5SSteve French if (ctx == NULL)
401538c8a9a5SSteve French return ERR_PTR(-ENOMEM);
401638c8a9a5SSteve French
401738c8a9a5SSteve French ctx->local_nls = cifs_sb->local_nls;
401838c8a9a5SSteve French ctx->linux_uid = fsuid;
401938c8a9a5SSteve French ctx->cred_uid = fsuid;
402038c8a9a5SSteve French ctx->UNC = master_tcon->tree_name;
402138c8a9a5SSteve French ctx->retry = master_tcon->retry;
402238c8a9a5SSteve French ctx->nocase = master_tcon->nocase;
402338c8a9a5SSteve French ctx->nohandlecache = master_tcon->nohandlecache;
402438c8a9a5SSteve French ctx->local_lease = master_tcon->local_lease;
402538c8a9a5SSteve French ctx->no_lease = master_tcon->no_lease;
402638c8a9a5SSteve French ctx->resilient = master_tcon->use_resilient;
402738c8a9a5SSteve French ctx->persistent = master_tcon->use_persistent;
402838c8a9a5SSteve French ctx->handle_timeout = master_tcon->handle_timeout;
402938c8a9a5SSteve French ctx->no_linux_ext = !master_tcon->unix_ext;
403038c8a9a5SSteve French ctx->linux_ext = master_tcon->posix_extensions;
403138c8a9a5SSteve French ctx->sectype = master_tcon->ses->sectype;
403238c8a9a5SSteve French ctx->sign = master_tcon->ses->sign;
403338c8a9a5SSteve French ctx->seal = master_tcon->seal;
403438c8a9a5SSteve French ctx->witness = master_tcon->use_witness;
40359b2ee27eSPaulo Alcantara ctx->dfs_root_ses = master_tcon->ses->dfs_root_ses;
403638c8a9a5SSteve French
403738c8a9a5SSteve French rc = cifs_set_vol_auth(ctx, master_tcon->ses);
403838c8a9a5SSteve French if (rc) {
403938c8a9a5SSteve French tcon = ERR_PTR(rc);
404038c8a9a5SSteve French goto out;
404138c8a9a5SSteve French }
404238c8a9a5SSteve French
404338c8a9a5SSteve French /* get a reference for the same TCP session */
404438c8a9a5SSteve French spin_lock(&cifs_tcp_ses_lock);
404538c8a9a5SSteve French ++master_tcon->ses->server->srv_count;
404638c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
404738c8a9a5SSteve French
404838c8a9a5SSteve French ses = cifs_get_smb_ses(master_tcon->ses->server, ctx);
404938c8a9a5SSteve French if (IS_ERR(ses)) {
405038c8a9a5SSteve French tcon = (struct cifs_tcon *)ses;
405138c8a9a5SSteve French cifs_put_tcp_session(master_tcon->ses->server, 0);
405238c8a9a5SSteve French goto out;
405338c8a9a5SSteve French }
405438c8a9a5SSteve French
40559b2ee27eSPaulo Alcantara #ifdef CONFIG_CIFS_DFS_UPCALL
40569b2ee27eSPaulo Alcantara spin_lock(&master_tcon->tc_lock);
40579b2ee27eSPaulo Alcantara if (master_tcon->origin_fullpath) {
40589b2ee27eSPaulo Alcantara spin_unlock(&master_tcon->tc_lock);
40599b2ee27eSPaulo Alcantara origin_fullpath = dfs_get_path(cifs_sb, cifs_sb->ctx->source);
40609b2ee27eSPaulo Alcantara if (IS_ERR(origin_fullpath)) {
40619b2ee27eSPaulo Alcantara tcon = ERR_CAST(origin_fullpath);
40629b2ee27eSPaulo Alcantara origin_fullpath = NULL;
40639b2ee27eSPaulo Alcantara cifs_put_smb_ses(ses);
40649b2ee27eSPaulo Alcantara goto out;
40659b2ee27eSPaulo Alcantara }
40669b2ee27eSPaulo Alcantara } else {
40679b2ee27eSPaulo Alcantara spin_unlock(&master_tcon->tc_lock);
40689b2ee27eSPaulo Alcantara }
40699b2ee27eSPaulo Alcantara #endif
40709b2ee27eSPaulo Alcantara
407138c8a9a5SSteve French tcon = cifs_get_tcon(ses, ctx);
407238c8a9a5SSteve French if (IS_ERR(tcon)) {
407338c8a9a5SSteve French cifs_put_smb_ses(ses);
407438c8a9a5SSteve French goto out;
407538c8a9a5SSteve French }
407638c8a9a5SSteve French
40779b2ee27eSPaulo Alcantara #ifdef CONFIG_CIFS_DFS_UPCALL
40789b2ee27eSPaulo Alcantara if (origin_fullpath) {
40799b2ee27eSPaulo Alcantara spin_lock(&tcon->tc_lock);
40809b2ee27eSPaulo Alcantara tcon->origin_fullpath = origin_fullpath;
40819b2ee27eSPaulo Alcantara spin_unlock(&tcon->tc_lock);
40829b2ee27eSPaulo Alcantara origin_fullpath = NULL;
40839b2ee27eSPaulo Alcantara queue_delayed_work(dfscache_wq, &tcon->dfs_cache_work,
40849b2ee27eSPaulo Alcantara dfs_cache_get_ttl() * HZ);
40859b2ee27eSPaulo Alcantara }
40869b2ee27eSPaulo Alcantara #endif
40879b2ee27eSPaulo Alcantara
408838c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
408938c8a9a5SSteve French if (cap_unix(ses))
409038c8a9a5SSteve French reset_cifs_unix_caps(0, tcon, NULL, ctx);
409138c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
409238c8a9a5SSteve French
409338c8a9a5SSteve French out:
409438c8a9a5SSteve French kfree(ctx->username);
409538c8a9a5SSteve French kfree_sensitive(ctx->password);
40969b2ee27eSPaulo Alcantara kfree(origin_fullpath);
409738c8a9a5SSteve French kfree(ctx);
409838c8a9a5SSteve French
409938c8a9a5SSteve French return tcon;
410038c8a9a5SSteve French }
410138c8a9a5SSteve French
4102ba55f8a9SPaulo Alcantara static struct cifs_tcon *
cifs_construct_tcon(struct cifs_sb_info * cifs_sb,kuid_t fsuid)4103ba55f8a9SPaulo Alcantara cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
4104ba55f8a9SPaulo Alcantara {
4105ba55f8a9SPaulo Alcantara struct cifs_tcon *ret;
4106ba55f8a9SPaulo Alcantara
4107ba55f8a9SPaulo Alcantara cifs_mount_lock();
4108ba55f8a9SPaulo Alcantara ret = __cifs_construct_tcon(cifs_sb, fsuid);
4109ba55f8a9SPaulo Alcantara cifs_mount_unlock();
4110ba55f8a9SPaulo Alcantara return ret;
4111ba55f8a9SPaulo Alcantara }
4112ba55f8a9SPaulo Alcantara
411338c8a9a5SSteve French struct cifs_tcon *
cifs_sb_master_tcon(struct cifs_sb_info * cifs_sb)411438c8a9a5SSteve French cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
411538c8a9a5SSteve French {
411638c8a9a5SSteve French return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
411738c8a9a5SSteve French }
411838c8a9a5SSteve French
411938c8a9a5SSteve French /* find and return a tlink with given uid */
412038c8a9a5SSteve French static struct tcon_link *
tlink_rb_search(struct rb_root * root,kuid_t uid)412138c8a9a5SSteve French tlink_rb_search(struct rb_root *root, kuid_t uid)
412238c8a9a5SSteve French {
412338c8a9a5SSteve French struct rb_node *node = root->rb_node;
412438c8a9a5SSteve French struct tcon_link *tlink;
412538c8a9a5SSteve French
412638c8a9a5SSteve French while (node) {
412738c8a9a5SSteve French tlink = rb_entry(node, struct tcon_link, tl_rbnode);
412838c8a9a5SSteve French
412938c8a9a5SSteve French if (uid_gt(tlink->tl_uid, uid))
413038c8a9a5SSteve French node = node->rb_left;
413138c8a9a5SSteve French else if (uid_lt(tlink->tl_uid, uid))
413238c8a9a5SSteve French node = node->rb_right;
413338c8a9a5SSteve French else
413438c8a9a5SSteve French return tlink;
413538c8a9a5SSteve French }
413638c8a9a5SSteve French return NULL;
413738c8a9a5SSteve French }
413838c8a9a5SSteve French
413938c8a9a5SSteve French /* insert a tcon_link into the tree */
414038c8a9a5SSteve French static void
tlink_rb_insert(struct rb_root * root,struct tcon_link * new_tlink)414138c8a9a5SSteve French tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
414238c8a9a5SSteve French {
414338c8a9a5SSteve French struct rb_node **new = &(root->rb_node), *parent = NULL;
414438c8a9a5SSteve French struct tcon_link *tlink;
414538c8a9a5SSteve French
414638c8a9a5SSteve French while (*new) {
414738c8a9a5SSteve French tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
414838c8a9a5SSteve French parent = *new;
414938c8a9a5SSteve French
415038c8a9a5SSteve French if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
415138c8a9a5SSteve French new = &((*new)->rb_left);
415238c8a9a5SSteve French else
415338c8a9a5SSteve French new = &((*new)->rb_right);
415438c8a9a5SSteve French }
415538c8a9a5SSteve French
415638c8a9a5SSteve French rb_link_node(&new_tlink->tl_rbnode, parent, new);
415738c8a9a5SSteve French rb_insert_color(&new_tlink->tl_rbnode, root);
415838c8a9a5SSteve French }
415938c8a9a5SSteve French
416038c8a9a5SSteve French /*
416138c8a9a5SSteve French * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
416238c8a9a5SSteve French * current task.
416338c8a9a5SSteve French *
416438c8a9a5SSteve French * If the superblock doesn't refer to a multiuser mount, then just return
416538c8a9a5SSteve French * the master tcon for the mount.
416638c8a9a5SSteve French *
416738c8a9a5SSteve French * First, search the rbtree for an existing tcon for this fsuid. If one
416838c8a9a5SSteve French * exists, then check to see if it's pending construction. If it is then wait
416938c8a9a5SSteve French * for construction to complete. Once it's no longer pending, check to see if
417038c8a9a5SSteve French * it failed and either return an error or retry construction, depending on
417138c8a9a5SSteve French * the timeout.
417238c8a9a5SSteve French *
417338c8a9a5SSteve French * If one doesn't exist then insert a new tcon_link struct into the tree and
417438c8a9a5SSteve French * try to construct a new one.
417538c8a9a5SSteve French */
417638c8a9a5SSteve French struct tcon_link *
cifs_sb_tlink(struct cifs_sb_info * cifs_sb)417738c8a9a5SSteve French cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
417838c8a9a5SSteve French {
417938c8a9a5SSteve French int ret;
418038c8a9a5SSteve French kuid_t fsuid = current_fsuid();
418138c8a9a5SSteve French struct tcon_link *tlink, *newtlink;
418238c8a9a5SSteve French
418338c8a9a5SSteve French if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
418438c8a9a5SSteve French return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
418538c8a9a5SSteve French
418638c8a9a5SSteve French spin_lock(&cifs_sb->tlink_tree_lock);
418738c8a9a5SSteve French tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
418838c8a9a5SSteve French if (tlink)
418938c8a9a5SSteve French cifs_get_tlink(tlink);
419038c8a9a5SSteve French spin_unlock(&cifs_sb->tlink_tree_lock);
419138c8a9a5SSteve French
419238c8a9a5SSteve French if (tlink == NULL) {
419338c8a9a5SSteve French newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
419438c8a9a5SSteve French if (newtlink == NULL)
419538c8a9a5SSteve French return ERR_PTR(-ENOMEM);
419638c8a9a5SSteve French newtlink->tl_uid = fsuid;
419738c8a9a5SSteve French newtlink->tl_tcon = ERR_PTR(-EACCES);
419838c8a9a5SSteve French set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
419938c8a9a5SSteve French set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
420038c8a9a5SSteve French cifs_get_tlink(newtlink);
420138c8a9a5SSteve French
420238c8a9a5SSteve French spin_lock(&cifs_sb->tlink_tree_lock);
420338c8a9a5SSteve French /* was one inserted after previous search? */
420438c8a9a5SSteve French tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
420538c8a9a5SSteve French if (tlink) {
420638c8a9a5SSteve French cifs_get_tlink(tlink);
420738c8a9a5SSteve French spin_unlock(&cifs_sb->tlink_tree_lock);
420838c8a9a5SSteve French kfree(newtlink);
420938c8a9a5SSteve French goto wait_for_construction;
421038c8a9a5SSteve French }
421138c8a9a5SSteve French tlink = newtlink;
421238c8a9a5SSteve French tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
421338c8a9a5SSteve French spin_unlock(&cifs_sb->tlink_tree_lock);
421438c8a9a5SSteve French } else {
421538c8a9a5SSteve French wait_for_construction:
421638c8a9a5SSteve French ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
421738c8a9a5SSteve French TASK_INTERRUPTIBLE);
421838c8a9a5SSteve French if (ret) {
421938c8a9a5SSteve French cifs_put_tlink(tlink);
422038c8a9a5SSteve French return ERR_PTR(-ERESTARTSYS);
422138c8a9a5SSteve French }
422238c8a9a5SSteve French
422338c8a9a5SSteve French /* if it's good, return it */
422438c8a9a5SSteve French if (!IS_ERR(tlink->tl_tcon))
422538c8a9a5SSteve French return tlink;
422638c8a9a5SSteve French
422738c8a9a5SSteve French /* return error if we tried this already recently */
422838c8a9a5SSteve French if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
422938c8a9a5SSteve French cifs_put_tlink(tlink);
423038c8a9a5SSteve French return ERR_PTR(-EACCES);
423138c8a9a5SSteve French }
423238c8a9a5SSteve French
423338c8a9a5SSteve French if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
423438c8a9a5SSteve French goto wait_for_construction;
423538c8a9a5SSteve French }
423638c8a9a5SSteve French
423738c8a9a5SSteve French tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
423838c8a9a5SSteve French clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
423938c8a9a5SSteve French wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
424038c8a9a5SSteve French
424138c8a9a5SSteve French if (IS_ERR(tlink->tl_tcon)) {
424238c8a9a5SSteve French cifs_put_tlink(tlink);
424338c8a9a5SSteve French return ERR_PTR(-EACCES);
424438c8a9a5SSteve French }
424538c8a9a5SSteve French
424638c8a9a5SSteve French return tlink;
424738c8a9a5SSteve French }
424838c8a9a5SSteve French
424938c8a9a5SSteve French /*
425038c8a9a5SSteve French * periodic workqueue job that scans tcon_tree for a superblock and closes
425138c8a9a5SSteve French * out tcons.
425238c8a9a5SSteve French */
425338c8a9a5SSteve French static void
cifs_prune_tlinks(struct work_struct * work)425438c8a9a5SSteve French cifs_prune_tlinks(struct work_struct *work)
425538c8a9a5SSteve French {
425638c8a9a5SSteve French struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
425738c8a9a5SSteve French prune_tlinks.work);
425838c8a9a5SSteve French struct rb_root *root = &cifs_sb->tlink_tree;
425938c8a9a5SSteve French struct rb_node *node;
426038c8a9a5SSteve French struct rb_node *tmp;
426138c8a9a5SSteve French struct tcon_link *tlink;
426238c8a9a5SSteve French
426338c8a9a5SSteve French /*
426438c8a9a5SSteve French * Because we drop the spinlock in the loop in order to put the tlink
426538c8a9a5SSteve French * it's not guarded against removal of links from the tree. The only
426638c8a9a5SSteve French * places that remove entries from the tree are this function and
426738c8a9a5SSteve French * umounts. Because this function is non-reentrant and is canceled
426838c8a9a5SSteve French * before umount can proceed, this is safe.
426938c8a9a5SSteve French */
427038c8a9a5SSteve French spin_lock(&cifs_sb->tlink_tree_lock);
427138c8a9a5SSteve French node = rb_first(root);
427238c8a9a5SSteve French while (node != NULL) {
427338c8a9a5SSteve French tmp = node;
427438c8a9a5SSteve French node = rb_next(tmp);
427538c8a9a5SSteve French tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
427638c8a9a5SSteve French
427738c8a9a5SSteve French if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
427838c8a9a5SSteve French atomic_read(&tlink->tl_count) != 0 ||
427938c8a9a5SSteve French time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
428038c8a9a5SSteve French continue;
428138c8a9a5SSteve French
428238c8a9a5SSteve French cifs_get_tlink(tlink);
428338c8a9a5SSteve French clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
428438c8a9a5SSteve French rb_erase(tmp, root);
428538c8a9a5SSteve French
428638c8a9a5SSteve French spin_unlock(&cifs_sb->tlink_tree_lock);
428738c8a9a5SSteve French cifs_put_tlink(tlink);
428838c8a9a5SSteve French spin_lock(&cifs_sb->tlink_tree_lock);
428938c8a9a5SSteve French }
429038c8a9a5SSteve French spin_unlock(&cifs_sb->tlink_tree_lock);
429138c8a9a5SSteve French
429238c8a9a5SSteve French queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
429338c8a9a5SSteve French TLINK_IDLE_EXPIRE);
429438c8a9a5SSteve French }
429538c8a9a5SSteve French
429638c8a9a5SSteve French #ifndef CONFIG_CIFS_DFS_UPCALL
cifs_tree_connect(const unsigned int xid,struct cifs_tcon * tcon,const struct nls_table * nlsc)429738c8a9a5SSteve French int cifs_tree_connect(const unsigned int xid, struct cifs_tcon *tcon, const struct nls_table *nlsc)
429838c8a9a5SSteve French {
429938c8a9a5SSteve French int rc;
430038c8a9a5SSteve French const struct smb_version_operations *ops = tcon->ses->server->ops;
430138c8a9a5SSteve French
430238c8a9a5SSteve French /* only send once per connect */
430338c8a9a5SSteve French spin_lock(&tcon->tc_lock);
4304cd743cfeSShyam Prasad N
4305cd743cfeSShyam Prasad N /* if tcon is marked for needing reconnect, update state */
4306cd743cfeSShyam Prasad N if (tcon->need_reconnect)
4307cd743cfeSShyam Prasad N tcon->status = TID_NEED_TCON;
4308cd743cfeSShyam Prasad N
430991f4480cSShyam Prasad N if (tcon->status == TID_GOOD) {
431091f4480cSShyam Prasad N spin_unlock(&tcon->tc_lock);
431191f4480cSShyam Prasad N return 0;
431291f4480cSShyam Prasad N }
431391f4480cSShyam Prasad N
431438c8a9a5SSteve French if (tcon->status != TID_NEW &&
431538c8a9a5SSteve French tcon->status != TID_NEED_TCON) {
431638c8a9a5SSteve French spin_unlock(&tcon->tc_lock);
431738c8a9a5SSteve French return -EHOSTDOWN;
431838c8a9a5SSteve French }
431938c8a9a5SSteve French
432038c8a9a5SSteve French tcon->status = TID_IN_TCON;
432138c8a9a5SSteve French spin_unlock(&tcon->tc_lock);
432238c8a9a5SSteve French
432338c8a9a5SSteve French rc = ops->tree_connect(xid, tcon->ses, tcon->tree_name, tcon, nlsc);
432438c8a9a5SSteve French if (rc) {
432538c8a9a5SSteve French spin_lock(&tcon->tc_lock);
432638c8a9a5SSteve French if (tcon->status == TID_IN_TCON)
432738c8a9a5SSteve French tcon->status = TID_NEED_TCON;
432838c8a9a5SSteve French spin_unlock(&tcon->tc_lock);
432938c8a9a5SSteve French } else {
433038c8a9a5SSteve French spin_lock(&tcon->tc_lock);
433138c8a9a5SSteve French if (tcon->status == TID_IN_TCON)
433238c8a9a5SSteve French tcon->status = TID_GOOD;
433338c8a9a5SSteve French tcon->need_reconnect = false;
433438c8a9a5SSteve French spin_unlock(&tcon->tc_lock);
433538c8a9a5SSteve French }
433638c8a9a5SSteve French
433738c8a9a5SSteve French return rc;
433838c8a9a5SSteve French }
433938c8a9a5SSteve French #endif
4340