cifs: Add constructor/destructors for tcon->cfid (a63ec83c) · Commits · EulixOS / Software / Kernel

fs/cifs/cached_dir.c

+67 −43

Original line number	Original line	Diff line number	Diff line
	@@ -18,7 +18,7 @@
	int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,		int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,
	const char *path,		const char *path,
	struct cifs_sb_info *cifs_sb,		struct cifs_sb_info *cifs_sb,
	struct cached_fid **cfid)		struct cached_fid **ret_cfid)
	{		{
	struct cifs_ses *ses;		struct cifs_ses *ses;
	struct TCP_Server_Info *server;		struct TCP_Server_Info *server;
	@@ -35,6 +35,7 @@ int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,
	u8 oplock = SMB2_OPLOCK_LEVEL_II;		u8 oplock = SMB2_OPLOCK_LEVEL_II;
	struct cifs_fid *pfid;		struct cifs_fid *pfid;
	struct dentry *dentry;		struct dentry *dentry;
			struct cached_fid *cfid;

	if (tcon == NULL \|\| tcon->nohandlecache \|\|		if (tcon == NULL \|\| tcon->nohandlecache \|\|
	is_smb1_server(tcon->ses->server))		is_smb1_server(tcon->ses->server))
	@@ -51,12 +52,13 @@ int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,

	dentry = cifs_sb->root;		dentry = cifs_sb->root;

	mutex_lock(&tcon->cfid.fid_mutex);		cfid = tcon->cfid;
	if (tcon->cfid.is_valid) {		mutex_lock(&cfid->fid_mutex);
			if (cfid->is_valid) {
	cifs_dbg(FYI, "found a cached root file handle\n");		cifs_dbg(FYI, "found a cached root file handle\n");
	*cfid = &tcon->cfid;		*ret_cfid = cfid;
	kref_get(&tcon->cfid.refcount);		kref_get(&cfid->refcount);
	mutex_unlock(&tcon->cfid.fid_mutex);		mutex_unlock(&cfid->fid_mutex);
	return 0;		return 0;
	}		}

	@@ -67,7 +69,7 @@ int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,
	* thus causing a deadlock		* thus causing a deadlock
	*/		*/

	mutex_unlock(&tcon->cfid.fid_mutex);		mutex_unlock(&cfid->fid_mutex);

	if (smb3_encryption_required(tcon))		if (smb3_encryption_required(tcon))
	flags \|= CIFS_TRANSFORM_REQ;		flags \|= CIFS_TRANSFORM_REQ;
	@@ -75,7 +77,7 @@ int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,
	if (!server->ops->new_lease_key)		if (!server->ops->new_lease_key)
	return -EIO;		return -EIO;

	pfid = tcon->cfid.fid;		pfid = &cfid->fid;
	server->ops->new_lease_key(pfid);		server->ops->new_lease_key(pfid);

	memset(rqst, 0, sizeof(rqst));		memset(rqst, 0, sizeof(rqst));
	@@ -118,14 +120,14 @@ int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,
	rc = compound_send_recv(xid, ses, server,		rc = compound_send_recv(xid, ses, server,
	flags, 2, rqst,		flags, 2, rqst,
	resp_buftype, rsp_iov);		resp_buftype, rsp_iov);
	mutex_lock(&tcon->cfid.fid_mutex);		mutex_lock(&cfid->fid_mutex);

	/*		/*
	* Now we need to check again as the cached root might have		* Now we need to check again as the cached root might have
	* been successfully re-opened from a concurrent process		* been successfully re-opened from a concurrent process
	*/		*/

	if (tcon->cfid.is_valid) {		if (cfid->is_valid) {
	/* work was already done */		/* work was already done */

	/* stash fids for close() later */		/* stash fids for close() later */
	@@ -138,9 +140,9 @@ int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,
	* caller expects this func to set the fid in cfid to valid		* caller expects this func to set the fid in cfid to valid
	* cached root, so increment the refcount.		* cached root, so increment the refcount.
	*/		*/
	kref_get(&tcon->cfid.refcount);		kref_get(&cfid->refcount);

	mutex_unlock(&tcon->cfid.fid_mutex);		mutex_unlock(&cfid->fid_mutex);

	if (rc == 0) {		if (rc == 0) {
	/* close extra handle outside of crit sec */		/* close extra handle outside of crit sec */
	@@ -170,11 +172,11 @@ int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,
	oparms.fid->mid = le64_to_cpu(o_rsp->hdr.MessageId);		oparms.fid->mid = le64_to_cpu(o_rsp->hdr.MessageId);
	#endif /* CIFS_DEBUG2 */		#endif /* CIFS_DEBUG2 */

	tcon->cfid.tcon = tcon;		cfid->tcon = tcon;
	tcon->cfid.is_valid = true;		cfid->is_valid = true;
	tcon->cfid.dentry = dentry;		cfid->dentry = dentry;
	dget(dentry);		dget(dentry);
	kref_init(&tcon->cfid.refcount);		kref_init(&cfid->refcount);

	/* BB TBD check to see if oplock level check can be removed below */		/* BB TBD check to see if oplock level check can be removed below */
	if (o_rsp->OplockLevel == SMB2_OPLOCK_LEVEL_LEASE) {		if (o_rsp->OplockLevel == SMB2_OPLOCK_LEVEL_LEASE) {
	@@ -182,8 +184,8 @@ int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,
	* See commit 2f94a3125b87. Increment the refcount when we		* See commit 2f94a3125b87. Increment the refcount when we
	* get a lease for root, release it if lease break occurs		* get a lease for root, release it if lease break occurs
	*/		*/
	kref_get(&tcon->cfid.refcount);		kref_get(&cfid->refcount);
	tcon->cfid.has_lease = true;		cfid->has_lease = true;
	smb2_parse_contexts(server, o_rsp,		smb2_parse_contexts(server, o_rsp,
	&oparms.fid->epoch,		&oparms.fid->epoch,
	oparms.fid->lease_key, &oplock,		oparms.fid->lease_key, &oplock,
	@@ -198,37 +200,41 @@ int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,
	le16_to_cpu(qi_rsp->OutputBufferOffset),		le16_to_cpu(qi_rsp->OutputBufferOffset),
	sizeof(struct smb2_file_all_info),		sizeof(struct smb2_file_all_info),
	&rsp_iov[1], sizeof(struct smb2_file_all_info),		&rsp_iov[1], sizeof(struct smb2_file_all_info),
	(char *)&tcon->cfid.file_all_info))		(char *)&cfid->file_all_info))
	tcon->cfid.file_all_info_is_valid = true;		cfid->file_all_info_is_valid = true;
	tcon->cfid.time = jiffies;

			cfid->time = jiffies;

	oshr_exit:		oshr_exit:
	mutex_unlock(&tcon->cfid.fid_mutex);		mutex_unlock(&cfid->fid_mutex);
	oshr_free:		oshr_free:
	SMB2_open_free(&rqst[0]);		SMB2_open_free(&rqst[0]);
	SMB2_query_info_free(&rqst[1]);		SMB2_query_info_free(&rqst[1]);
	free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);		free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);
	free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);		free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);
	if (rc == 0)		if (rc == 0)
	*cfid = &tcon->cfid;		*ret_cfid = cfid;

	return rc;		return rc;
	}		}

	int open_cached_dir_by_dentry(struct cifs_tcon *tcon,		int open_cached_dir_by_dentry(struct cifs_tcon *tcon,
	struct dentry *dentry,		struct dentry *dentry,
	struct cached_fid **cfid)		struct cached_fid **ret_cfid)
	{		{
	mutex_lock(&tcon->cfid.fid_mutex);		struct cached_fid *cfid;
	if (tcon->cfid.dentry == dentry) {
			cfid = tcon->cfid;

			mutex_lock(&cfid->fid_mutex);
			if (cfid->dentry == dentry) {
	cifs_dbg(FYI, "found a cached root file handle by dentry\n");		cifs_dbg(FYI, "found a cached root file handle by dentry\n");
	*cfid = &tcon->cfid;		*ret_cfid = cfid;
	kref_get(&tcon->cfid.refcount);		kref_get(&cfid->refcount);
	mutex_unlock(&tcon->cfid.fid_mutex);		mutex_unlock(&cfid->fid_mutex);
	return 0;		return 0;
	}		}
	mutex_unlock(&tcon->cfid.fid_mutex);		mutex_unlock(&cfid->fid_mutex);
	return -ENOENT;		return -ENOENT;
	}		}

	@@ -241,8 +247,8 @@ smb2_close_cached_fid(struct kref *ref)

	if (cfid->is_valid) {		if (cfid->is_valid) {
	cifs_dbg(FYI, "clear cached root file handle\n");		cifs_dbg(FYI, "clear cached root file handle\n");
	SMB2_close(0, cfid->tcon, cfid->fid->persistent_fid,		SMB2_close(0, cfid->tcon, cfid->fid.persistent_fid,
	cfid->fid->volatile_fid);		cfid->fid.volatile_fid);
	}		}

	/*		/*
	@@ -312,7 +318,7 @@ void close_all_cached_dirs(struct cifs_sb_info *cifs_sb)
	tcon = tlink_tcon(tlink);		tcon = tlink_tcon(tlink);
	if (IS_ERR(tcon))		if (IS_ERR(tcon))
	continue;		continue;
	cfid = &tcon->cfid;		cfid = tcon->cfid;
	mutex_lock(&cfid->fid_mutex);		mutex_lock(&cfid->fid_mutex);
	if (cfid->dentry) {		if (cfid->dentry) {
	dput(cfid->dentry);		dput(cfid->dentry);
	@@ -328,12 +334,12 @@ void close_all_cached_dirs(struct cifs_sb_info *cifs_sb)
	*/		*/
	void invalidate_all_cached_dirs(struct cifs_tcon *tcon)		void invalidate_all_cached_dirs(struct cifs_tcon *tcon)
	{		{
	mutex_lock(&tcon->cfid.fid_mutex);		mutex_lock(&tcon->cfid->fid_mutex);
	tcon->cfid.is_valid = false;		tcon->cfid->is_valid = false;
	/* cached handle is not valid, so SMB2_CLOSE won't be sent below */		/* cached handle is not valid, so SMB2_CLOSE won't be sent below */
	close_cached_dir_lease_locked(&tcon->cfid);		close_cached_dir_lease_locked(tcon->cfid);
	memset(tcon->cfid.fid, 0, sizeof(struct cifs_fid));		memset(&tcon->cfid->fid, 0, sizeof(struct cifs_fid));
	mutex_unlock(&tcon->cfid.fid_mutex);		mutex_unlock(&tcon->cfid->fid_mutex);
	}		}

	static void		static void
	@@ -347,16 +353,34 @@ smb2_cached_lease_break(struct work_struct *work)

	int cached_dir_lease_break(struct cifs_tcon *tcon, __u8 lease_key[16])		int cached_dir_lease_break(struct cifs_tcon *tcon, __u8 lease_key[16])
	{		{
	if (tcon->cfid.is_valid &&		if (tcon->cfid->is_valid &&
	!memcmp(lease_key,		!memcmp(lease_key,
	tcon->cfid.fid->lease_key,		tcon->cfid->fid.lease_key,
	SMB2_LEASE_KEY_SIZE)) {		SMB2_LEASE_KEY_SIZE)) {
	tcon->cfid.time = 0;		tcon->cfid->time = 0;
	INIT_WORK(&tcon->cfid.lease_break,		INIT_WORK(&tcon->cfid->lease_break,
	smb2_cached_lease_break);		smb2_cached_lease_break);
	queue_work(cifsiod_wq,		queue_work(cifsiod_wq,
	&tcon->cfid.lease_break);		&tcon->cfid->lease_break);
	return true;		return true;
	}		}
	return false;		return false;
	}		}

			struct cached_fid *init_cached_dir(void)
			{
			struct cached_fid *cfid;

			cfid = kzalloc(sizeof(*cfid), GFP_KERNEL);
			if (!cfid)
			return NULL;
			INIT_LIST_HEAD(&cfid->dirents.entries);
			mutex_init(&cfid->dirents.de_mutex);
			mutex_init(&cfid->fid_mutex);
			return cfid;
			}

			void free_cached_dir(struct cifs_tcon *tcon)
			{
			kfree(tcon->cfid);
			}

