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

fs/cifs/cached_dir.c

+284 −185

Original line number	Diff line number	Diff line
		@@ -5,13 +5,98 @@
		* Copyright (c) 2022, Ronnie Sahlberg <lsahlber@redhat.com>
		*/

		#include <linux/namei.h>
		#include "cifsglob.h"
		#include "cifsproto.h"
		#include "cifs_debug.h"
		#include "smb2proto.h"
		#include "cached_dir.h"

		struct cached_fid init_cached_dir(const char path);
		static struct cached_fid init_cached_dir(const char path);
		static void free_cached_dir(struct cached_fid *cfid);

		static struct cached_fid find_or_create_cached_dir(struct cached_fids cfids,
		const char *path,
		bool lookup_only)
		{
		struct cached_fid *cfid;

		spin_lock(&cfids->cfid_list_lock);
		list_for_each_entry(cfid, &cfids->entries, entry) {
		if (!strcmp(cfid->path, path)) {
		/*
		* If it doesn't have a lease it is either not yet
		* fully cached or it may be in the process of
		* being deleted due to a lease break.
		*/
		if (!cfid->has_lease) {
		spin_unlock(&cfids->cfid_list_lock);
		return NULL;
		}
		kref_get(&cfid->refcount);
		spin_unlock(&cfids->cfid_list_lock);
		return cfid;
		}
		}
		if (lookup_only) {
		spin_unlock(&cfids->cfid_list_lock);
		return NULL;
		}
		if (cfids->num_entries >= MAX_CACHED_FIDS) {
		spin_unlock(&cfids->cfid_list_lock);
		return NULL;
		}
		cfid = init_cached_dir(path);
		if (cfid == NULL) {
		spin_unlock(&cfids->cfid_list_lock);
		return NULL;
		}
		cfid->cfids = cfids;
		cfids->num_entries++;
		list_add(&cfid->entry, &cfids->entries);
		cfid->on_list = true;
		kref_get(&cfid->refcount);
		spin_unlock(&cfids->cfid_list_lock);
		return cfid;
		}

		static struct dentry *
		path_to_dentry(struct cifs_sb_info cifs_sb, const char path)
		{
		struct dentry *dentry;
		const char s, p;
		char sep;

		sep = CIFS_DIR_SEP(cifs_sb);
		dentry = dget(cifs_sb->root);
		s = path;

		do {
		struct inode *dir = d_inode(dentry);
		struct dentry *child;

		if (!S_ISDIR(dir->i_mode)) {
		dput(dentry);
		dentry = ERR_PTR(-ENOTDIR);
		break;
		}

		/* skip separators */
		while (*s == sep)
		s++;
		if (!*s)
		break;
		p = s++;
		/* next separator */
		while (s && s != sep)
		s++;

		child = lookup_positive_unlocked(p, dentry, s - p);
		dput(dentry);
		dentry = child;
		} while (!IS_ERR(dentry));
		return dentry;
		}

		/*
		* Open the and cache a directory handle.
		@@ -33,61 +118,57 @@ int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,
		struct kvec open_iov[SMB2_CREATE_IOV_SIZE];
		struct kvec qi_iov[1];
		int rc, flags = 0;
		__le16 utf16_path = 0; /* Null - since an open of top of share */
		__le16 *utf16_path = NULL;
		u8 oplock = SMB2_OPLOCK_LEVEL_II;
		struct cifs_fid *pfid;
		struct dentry *dentry;
		struct dentry *dentry = NULL;
		struct cached_fid *cfid;
		struct cached_fids *cfids;

		if (tcon == NULL \|\| tcon->nohandlecache \|\|
		if (tcon == NULL \|\| tcon->cfids == NULL \|\| tcon->nohandlecache \|\|
		is_smb1_server(tcon->ses->server))
		return -EOPNOTSUPP;

		ses = tcon->ses;
		server = ses->server;
		cfids = tcon->cfids;

		if (!server->ops->new_lease_key)
		return -EIO;

		if (cifs_sb->root == NULL)
		return -ENOENT;

		if (!path[0])
		dentry = cifs_sb->root;
		else
		return -ENOENT;
		utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
		if (!utf16_path)
		return -ENOMEM;

		cfid = tcon->cfids->cfid;
		cfid = find_or_create_cached_dir(cfids, path, lookup_only);
		if (cfid == NULL) {
		cfid = init_cached_dir(path);
		tcon->cfids->cfid = cfid;
		kfree(utf16_path);
		return -ENOENT;
		}
		if (cfid == NULL)
		return -ENOMEM;

		mutex_lock(&cfid->fid_mutex);
		if (cfid->is_valid) {
		cifs_dbg(FYI, "found a cached root file handle\n");
		/*
		* At this point we either have a lease already and we can just
		* return it. If not we are guaranteed to be the only thread accessing
		* this cfid.
		*/
		if (cfid->has_lease) {
		*ret_cfid = cfid;
		kref_get(&cfid->refcount);
		mutex_unlock(&cfid->fid_mutex);
		kfree(utf16_path);
		return 0;
		}

		/*
		* We do not hold the lock for the open because in case
		* SMB2_open needs to reconnect, it will end up calling
		* cifs_mark_open_files_invalid() which takes the lock again
		* thus causing a deadlock
		* SMB2_open needs to reconnect.
		* This is safe because no other thread will be able to get a ref
		* to the cfid until we have finished opening the file and (possibly)
		* acquired a lease.
		*/
		mutex_unlock(&cfid->fid_mutex);

		if (lookup_only)
		return -ENOENT;

		if (smb3_encryption_required(tcon))
		flags \|= CIFS_TRANSFORM_REQ;

		if (!server->ops->new_lease_key)
		return -EIO;

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

		@@ -108,7 +189,7 @@ int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,
		oparms.reconnect = false;

		rc = SMB2_open_init(tcon, server,
		&rqst[0], &oplock, &oparms, &utf16_path);
		&rqst[0], &oplock, &oparms, utf16_path);
		if (rc)
		goto oshr_free;
		smb2_set_next_command(tcon, &rqst[0]);
		@@ -131,47 +212,13 @@ int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,
		rc = compound_send_recv(xid, ses, server,
		flags, 2, rqst,
		resp_buftype, rsp_iov);
		mutex_lock(&cfid->fid_mutex);

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

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

		/* stash fids for close() later */
		struct cifs_fid fid = {
		.persistent_fid = pfid->persistent_fid,
		.volatile_fid = pfid->volatile_fid,
		};

		/*
		* caller expects this func to set the fid in cfid to valid
		* cached root, so increment the refcount.
		*/
		kref_get(&cfid->refcount);

		mutex_unlock(&cfid->fid_mutex);

		if (rc == 0) {
		/* close extra handle outside of crit sec */
		SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
		}
		rc = 0;
		goto oshr_free;
		}

		/* Cached root is still invalid, continue normaly */

		if (rc) {
		if (rc == -EREMCHG) {
		tcon->need_reconnect = true;
		pr_warn_once("server share %s deleted\n",
		tcon->tree_name);
		}
		goto oshr_exit;
		goto oshr_free;
		}

		atomic_inc(&tcon->num_remote_opens);
		@@ -183,31 +230,18 @@ int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,
		oparms.fid->mid = le64_to_cpu(o_rsp->hdr.MessageId);
		#endif /* CIFS_DEBUG2 */

		cfid->tcon = tcon;
		cfid->is_valid = true;
		cfid->dentry = dentry;
		if (dentry)
		dget(dentry);
		kref_init(&cfid->refcount);
		if (o_rsp->OplockLevel != SMB2_OPLOCK_LEVEL_LEASE)
		goto oshr_free;


		/* BB TBD check to see if oplock level check can be removed below */
		if (o_rsp->OplockLevel == SMB2_OPLOCK_LEVEL_LEASE) {
		/*
		* See commit 2f94a3125b87. Increment the refcount when we
		* get a lease for root, release it if lease break occurs
		*/
		kref_get(&cfid->refcount);
		cfid->has_lease = true;
		smb2_parse_contexts(server, o_rsp,
		&oparms.fid->epoch,
		oparms.fid->lease_key, &oplock,
		NULL, NULL);
		} else
		goto oshr_exit;

		qi_rsp = (struct smb2_query_info_rsp *)rsp_iov[1].iov_base;
		if (le32_to_cpu(qi_rsp->OutputBufferLength) < sizeof(struct smb2_file_all_info))
		goto oshr_exit;
		goto oshr_free;
		if (!smb2_validate_and_copy_iov(
		le16_to_cpu(qi_rsp->OutputBufferOffset),
		sizeof(struct smb2_file_all_info),
		@@ -215,15 +249,40 @@ int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,
		(char *)&cfid->file_all_info))
		cfid->file_all_info_is_valid = true;

		if (!path[0])
		dentry = dget(cifs_sb->root);
		else {
		dentry = path_to_dentry(cifs_sb, path);
		if (IS_ERR(dentry))
		goto oshr_free;
		}
		cfid->dentry = dentry;
		cfid->tcon = tcon;
		cfid->time = jiffies;
		cfid->is_open = true;
		cfid->has_lease = true;

		oshr_exit:
		mutex_unlock(&cfid->fid_mutex);
		oshr_free:
		kfree(utf16_path);
		SMB2_open_free(&rqst[0]);
		SMB2_query_info_free(&rqst[1]);
		free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);
		free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);
		spin_lock(&cfids->cfid_list_lock);
		if (!cfid->has_lease) {
		if (cfid->on_list) {
		list_del(&cfid->entry);
		cfid->on_list = false;
		cfids->num_entries--;
		}
		rc = -ENOENT;
		}
		spin_unlock(&cfids->cfid_list_lock);
		if (rc) {
		free_cached_dir(cfid);
		cfid = NULL;
		}

		if (rc == 0)
		*ret_cfid = cfid;

		@@ -235,20 +294,22 @@ int open_cached_dir_by_dentry(struct cifs_tcon *tcon,
		struct cached_fid **ret_cfid)
		{
		struct cached_fid *cfid;
		struct cached_fids *cfids = tcon->cfids;

		cfid = tcon->cfids->cfid;
		if (cfid == NULL)
		if (cfids == NULL)
		return -ENOENT;

		mutex_lock(&cfid->fid_mutex);
		if (cfid->dentry == dentry) {
		spin_lock(&cfids->cfid_list_lock);
		list_for_each_entry(cfid, &cfids->entries, entry) {
		if (dentry && cfid->dentry == dentry) {
		cifs_dbg(FYI, "found a cached root file handle by dentry\n");
		*ret_cfid = cfid;
		kref_get(&cfid->refcount);
		mutex_unlock(&cfid->fid_mutex);
		*ret_cfid = cfid;
		spin_unlock(&cfids->cfid_list_lock);
		return 0;
		}
		mutex_unlock(&cfid->fid_mutex);
		}
		spin_unlock(&cfids->cfid_list_lock);
		return -ENOENT;
		}

		@@ -257,64 +318,30 @@ smb2_close_cached_fid(struct kref *ref)
		{
		struct cached_fid *cfid = container_of(ref, struct cached_fid,
		refcount);
		struct cached_dirent dirent, q;

		if (cfid->is_valid) {
		cifs_dbg(FYI, "clear cached root file handle\n");
		SMB2_close(0, cfid->tcon, cfid->fid.persistent_fid,
		cfid->fid.volatile_fid);
		spin_lock(&cfid->cfids->cfid_list_lock);
		if (cfid->on_list) {
		list_del(&cfid->entry);
		cfid->on_list = false;
		cfid->cfids->num_entries--;
		}
		spin_unlock(&cfid->cfids->cfid_list_lock);

		/*
		* We only check validity above to send SMB2_close,
		* but we still need to invalidate these entries
		* when this function is called
		*/
		cfid->is_valid = false;
		cfid->file_all_info_is_valid = false;
		cfid->has_lease = false;
		if (cfid->dentry) {
		dput(cfid->dentry);
		cfid->dentry = NULL;
		}
		/*
		* Delete all cached dirent names
		*/
		mutex_lock(&cfid->dirents.de_mutex);
		list_for_each_entry_safe(dirent, q, &cfid->dirents.entries, entry) {
		list_del(&dirent->entry);
		kfree(dirent->name);
		kfree(dirent);
		}
		cfid->dirents.is_valid = 0;
		cfid->dirents.is_failed = 0;
		cfid->dirents.ctx = NULL;
		cfid->dirents.pos = 0;
		mutex_unlock(&cfid->dirents.de_mutex);

		if (cfid->is_open) {
		SMB2_close(0, cfid->tcon, cfid->fid.persistent_fid,
		cfid->fid.volatile_fid);
		}

		void close_cached_dir(struct cached_fid *cfid)
		{
		mutex_lock(&cfid->fid_mutex);
		kref_put(&cfid->refcount, smb2_close_cached_fid);
		mutex_unlock(&cfid->fid_mutex);
		free_cached_dir(cfid);
		}

		void close_cached_dir_lease_locked(struct cached_fid *cfid)
		void close_cached_dir(struct cached_fid *cfid)
		{
		if (cfid->has_lease) {
		cfid->has_lease = false;
		kref_put(&cfid->refcount, smb2_close_cached_fid);
		}
		}

		void close_cached_dir_lease(struct cached_fid *cfid)
		{
		mutex_lock(&cfid->fid_mutex);
		close_cached_dir_lease_locked(cfid);
		mutex_unlock(&cfid->fid_mutex);
		}

		/*
		* Called from cifs_kill_sb when we unmount a share
		@@ -326,41 +353,62 @@ void close_all_cached_dirs(struct cifs_sb_info *cifs_sb)
		struct cached_fid *cfid;
		struct cifs_tcon *tcon;
		struct tcon_link *tlink;
		struct cached_fids *cfids;

		for (node = rb_first(root); node; node = rb_next(node)) {
		tlink = rb_entry(node, struct tcon_link, tl_rbnode);
		tcon = tlink_tcon(tlink);
		if (IS_ERR(tcon))
		continue;
		cfid = tcon->cfids->cfid;
		if (cfid == NULL)
		cfids = tcon->cfids;
		if (cfids == NULL)
		continue;
		mutex_lock(&cfid->fid_mutex);
		if (cfid->dentry) {
		list_for_each_entry(cfid, &cfids->entries, entry) {
		dput(cfid->dentry);
		cfid->dentry = NULL;
		}
		mutex_unlock(&cfid->fid_mutex);
		}
		}

		/*
		* Invalidate and close all cached dirs when a TCON has been reset
		* Invalidate all cached dirs when a TCON has been reset
		* due to a session loss.
		*/
		void invalidate_all_cached_dirs(struct cifs_tcon *tcon)
		{
		struct cached_fid *cfid = tcon->cfids->cfid;

		if (cfid == NULL)
		return;
		struct cached_fids *cfids = tcon->cfids;
		struct cached_fid cfid, q;
		struct list_head entry;

		INIT_LIST_HEAD(&entry);
		spin_lock(&cfids->cfid_list_lock);
		list_for_each_entry_safe(cfid, q, &cfids->entries, entry) {
		list_del(&cfid->entry);
		list_add(&cfid->entry, &entry);
		cfids->num_entries--;
		cfid->is_open = false;
		/* To prevent race with smb2_cached_lease_break() */
		kref_get(&cfid->refcount);
		}
		spin_unlock(&cfids->cfid_list_lock);

		mutex_lock(&cfid->fid_mutex);
		cfid->is_valid = false;
		/* cached handle is not valid, so SMB2_CLOSE won't be sent below */
		close_cached_dir_lease_locked(cfid);
		memset(&cfid->fid, 0, sizeof(struct cifs_fid));
		mutex_unlock(&cfid->fid_mutex);
		list_for_each_entry_safe(cfid, q, &entry, entry) {
		cfid->on_list = false;
		list_del(&cfid->entry);
		cancel_work_sync(&cfid->lease_break);
		if (cfid->has_lease) {
		/*
		* We lease was never cancelled from the server so we
		* need to drop the reference.
		*/
		spin_lock(&cfids->cfid_list_lock);
		cfid->has_lease = false;
		spin_unlock(&cfids->cfid_list_lock);
		kref_put(&cfid->refcount, smb2_close_cached_fid);
		}
		/* Drop the extra reference opened above*/
		kref_put(&cfid->refcount, smb2_close_cached_fid);
		}
		}

		static void
		@@ -369,51 +417,83 @@ smb2_cached_lease_break(struct work_struct *work)
		struct cached_fid *cfid = container_of(work,
		struct cached_fid, lease_break);

		close_cached_dir_lease(cfid);
		spin_lock(&cfid->cfids->cfid_list_lock);
		cfid->has_lease = false;
		spin_unlock(&cfid->cfids->cfid_list_lock);
		kref_put(&cfid->refcount, smb2_close_cached_fid);
		}

		int cached_dir_lease_break(struct cifs_tcon *tcon, __u8 lease_key[16])
		{
		struct cached_fid *cfid = tcon->cfids->cfid;
		struct cached_fids *cfids = tcon->cfids;
		struct cached_fid *cfid;

		if (cfid == NULL)
		if (cfids == NULL)
		return false;

		if (cfid->is_valid &&
		spin_lock(&cfids->cfid_list_lock);
		list_for_each_entry(cfid, &cfids->entries, entry) {
		if (cfid->has_lease &&
		!memcmp(lease_key,
		cfid->fid.lease_key,
		SMB2_LEASE_KEY_SIZE)) {
		cfid->time = 0;
		INIT_WORK(&cfid->lease_break,
		smb2_cached_lease_break);
		/*
		* We found a lease remove it from the list
		* so no threads can access it.
		*/
		list_del(&cfid->entry);
		cfid->on_list = false;
		cfids->num_entries--;

		queue_work(cifsiod_wq,
		&cfid->lease_break);
		spin_unlock(&cfids->cfid_list_lock);
		return true;
		}
		}
		spin_unlock(&cfids->cfid_list_lock);
		return false;
		}

		struct cached_fid init_cached_dir(const char path)
		static struct cached_fid init_cached_dir(const char path)
		{
		struct cached_fid *cfid;

		cfid = kzalloc(sizeof(*cfid), GFP_KERNEL);
		cfid = kzalloc(sizeof(*cfid), GFP_ATOMIC);
		if (!cfid)
		return NULL;
		cfid->path = kstrdup(path, GFP_KERNEL);
		cfid->path = kstrdup(path, GFP_ATOMIC);
		if (!cfid->path) {
		kfree(cfid);
		return NULL;
		}

		INIT_WORK(&cfid->lease_break, smb2_cached_lease_break);
		INIT_LIST_HEAD(&cfid->entry);
		INIT_LIST_HEAD(&cfid->dirents.entries);
		mutex_init(&cfid->dirents.de_mutex);
		mutex_init(&cfid->fid_mutex);
		spin_lock_init(&cfid->fid_lock);
		kref_init(&cfid->refcount);
		return cfid;
		}

		void free_cached_dir(struct cached_fid *cfid)
		static void free_cached_dir(struct cached_fid *cfid)
		{
		struct cached_dirent dirent, q;

		dput(cfid->dentry);
		cfid->dentry = NULL;

		/*
		* Delete all cached dirent names
		*/
		list_for_each_entry_safe(dirent, q, &cfid->dirents.entries, entry) {
		list_del(&dirent->entry);
		kfree(dirent->name);
		kfree(dirent);
		}

		kfree(cfid->path);
		cfid->path = NULL;
		kfree(cfid);
		@@ -426,15 +506,34 @@ struct cached_fids *init_cached_dirs(void)
		cfids = kzalloc(sizeof(*cfids), GFP_KERNEL);
		if (!cfids)
		return NULL;
		mutex_init(&cfids->cfid_list_mutex);
		spin_lock_init(&cfids->cfid_list_lock);
		INIT_LIST_HEAD(&cfids->entries);
		return cfids;
		}

		/*
		* Called from tconInfoFree when we are tearing down the tcon.
		* There are no active users or open files/directories at this point.
		*/
		void free_cached_dirs(struct cached_fids *cfids)
		{
		if (cfids->cfid) {
		free_cached_dir(cfids->cfid);
		cfids->cfid = NULL;
		struct cached_fid cfid, q;
		struct list_head entry;

		INIT_LIST_HEAD(&entry);
		spin_lock(&cfids->cfid_list_lock);
		list_for_each_entry_safe(cfid, q, &cfids->entries, entry) {
		cfid->on_list = false;
		cfid->is_open = false;
		list_del(&cfid->entry);
		list_add(&cfid->entry, &entry);
		}
		spin_unlock(&cfids->cfid_list_lock);

		list_for_each_entry_safe(cfid, q, &entry, entry) {
		list_del(&cfid->entry);
		free_cached_dir(cfid);
		}

		kfree(cfids);
		}

fs/cifs/cached_dir.h

+13 −7

Original line number	Diff line number	Diff line
		@@ -31,14 +31,17 @@ struct cached_dirents {
		};

		struct cached_fid {
		struct list_head entry;
		struct cached_fids *cfids;
		const char *path;
		bool is_valid:1; /* Do we have a useable root fid */
		bool file_all_info_is_valid:1;
		bool has_lease:1;
		bool is_open:1;
		bool on_list:1;
		bool file_all_info_is_valid:1;
		unsigned long time; /* jiffies of when lease was taken */
		struct kref refcount;
		struct cifs_fid fid;
		struct mutex fid_mutex;
		spinlock_t fid_lock;
		struct cifs_tcon *tcon;
		struct dentry *dentry;
		struct work_struct lease_break;
		@@ -46,9 +49,14 @@ struct cached_fid {
		struct cached_dirents dirents;
		};

		#define MAX_CACHED_FIDS 16
		struct cached_fids {
		struct mutex cfid_list_mutex;
		struct cached_fid *cfid;
		/* Must be held when:
		* - accessing the cfids->entries list
		*/
		spinlock_t cfid_list_lock;
		int num_entries;
		struct list_head entries;
		};

		extern struct cached_fids *init_cached_dirs(void);
		@@ -61,8 +69,6 @@ extern int open_cached_dir_by_dentry(struct cifs_tcon *tcon,
		struct dentry *dentry,
		struct cached_fid **cfid);
		extern void close_cached_dir(struct cached_fid *cfid);
		extern void close_cached_dir_lease(struct cached_fid *cfid);
		extern void close_cached_dir_lease_locked(struct cached_fid *cfid);
		extern void close_all_cached_dirs(struct cifs_sb_info *cifs_sb);
		extern void invalidate_all_cached_dirs(struct cifs_tcon *tcon);
		extern int cached_dir_lease_break(struct cifs_tcon *tcon, __u8 lease_key[16]);

fs/cifs/cifs_ioctl.h

+8 −0

Original line number	Diff line number	Diff line
		@@ -91,6 +91,13 @@ struct smb3_notify {
		bool watch_tree;
		} __packed;

		struct smb3_notify_info {
		__u32 completion_filter;
		bool watch_tree;
		__u32 data_len; /* size of notify data below */
		__u8 notify_data[];
		} __packed;

		#define CIFS_IOCTL_MAGIC 0xCF
		#define CIFS_IOC_COPYCHUNK_FILE _IOW(CIFS_IOCTL_MAGIC, 3, int)
		#define CIFS_IOC_SET_INTEGRITY _IO(CIFS_IOCTL_MAGIC, 4)
		@@ -100,6 +107,7 @@ struct smb3_notify {
		#define CIFS_DUMP_KEY _IOWR(CIFS_IOCTL_MAGIC, 8, struct smb3_key_debug_info)
		#define CIFS_IOC_NOTIFY _IOW(CIFS_IOCTL_MAGIC, 9, struct smb3_notify)
		#define CIFS_DUMP_FULL_KEY _IOWR(CIFS_IOCTL_MAGIC, 10, struct smb3_full_key_debug_info)
		#define CIFS_IOC_NOTIFY_INFO _IOWR(CIFS_IOCTL_MAGIC, 11, struct smb3_notify_info)
		#define CIFS_IOC_SHUTDOWN _IOR ('X', 125, __u32)

		/*

fs/cifs/cifsfs.c

+7 −2

Original line number	Diff line number	Diff line
		@@ -396,6 +396,7 @@ cifs_alloc_inode(struct super_block *sb)
		cifs_inode->epoch = 0;
		spin_lock_init(&cifs_inode->open_file_lock);
		generate_random_uuid(cifs_inode->lease_key);
		cifs_inode->symlink_target = NULL;

		/*
		* Can not set i_flags here - they get immediately overwritten to zero
		@@ -412,7 +413,11 @@ cifs_alloc_inode(struct super_block *sb)
		static void
		cifs_free_inode(struct inode *inode)
		{
		kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
		struct cifsInodeInfo *cinode = CIFS_I(inode);

		if (S_ISLNK(inode->i_mode))
		kfree(cinode->symlink_target);
		kmem_cache_free(cifs_inode_cachep, cinode);
		}

		static void
		@@ -1139,7 +1144,7 @@ const struct inode_operations cifs_file_inode_ops = {
		};

		const struct inode_operations cifs_symlink_inode_ops = {
		.get_link = cifs_get_link,
		.get_link = simple_get_link,
		.permission = cifs_permission,
		.listxattr = cifs_listxattr,
		};

fs/cifs/cifsglob.h

+37 −11

Original line number	Diff line number	Diff line
		@@ -185,6 +185,19 @@ struct cifs_cred {
		struct cifs_ace *aces;
		};

		struct cifs_open_info_data {
		char *symlink_target;
		union {
		struct smb2_file_all_info fi;
		struct smb311_posix_qinfo posix_fi;
		};
		};

		static inline void cifs_free_open_info(struct cifs_open_info_data *data)
		{
		kfree(data->symlink_target);
		}

		/*
		*****************************************************************
		* Except the CIFS PDUs themselves all the
		@@ -307,20 +320,20 @@ struct smb_version_operations {
		int (is_path_accessible)(const unsigned int, struct cifs_tcon ,
		struct cifs_sb_info , const char );
		/* query path data from the server */
		int (query_path_info)(const unsigned int, struct cifs_tcon ,
		struct cifs_sb_info , const char ,
		FILE_ALL_INFO , bool , bool *);
		int (query_path_info)(const unsigned int xid, struct cifs_tcon tcon,
		struct cifs_sb_info cifs_sb, const char full_path,
		struct cifs_open_info_data data, bool adjust_tz, bool *reparse);
		/* query file data from the server */
		int (query_file_info)(const unsigned int, struct cifs_tcon ,
		struct cifs_fid , FILE_ALL_INFO );
		int (query_file_info)(const unsigned int xid, struct cifs_tcon tcon,
		struct cifsFileInfo cfile, struct cifs_open_info_data data);
		/* query reparse tag from srv to determine which type of special file */
		int (query_reparse_tag)(const unsigned int xid, struct cifs_tcon tcon,
		struct cifs_sb_info cifs_sb, const char path,
		__u32 *reparse_tag);
		/* get server index number */
		int (get_srv_inum)(const unsigned int, struct cifs_tcon ,
		struct cifs_sb_info , const char ,
		u64 uniqueid, FILE_ALL_INFO );
		int (get_srv_inum)(const unsigned int xid, struct cifs_tcon tcon,
		struct cifs_sb_info cifs_sb, const char full_path, u64 *uniqueid,
		struct cifs_open_info_data *data);
		/* set size by path */
		int (set_path_size)(const unsigned int, struct cifs_tcon ,
		const char , __u64, struct cifs_sb_info , bool);
		@@ -369,8 +382,8 @@ struct smb_version_operations {
		struct cifs_sb_info , const char ,
		char **, bool);
		/* open a file for non-posix mounts */
		int (open)(const unsigned int, struct cifs_open_parms ,
		__u32 , FILE_ALL_INFO );
		int (open)(const unsigned int xid, struct cifs_open_parms oparms, __u32 *oplock,
		void *buf);
		/* set fid protocol-specific info */
		void (set_fid)(struct cifsFileInfo , struct cifs_fid *, __u32);
		/* close a file */
		@@ -441,7 +454,7 @@ struct smb_version_operations {
		int (enum_snapshots)(const unsigned int xid, struct cifs_tcon tcon,
		struct cifsFileInfo src_file, void __user );
		int (notify)(const unsigned int xid, struct file pfile,
		void __user *pbuf);
		void __user *pbuf, bool return_changes);
		int (query_mf_symlink)(unsigned int, struct cifs_tcon ,
		struct cifs_sb_info , const unsigned char ,
		char , unsigned int );
		@@ -1123,6 +1136,7 @@ struct cifs_fattr {
		struct timespec64 cf_mtime;
		struct timespec64 cf_ctime;
		u32 cf_cifstag;
		char *cf_symlink_target;
		};

		/*
		@@ -1385,6 +1399,7 @@ struct cifsFileInfo {
		struct work_struct put; /* work for the final part of _put */
		struct delayed_work deferred;
		bool deferred_close_scheduled; /* Flag to indicate close is scheduled */
		char *symlink_target;
		};

		struct cifs_io_parms {
		@@ -1543,6 +1558,7 @@ struct cifsInodeInfo {
		struct list_head deferred_closes; /* list of deferred closes */
		spinlock_t deferred_lock; /* protection on deferred list */
		bool lease_granted; /* Flag to indicate whether lease or oplock is granted. */
		char *symlink_target;
		};

		static inline struct cifsInodeInfo *
		@@ -2111,4 +2127,14 @@ static inline size_t ntlmssp_workstation_name_size(const struct cifs_ses *ses)
		return sizeof(ses->workstation_name);
		}

		static inline void move_cifs_info_to_smb2(struct smb2_file_all_info dst, const FILE_ALL_INFO src)
		{
		memcpy(dst, src, (size_t)((u8 )&src->AccessFlags - (u8 )src));
		dst->AccessFlags = src->AccessFlags;
		dst->CurrentByteOffset = src->CurrentByteOffset;
		dst->Mode = src->Mode;
		dst->AlignmentRequirement = src->AlignmentRequirement;
		dst->FileNameLength = src->FileNameLength;
		}

		#endif /* _CIFS_GLOB_H */