Merge tag '6.3-rc-smb3-client-fixes-part2' of git://git.samba.org/sfrench/cifs-2.6 (3162745a) · Commits · EulixOS / Software / Kernel

fs/cifs/cifsproto.h

+16 −5

Original line number	Diff line number	Diff line
		@@ -667,11 +667,21 @@ static inline int get_dfs_path(const unsigned int xid, struct cifs_ses *ses,
		int match_target_ip(struct TCP_Server_Info *server,
		const char *share, size_t share_len,
		bool *result);

		int cifs_dfs_query_info_nonascii_quirk(const unsigned int xid,
		int cifs_inval_name_dfs_link_error(const unsigned int xid,
		struct cifs_tcon *tcon,
		struct cifs_sb_info *cifs_sb,
		const char *full_path,
		bool *islink);
		#else
		static inline int cifs_inval_name_dfs_link_error(const unsigned int xid,
		struct cifs_tcon *tcon,
		struct cifs_sb_info *cifs_sb,
		const char *dfs_link_path);
		const char *full_path,
		bool *islink)
		{
		*islink = false;
		return 0;
		}
		#endif

		static inline int cifs_create_options(struct cifs_sb_info *cifs_sb, int options)
		@@ -684,5 +694,6 @@ static inline int cifs_create_options(struct cifs_sb_info *cifs_sb, int options)

		struct super_block cifs_get_tcon_super(struct cifs_tcon tcon);
		void cifs_put_tcon_super(struct super_block *sb);
		int cifs_wait_for_server_reconnect(struct TCP_Server_Info *server, bool retry);

		#endif /* _CIFSPROTO_H */

fs/cifs/cifssmb.c

+3 −40

Original line number	Diff line number	Diff line
		@@ -72,7 +72,6 @@ cifs_reconnect_tcon(struct cifs_tcon *tcon, int smb_command)
		struct cifs_ses *ses;
		struct TCP_Server_Info *server;
		struct nls_table *nls_codepage;
		int retries;

		/*
		* SMBs NegProt, SessSetup, uLogoff do not have tcon yet so check for
		@@ -102,45 +101,9 @@ cifs_reconnect_tcon(struct cifs_tcon *tcon, int smb_command)
		}
		spin_unlock(&tcon->tc_lock);

		retries = server->nr_targets;

		/*
		* Give demultiplex thread up to 10 seconds to each target available for
		* reconnect -- should be greater than cifs socket timeout which is 7
		* seconds.
		*/
		while (server->tcpStatus == CifsNeedReconnect) {
		rc = wait_event_interruptible_timeout(server->response_q,
		(server->tcpStatus != CifsNeedReconnect),
		10 * HZ);
		if (rc < 0) {
		cifs_dbg(FYI, "%s: aborting reconnect due to a received signal by the process\n",
		__func__);
		return -ERESTARTSYS;
		}

		/* are we still trying to reconnect? */
		spin_lock(&server->srv_lock);
		if (server->tcpStatus != CifsNeedReconnect) {
		spin_unlock(&server->srv_lock);
		break;
		}
		spin_unlock(&server->srv_lock);

		if (retries && --retries)
		continue;

		/*
		* on "soft" mounts we wait once. Hard mounts keep
		* retrying until process is killed or server comes
		* back on-line
		*/
		if (!tcon->retry) {
		cifs_dbg(FYI, "gave up waiting on reconnect in smb_init\n");
		return -EHOSTDOWN;
		}
		retries = server->nr_targets;
		}
		rc = cifs_wait_for_server_reconnect(server, tcon->retry);
		if (rc)
		return rc;

		spin_lock(&ses->chan_lock);
		if (!cifs_chan_needs_reconnect(ses, server) && !tcon->need_reconnect) {

fs/cifs/connect.c

+4 −27

Original line number	Diff line number	Diff line
		@@ -1294,7 +1294,8 @@ cifs_match_ipaddr(struct sockaddr srcaddr, struct sockaddr rhs)
		case AF_INET6: {
		struct sockaddr_in6 saddr6 = (struct sockaddr_in6 )srcaddr;
		struct sockaddr_in6 vaddr6 = (struct sockaddr_in6 )rhs;
		return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
		return (ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr)
		&& saddr6->sin6_scope_id == vaddr6->sin6_scope_id);
		}
		default:
		WARN_ON(1);
		@@ -1343,32 +1344,8 @@ match_port(struct TCP_Server_Info server, struct sockaddr addr)

		static bool match_server_address(struct TCP_Server_Info server, struct sockaddr addr)
		{
		switch (addr->sa_family) {
		case AF_INET: {
		struct sockaddr_in addr4 = (struct sockaddr_in )addr;
		struct sockaddr_in *srv_addr4 =
		(struct sockaddr_in *)&server->dstaddr;

		if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
		return false;
		break;
		}
		case AF_INET6: {
		struct sockaddr_in6 addr6 = (struct sockaddr_in6 )addr;
		struct sockaddr_in6 *srv_addr6 =
		(struct sockaddr_in6 *)&server->dstaddr;

		if (!ipv6_addr_equal(&addr6->sin6_addr,
		&srv_addr6->sin6_addr))
		if (!cifs_match_ipaddr(addr, (struct sockaddr *)&server->dstaddr))
		return false;
		if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
		return false;
		break;
		}
		default:
		WARN_ON(1);
		return false; /* don't expect to be here */
		}

		return true;
		}

fs/cifs/file.c

+9 −2

Original line number	Diff line number	Diff line
		@@ -52,6 +52,8 @@ static void cifs_undirty_folios(struct inode *inode, loff_t start, unsigned int

		end = (start + len - 1) / PAGE_SIZE;
		xas_for_each_marked(&xas, folio, end, PAGECACHE_TAG_DIRTY) {
		if (xas_retry(&xas, folio))
		continue;
		xas_pause(&xas);
		rcu_read_unlock();
		folio_lock(folio);
		@@ -81,6 +83,8 @@ void cifs_pages_written_back(struct inode *inode, loff_t start, unsigned int len

		end = (start + len - 1) / PAGE_SIZE;
		xas_for_each(&xas, folio, end) {
		if (xas_retry(&xas, folio))
		continue;
		if (!folio_test_writeback(folio)) {
		WARN_ONCE(1, "bad %x @%llx page %lx %lx\n",
		len, start, folio_index(folio), end);
		@@ -112,6 +116,8 @@ void cifs_pages_write_failed(struct inode *inode, loff_t start, unsigned int len

		end = (start + len - 1) / PAGE_SIZE;
		xas_for_each(&xas, folio, end) {
		if (xas_retry(&xas, folio))
		continue;
		if (!folio_test_writeback(folio)) {
		WARN_ONCE(1, "bad %x @%llx page %lx %lx\n",
		len, start, folio_index(folio), end);
		@@ -2839,6 +2845,7 @@ static ssize_t cifs_write_back_from_locked_folio(struct address_space *mapping,
		free_xid(xid);
		if (rc == 0) {
		wbc->nr_to_write = count;
		rc = len;
		} else if (is_retryable_error(rc)) {
		cifs_pages_write_redirty(inode, start, len);
		} else {
		@@ -3605,7 +3612,7 @@ static ssize_t __cifs_writev(

		ctx->nr_pinned_pages = rc;
		ctx->bv = (void *)ctx->iter.bvec;
		ctx->bv_need_unpin = iov_iter_extract_will_pin(&ctx->iter);
		ctx->bv_need_unpin = iov_iter_extract_will_pin(from);
		} else if ((iov_iter_is_bvec(from) \|\| iov_iter_is_kvec(from)) &&
		!is_sync_kiocb(iocb)) {
		/*
		@@ -4141,7 +4148,7 @@ static ssize_t __cifs_readv(

		ctx->nr_pinned_pages = rc;
		ctx->bv = (void *)ctx->iter.bvec;
		ctx->bv_need_unpin = iov_iter_extract_will_pin(&ctx->iter);
		ctx->bv_need_unpin = iov_iter_extract_will_pin(to);
		ctx->should_dirty = true;
		} else if ((iov_iter_is_bvec(to) \|\| iov_iter_is_kvec(to)) &&
		!is_sync_kiocb(iocb)) {

fs/cifs/misc.c

+111 −0

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@
		#include "cifsfs.h"
		#ifdef CONFIG_CIFS_DFS_UPCALL
		#include "dns_resolve.h"
		#include "dfs_cache.h"
		#endif
		#include "fs_context.h"
		#include "cached_dir.h"
		@@ -1198,4 +1199,114 @@ int cifs_update_super_prepath(struct cifs_sb_info cifs_sb, char prefix)
		cifs_sb->mnt_cifs_flags \|= CIFS_MOUNT_USE_PREFIX_PATH;
		return 0;
		}

		/*
		* Handle weird Windows SMB server behaviour. It responds with
		* STATUS_OBJECT_NAME_INVALID code to SMB2 QUERY_INFO request for
		* "\<server>\<dfsname>\<linkpath>" DFS reference, where <dfsname> contains
		* non-ASCII unicode symbols.
		*/
		int cifs_inval_name_dfs_link_error(const unsigned int xid,
		struct cifs_tcon *tcon,
		struct cifs_sb_info *cifs_sb,
		const char *full_path,
		bool *islink)
		{
		struct cifs_ses *ses = tcon->ses;
		size_t len;
		char *path;
		char *ref_path;

		*islink = false;

		/*
		* Fast path - skip check when @full_path doesn't have a prefix path to
		* look up or tcon is not DFS.
		*/
		if (strlen(full_path) < 2 \|\| !cifs_sb \|\|
		(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS) \|\|
		!is_tcon_dfs(tcon) \|\| !ses->server->origin_fullpath)
		return 0;

		/*
		* Slow path - tcon is DFS and @full_path has prefix path, so attempt
		* to get a referral to figure out whether it is an DFS link.
		*/
		len = strnlen(tcon->tree_name, MAX_TREE_SIZE + 1) + strlen(full_path) + 1;
		path = kmalloc(len, GFP_KERNEL);
		if (!path)
		return -ENOMEM;

		scnprintf(path, len, "%s%s", tcon->tree_name, full_path);
		ref_path = dfs_cache_canonical_path(path + 1, cifs_sb->local_nls,
		cifs_remap(cifs_sb));
		kfree(path);

		if (IS_ERR(ref_path)) {
		if (PTR_ERR(ref_path) != -EINVAL)
		return PTR_ERR(ref_path);
		} else {
		struct dfs_info3_param *refs = NULL;
		int num_refs = 0;

		/*
		* XXX: we are not using dfs_cache_find() here because we might
		* end filling all the DFS cache and thus potentially
		* removing cached DFS targets that the client would eventually
		* need during failover.
		*/
		if (ses->server->ops->get_dfs_refer &&
		!ses->server->ops->get_dfs_refer(xid, ses, ref_path, &refs,
		&num_refs, cifs_sb->local_nls,
		cifs_remap(cifs_sb)))
		*islink = refs[0].server_type == DFS_TYPE_LINK;
		free_dfs_info_array(refs, num_refs);
		kfree(ref_path);
		}
		return 0;
		}
		#endif

		int cifs_wait_for_server_reconnect(struct TCP_Server_Info *server, bool retry)
		{
		int timeout = 10;
		int rc;

		spin_lock(&server->srv_lock);
		if (server->tcpStatus != CifsNeedReconnect) {
		spin_unlock(&server->srv_lock);
		return 0;
		}
		timeout *= server->nr_targets;
		spin_unlock(&server->srv_lock);

		/*
		* Give demultiplex thread up to 10 seconds to each target available for
		* reconnect -- should be greater than cifs socket timeout which is 7
		* seconds.
		*
		* On "soft" mounts we wait once. Hard mounts keep retrying until
		* process is killed or server comes back on-line.
		*/
		do {
		rc = wait_event_interruptible_timeout(server->response_q,
		(server->tcpStatus != CifsNeedReconnect),
		timeout * HZ);
		if (rc < 0) {
		cifs_dbg(FYI, "%s: aborting reconnect due to received signal\n",
		__func__);
		return -ERESTARTSYS;
		}

		/* are we still trying to reconnect? */
		spin_lock(&server->srv_lock);
		if (server->tcpStatus != CifsNeedReconnect) {
		spin_unlock(&server->srv_lock);
		return 0;
		}
		spin_unlock(&server->srv_lock);
		} while (retry);

		cifs_dbg(FYI, "%s: gave up waiting on reconnect\n", __func__);
		return -EHOSTDOWN;
		}