fs/cifs/cached_dir.h

+38 −0

Original line number	Original line	Diff line number	Diff line
	@@ -9,6 +9,44 @@
	#define _CACHED_DIR_H		#define _CACHED_DIR_H


			struct cached_dirent {
			struct list_head entry;
			char *name;
			int namelen;
			loff_t pos;

			struct cifs_fattr fattr;
			};

			struct cached_dirents {
			bool is_valid:1;
			bool is_failed:1;
			struct dir_context ctx; /
			* Only used to make sure we only take entries
			* from a single context. Never dereferenced.
			*/
			struct mutex de_mutex;
			int pos; /* Expected ctx->pos */
			struct list_head entries;
			};

			struct cached_fid {
			bool is_valid:1; /* Do we have a useable root fid */
			bool file_all_info_is_valid:1;
			bool has_lease:1;
			unsigned long time; /* jiffies of when lease was taken */
			struct kref refcount;
			struct cifs_fid fid;
			struct mutex fid_mutex;
			struct cifs_tcon *tcon;
			struct dentry *dentry;
			struct work_struct lease_break;
			struct smb2_file_all_info file_all_info;
			struct cached_dirents dirents;
			};

			extern struct cached_fid *init_cached_dir(void);
			extern void free_cached_dir(struct cifs_tcon *tcon);
	extern int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,		extern int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,
	const char *path,		const char *path,
	struct cifs_sb_info *cifs_sb,		struct cifs_sb_info *cifs_sb,

fs/cifs/cifsglob.h

+1 −37

Original line number	Original line	Diff line number	Diff line
	@@ -1128,42 +1128,6 @@ struct cifs_fattr {
	u32 cf_cifstag;		u32 cf_cifstag;
	};		};

	struct cached_dirent {
	struct list_head entry;
	char *name;
	int namelen;
	loff_t pos;

	struct cifs_fattr fattr;
	};

	struct cached_dirents {
	bool is_valid:1;
	bool is_failed:1;
	struct dir_context ctx; /
	* Only used to make sure we only take entries
	* from a single context. Never dereferenced.
	*/
	struct mutex de_mutex;
	int pos; /* Expected ctx->pos */
	struct list_head entries;
	};

	struct cached_fid {
	bool is_valid:1; /* Do we have a useable root fid */
	bool file_all_info_is_valid:1;
	bool has_lease:1;
	unsigned long time; /* jiffies of when lease was taken */
	struct kref refcount;
	struct cifs_fid *fid;
	struct mutex fid_mutex;
	struct cifs_tcon *tcon;
	struct dentry *dentry;
	struct work_struct lease_break;
	struct smb2_file_all_info file_all_info;
	struct cached_dirents dirents;
	};

	/*		/*
	* there is one of these for each connection to a resource on a particular		* there is one of these for each connection to a resource on a particular
	* session		* session
	@@ -1257,7 +1221,7 @@ struct cifs_tcon {
	struct fscache_volume fscache; / cookie for share */		struct fscache_volume fscache; / cookie for share */
	#endif		#endif
	struct list_head pending_opens; /* list of incomplete opens */		struct list_head pending_opens; /* list of incomplete opens */
	struct cached_fid cfid; /* Cached root fid */		struct cached_fid cfid; / Cached root fid */
	/* BB add field for back pointer to sb struct(s)? */		/* BB add field for back pointer to sb struct(s)? */
	#ifdef CONFIG_CIFS_DFS_UPCALL		#ifdef CONFIG_CIFS_DFS_UPCALL
	struct list_head ulist; /* cache update list */		struct list_head ulist; /* cache update list */

fs/cifs/misc.c

+9 −11

Original line number	Original line	Diff line number	Diff line
	@@ -23,6 +23,7 @@
	#include "dns_resolve.h"		#include "dns_resolve.h"
	#endif		#endif
	#include "fs_context.h"		#include "fs_context.h"
			#include "cached_dir.h"

	extern mempool_t *cifs_sm_req_poolp;		extern mempool_t *cifs_sm_req_poolp;
	extern mempool_t *cifs_req_poolp;		extern mempool_t *cifs_req_poolp;
	@@ -116,13 +117,11 @@ tconInfoAlloc(void)
	ret_buf = kzalloc(sizeof(*ret_buf), GFP_KERNEL);		ret_buf = kzalloc(sizeof(*ret_buf), GFP_KERNEL);
	if (!ret_buf)		if (!ret_buf)
	return NULL;		return NULL;
	ret_buf->cfid.fid = kzalloc(sizeof(*ret_buf->cfid.fid), GFP_KERNEL);		ret_buf->cfid = init_cached_dir();
	if (!ret_buf->cfid.fid) {		if (!ret_buf->cfid) {
	kfree(ret_buf);		kfree(ret_buf);
	return NULL;		return NULL;
	}		}
	INIT_LIST_HEAD(&ret_buf->cfid.dirents.entries);
	mutex_init(&ret_buf->cfid.dirents.de_mutex);

	atomic_inc(&tconInfoAllocCount);		atomic_inc(&tconInfoAllocCount);
	ret_buf->status = TID_NEW;		ret_buf->status = TID_NEW;
	@@ -131,7 +130,6 @@ tconInfoAlloc(void)
	INIT_LIST_HEAD(&ret_buf->openFileList);		INIT_LIST_HEAD(&ret_buf->openFileList);
	INIT_LIST_HEAD(&ret_buf->tcon_list);		INIT_LIST_HEAD(&ret_buf->tcon_list);
	spin_lock_init(&ret_buf->open_file_lock);		spin_lock_init(&ret_buf->open_file_lock);
	mutex_init(&ret_buf->cfid.fid_mutex);
	spin_lock_init(&ret_buf->stat_lock);		spin_lock_init(&ret_buf->stat_lock);
	atomic_set(&ret_buf->num_local_opens, 0);		atomic_set(&ret_buf->num_local_opens, 0);
	atomic_set(&ret_buf->num_remote_opens, 0);		atomic_set(&ret_buf->num_remote_opens, 0);
	@@ -140,17 +138,17 @@ tconInfoAlloc(void)
	}		}

	void		void
	tconInfoFree(struct cifs_tcon *buf_to_free)		tconInfoFree(struct cifs_tcon *tcon)
	{		{
	if (buf_to_free == NULL) {		if (tcon == NULL) {
	cifs_dbg(FYI, "Null buffer passed to tconInfoFree\n");		cifs_dbg(FYI, "Null buffer passed to tconInfoFree\n");
	return;		return;
	}		}
			free_cached_dir(tcon);
	atomic_dec(&tconInfoAllocCount);		atomic_dec(&tconInfoAllocCount);
	kfree(buf_to_free->nativeFileSystem);		kfree(tcon->nativeFileSystem);
	kfree_sensitive(buf_to_free->password);		kfree_sensitive(tcon->password);
	kfree(buf_to_free->cfid.fid);		kfree(tcon);
	kfree(buf_to_free);
	}		}

	struct smb_hdr *		struct smb_hdr *

fs/cifs/smb2inode.c

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -524,8 +524,8 @@ smb2_query_path_info(const unsigned int xid, struct cifs_tcon *tcon,
	&cfid->file_all_info);		&cfid->file_all_info);
	} else {		} else {
	rc = SMB2_query_info(xid, tcon,		rc = SMB2_query_info(xid, tcon,
	cfid->fid->persistent_fid,		cfid->fid.persistent_fid,
	cfid->fid->volatile_fid, smb2_data);		cfid->fid.volatile_fid, smb2_data);
	if (!rc)		if (!rc)
	move_smb2_info_to_cifs(data, smb2_data);		move_smb2_info_to_cifs(data, smb2_data);
	}		}