merged into cifs-2.6.git for-next with minor changes. Let me know if
objections to the fix of the return code (ENOSYS is for syscalls only)
$ diff ~/save-patch1/0019-cifs-Add-DFS-cache-routines.patch
0019-cifs-Add-DFS-cache-routines.patch
834c834
< + ce = ERR_PTR(-ENOSYS);
---
> + ce = ERR_PTR(-EOPNOTSUPP);
1481c1481
< + rc = -ENOSYS;
---
> + rc = -EOPNOTSUPP;
On Thu, Nov 15, 2018 at 8:22 AM Aurelien Aptel <aaptel@xxxxxxxx> wrote:
>
> From: Paulo Alcantara <paulo@xxxxxxxx>
>
> * Add new dfs_cache.[ch] files
>
> * Add new /proc/fs/cifs/dfscache file
> - dump current cache when read
> - clear current cache when writing "0" to it
>
> * Add delayed_work to periodically refresh cache entries
>
> The new interface will be used for caching DFS referrals, as well as
> supporting client target failover.
>
> The DFS cache is a hashtable that maps UNC paths to cache entries.
>
> A cache entry contains:
> - the UNC path it is mapped on
> - how much the the UNC path the entry consumes
> - flags
> - a Time-To-Live after which the entry expires
> - a list of possible targets (linked lists of UNC paths)
> - a "hint target" pointing the last known working target or the first
> target if none were tried. This hint lets cifs.ko remember and try
> working targets first.
>
> * Looking for an entry in the cache is done with dfs_cache_find()
> - if no valid entries are found, a DFS query is made, stored in the
> cache and returned
> - the full target list can be copied and returned to avoid race
> conditions and looped on with the help with the
> dfs_cache_tgt_iterator
>
> * Updating the target hint to the next target is done with
> dfs_cache_update_tgthint()
>
> These functions have a dfs_cache_noreq_XXX() version that doesn't
> fetches referrals if no entries are found. These versions don't
> require the tcp/ses/tcon/cifs_sb parameters as a result.
>
> Expired entries cannot be used and since they have a pretty short TTL
> [1] in order for them to be useful for failover the DFS cache adds a
> delayed work called periodically to keep them fresh.
>
> Since we might not have available connections to issue the referral
> request when refreshing we need to store volume_info structs with
> credentials and other needed info to be able to connect to the right
> server.
>
> 1: Windows defaults: 5mn for domain-based referrals, 30mn for regular
> links
>
> Signed-off-by: Paulo Alcantara <palcantara@xxxxxxx>
> Signed-off-by: Aurelien Aptel <aaptel@xxxxxxxx>
> ---
> fs/cifs/Makefile | 2 +-
> fs/cifs/cifs_debug.c | 12 +
> fs/cifs/cifsglob.h | 5 +
> fs/cifs/cifsproto.h | 3 +
> fs/cifs/connect.c | 2 +-
> fs/cifs/dfs_cache.c | 1379 ++++++++++++++++++++++++++++++++++++++++++++++++++
> fs/cifs/dfs_cache.h | 97 ++++
> 7 files changed, 1498 insertions(+), 2 deletions(-)
> create mode 100644 fs/cifs/dfs_cache.c
> create mode 100644 fs/cifs/dfs_cache.h
>
> diff --git a/fs/cifs/Makefile b/fs/cifs/Makefile
> index 85817991ee68..51af69a1a328 100644
> --- a/fs/cifs/Makefile
> +++ b/fs/cifs/Makefile
> @@ -17,7 +17,7 @@ cifs-$(CONFIG_CIFS_ACL) += cifsacl.o
>
> cifs-$(CONFIG_CIFS_UPCALL) += cifs_spnego.o
>
> -cifs-$(CONFIG_CIFS_DFS_UPCALL) += dns_resolve.o cifs_dfs_ref.o
> +cifs-$(CONFIG_CIFS_DFS_UPCALL) += dns_resolve.o cifs_dfs_ref.o dfs_cache.o
>
> cifs-$(CONFIG_CIFS_FSCACHE) += fscache.o cache.o
>
> diff --git a/fs/cifs/cifs_debug.c b/fs/cifs/cifs_debug.c
> index ba178b09de0b..593fb422d0f3 100644
> --- a/fs/cifs/cifs_debug.c
> +++ b/fs/cifs/cifs_debug.c
> @@ -30,6 +30,9 @@
> #include "cifsproto.h"
> #include "cifs_debug.h"
> #include "cifsfs.h"
> +#ifdef CONFIG_CIFS_DFS_UPCALL
> +#include "dfs_cache.h"
> +#endif
> #ifdef CONFIG_CIFS_SMB_DIRECT
> #include "smbdirect.h"
> #endif
> @@ -629,6 +632,11 @@ cifs_proc_init(void)
> &cifs_security_flags_proc_fops);
> proc_create("LookupCacheEnabled", 0644, proc_fs_cifs,
> &cifs_lookup_cache_proc_fops);
> +
> +#ifdef CONFIG_CIFS_DFS_UPCALL
> + proc_create("dfscache", 0644, proc_fs_cifs, &dfscache_proc_fops);
> +#endif
> +
> #ifdef CONFIG_CIFS_SMB_DIRECT
> proc_create("rdma_readwrite_threshold", 0644, proc_fs_cifs,
> &cifs_rdma_readwrite_threshold_proc_fops);
> @@ -663,6 +671,10 @@ cifs_proc_clean(void)
> remove_proc_entry("SecurityFlags", proc_fs_cifs);
> remove_proc_entry("LinuxExtensionsEnabled", proc_fs_cifs);
> remove_proc_entry("LookupCacheEnabled", proc_fs_cifs);
> +
> +#ifdef CONFIG_CIFS_DFS_UPCALL
> + remove_proc_entry("dfscache", proc_fs_cifs);
> +#endif
> #ifdef CONFIG_CIFS_SMB_DIRECT
> remove_proc_entry("rdma_readwrite_threshold", proc_fs_cifs);
> remove_proc_entry("smbd_max_frmr_depth", proc_fs_cifs);
> diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
> index 9534f46e6ad2..bd183ec17066 100644
> --- a/fs/cifs/cifsglob.h
> +++ b/fs/cifs/cifsglob.h
> @@ -1014,6 +1014,11 @@ struct cifs_tcon {
> struct list_head pending_opens; /* list of incomplete opens */
> struct cached_fid crfid; /* Cached root fid */
> /* BB add field for back pointer to sb struct(s)? */
> +#ifdef CONFIG_CIFS_DFS_UPCALL
> + char *dfs_path;
> + int remap:2;
> + struct list_head ulist; /* cache update list */
> +#endif
> };
>
> /*
> diff --git a/fs/cifs/cifsproto.h b/fs/cifs/cifsproto.h
> index f4dd2a3795dd..efa5e36b3762 100644
> --- a/fs/cifs/cifsproto.h
> +++ b/fs/cifs/cifsproto.h
> @@ -527,6 +527,9 @@ extern int SMBencrypt(unsigned char *passwd, const unsigned char *c8,
> extern void
> cifs_cleanup_volume_info_contents(struct smb_vol *volume_info);
>
> +extern struct TCP_Server_Info *
> +cifs_find_tcp_session(struct smb_vol *vol);
> +
> void cifs_readdata_release(struct kref *refcount);
> int cifs_async_readv(struct cifs_readdata *rdata);
> int cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid);
> diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
> index 86649230b4f2..b4fed69add86 100644
> --- a/fs/cifs/connect.c
> +++ b/fs/cifs/connect.c
> @@ -2294,7 +2294,7 @@ static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
> return 1;
> }
>
> -static struct TCP_Server_Info *
> +struct TCP_Server_Info *
> cifs_find_tcp_session(struct smb_vol *vol)
> {
> struct TCP_Server_Info *server;
> diff --git a/fs/cifs/dfs_cache.c b/fs/cifs/dfs_cache.c
> new file mode 100644
> index 000000000000..18da279e9354
> --- /dev/null
> +++ b/fs/cifs/dfs_cache.c
> @@ -0,0 +1,1379 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * DFS referral cache routines
> + *
> + * Copyright (c) 2018 Paulo Alcantara <palcantara@xxxxxxx>
> + */
> +
> +#include <linux/rcupdate.h>
> +#include <linux/rculist.h>
> +#include <linux/jhash.h>
> +#include <linux/ktime.h>
> +#include <linux/slab.h>
> +#include <linux/nls.h>
> +#include <linux/workqueue.h>
> +#include "cifsglob.h"
> +#include "smb2pdu.h"
> +#include "smb2proto.h"
> +#include "cifsproto.h"
> +#include "cifs_debug.h"
> +#include "cifs_unicode.h"
> +#include "smb2glob.h"
> +
> +#include "dfs_cache.h"
> +
> +#define DFS_CACHE_HTABLE_SIZE 32
> +#define DFS_CACHE_MAX_ENTRIES 64
> +
> +#define IS_INTERLINK_SET(v) ((v) & (DFSREF_REFERRAL_SERVER | \
> + DFSREF_STORAGE_SERVER))
> +
> +struct dfs_cache_tgt {
> + char *t_name;
> + struct list_head t_list;
> +};
> +
> +struct dfs_cache_entry {
> + struct hlist_node ce_hlist;
> + const char *ce_path;
> + int ce_ttl;
> + int ce_srvtype;
> + int ce_flags;
> + struct timespec64 ce_etime;
> + int ce_path_consumed;
> + int ce_numtgts;
> + struct list_head ce_tlist;
> + struct dfs_cache_tgt *ce_tgthint;
> + struct rcu_head ce_rcu;
> +};
> +
> +static struct kmem_cache *dfs_cache_slab __read_mostly;
> +
> +struct dfs_cache_vol_info {
> + char *vi_fullpath;
> + struct smb_vol vi_vol;
> + struct list_head vi_list;
> +};
> +
> +struct dfs_cache {
> + struct mutex dc_lock;
> + struct nls_table *dc_nlsc;
> + struct list_head dc_vol_list;
> + int dc_ttl;
> + struct delayed_work dc_refresh;
> +};
> +
> +static struct dfs_cache dfs_cache;
> +
> +/*
> + * Number of entries in the cache
> + */
> +static size_t dfs_cache_count;
> +
> +static DEFINE_MUTEX(dfs_cache_list_lock);
> +static struct hlist_head dfs_cache_htable[DFS_CACHE_HTABLE_SIZE];
> +
> +static void refresh_cache_worker(struct work_struct *work);
> +
> +static inline bool is_path_valid(const char *path)
> +{
> + return path && (strchr(path + 1, '\\') || strchr(path + 1, '/'));
> +}
> +
> +static inline int get_normalized_path(const char *path, char **npath)
> +{
> + if (*path == '\\') {
> + *npath = (char *)path;
> + } else {
> + *npath = kstrndup(path, strlen(path), GFP_KERNEL);
> + if (!*npath)
> + return -ENOMEM;
> + convert_delimiter(*npath, '\\');
> + }
> + return 0;
> +}
> +
> +static inline void free_normalized_path(const char *path, char *npath)
> +{
> + if (path != npath)
> + kfree(npath);
> +}
> +
> +static inline bool cache_entry_expired(const struct dfs_cache_entry *ce)
> +{
> + struct timespec64 ts;
> +
> + ts = current_kernel_time64();
> + return timespec64_compare(&ts, &ce->ce_etime) >= 0;
> +}
> +
> +static inline void free_tgts(struct dfs_cache_entry *ce)
> +{
> + struct dfs_cache_tgt *t, *n;
> +
> + list_for_each_entry_safe(t, n, &ce->ce_tlist, t_list) {
> + list_del(&t->t_list);
> + kfree(t->t_name);
> + kfree(t);
> + }
> +}
> +
> +static void free_cache_entry(struct rcu_head *rcu)
> +{
> + struct dfs_cache_entry *ce = container_of(rcu, struct dfs_cache_entry,
> + ce_rcu);
> + kmem_cache_free(dfs_cache_slab, ce);
> +}
> +
> +static inline void flush_cache_ent(struct dfs_cache_entry *ce)
> +{
> + if (hlist_unhashed(&ce->ce_hlist))
> + return;
> +
> + hlist_del_init_rcu(&ce->ce_hlist);
> + kfree(ce->ce_path);
> + free_tgts(ce);
> + dfs_cache_count--;
> + call_rcu(&ce->ce_rcu, free_cache_entry);
> +}
> +
> +static void flush_cache_ents(void)
> +{
> + int i;
> +
> + rcu_read_lock();
> + for (i = 0; i < DFS_CACHE_HTABLE_SIZE; i++) {
> + struct hlist_head *l = &dfs_cache_htable[i];
> + struct dfs_cache_entry *ce;
> +
> + hlist_for_each_entry_rcu(ce, l, ce_hlist)
> + flush_cache_ent(ce);
> + }
> + rcu_read_unlock();
> +}
> +
> +/*
> + * dfs cache /proc file
> + */
> +static int dfscache_proc_show(struct seq_file *m, void *v)
> +{
> + int bucket;
> + struct dfs_cache_entry *ce;
> + struct dfs_cache_tgt *t;
> +
> + seq_puts(m, "DFS cache\n---------\n");
> +
> + mutex_lock(&dfs_cache_list_lock);
> +
> + rcu_read_lock();
> + hash_for_each_rcu(dfs_cache_htable, bucket, ce, ce_hlist) {
> + seq_printf(m,
> + "cache entry: path=%s,type=%s,ttl=%d,etime=%ld,"
> + "interlink=%s,path_consumed=%d,expired=%s\n",
> + ce->ce_path,
> + ce->ce_srvtype == DFS_TYPE_ROOT ? "root" : "link",
> + ce->ce_ttl, ce->ce_etime.tv_nsec,
> + IS_INTERLINK_SET(ce->ce_flags) ? "yes" : "no",
> + ce->ce_path_consumed,
> + cache_entry_expired(ce) ? "yes" : "no");
> +
> + list_for_each_entry(t, &ce->ce_tlist, t_list) {
> + seq_printf(m, " %s%s\n",
> + t->t_name,
> + ce->ce_tgthint == t ? " (target hint)" : "");
> + }
> +
> + }
> + rcu_read_unlock();
> +
> + mutex_unlock(&dfs_cache_list_lock);
> + return 0;
> +}
> +
> +static ssize_t dfscache_proc_write(struct file *file, const char __user *buffer,
> + size_t count, loff_t *ppos)
> +{
> + char c;
> + int rc;
> +
> + rc = get_user(c, buffer);
> + if (rc)
> + return rc;
> +
> + if (c != '0')
> + return -EINVAL;
> +
> + cifs_dbg(FYI, "clearing dfs cache");
> + mutex_lock(&dfs_cache_list_lock);
> + flush_cache_ents();
> + mutex_unlock(&dfs_cache_list_lock);
> +
> + return count;
> +}
> +
> +static int dfscache_proc_open(struct inode *inode, struct file *file)
> +{
> + return single_open(file, dfscache_proc_show, NULL);
> +}
> +
> +const struct file_operations dfscache_proc_fops = {
> + .open = dfscache_proc_open,
> + .read = seq_read,
> + .llseek = seq_lseek,
> + .release = single_release,
> + .write = dfscache_proc_write,
> +};
> +
> +#ifdef CONFIG_CIFS_DEBUG2
> +static inline void dump_tgts(const struct dfs_cache_entry *ce)
> +{
> + struct dfs_cache_tgt *t;
> +
> + cifs_dbg(FYI, "target list:\n");
> + list_for_each_entry(t, &ce->ce_tlist, t_list) {
> + cifs_dbg(FYI, " %s%s\n", t->t_name,
> + ce->ce_tgthint == t ? " (target hint)" : "");
> + }
> +}
> +
> +static inline void dump_ce(const struct dfs_cache_entry *ce)
> +{
> + cifs_dbg(FYI, "cache entry: path=%s,type=%s,ttl=%d,etime=%ld,"
> + "interlink=%s,path_consumed=%d,expired=%s\n", ce->ce_path,
> + ce->ce_srvtype == DFS_TYPE_ROOT ? "root" : "link", ce->ce_ttl,
> + ce->ce_etime.tv_nsec,
> + IS_INTERLINK_SET(ce->ce_flags) ? "yes" : "no",
> + ce->ce_path_consumed,
> + cache_entry_expired(ce) ? "yes" : "no");
> + dump_tgts(ce);
> +}
> +
> +static inline void dump_refs(const struct dfs_info3_param *refs, int numrefs)
> +{
> + int i;
> +
> + cifs_dbg(FYI, "DFS referrals returned by the server:\n");
> + for (i = 0; i < numrefs; i++) {
> + const struct dfs_info3_param *ref = &refs[i];
> +
> + cifs_dbg(FYI,
> + "\n"
> + "flags: 0x%x\n"
> + "path_consumed: %d\n"
> + "server_type: 0x%x\n"
> + "ref_flag: 0x%x\n"
> + "path_name: %s\n"
> + "node_name: %s\n"
> + "ttl: %d (%dm)\n",
> + ref->flags, ref->path_consumed, ref->server_type,
> + ref->ref_flag, ref->path_name, ref->node_name,
> + ref->ttl, ref->ttl / 60);
> + }
> +}
> +#else
> +#define dump_tgts(e)
> +#define dump_ce(e)
> +#define dump_refs(r, n)
> +#endif
> +
> +/**
> + * dfs_cache_init - Initialize DFS referral cache.
> + *
> + * Return zero if initialized successfully, otherwise non-zero.
> + */
> +int dfs_cache_init(void)
> +{
> + int i;
> +
> + dfs_cache_slab = kmem_cache_create("cifs_dfs_cache",
> + sizeof(struct dfs_cache_entry), 0,
> + SLAB_HWCACHE_ALIGN, NULL);
> + if (!dfs_cache_slab)
> + return -ENOMEM;
> +
> + for (i = 0; i < DFS_CACHE_HTABLE_SIZE; i++)
> + INIT_HLIST_HEAD(&dfs_cache_htable[i]);
> +
> + INIT_LIST_HEAD(&dfs_cache.dc_vol_list);
> + mutex_init(&dfs_cache.dc_lock);
> + INIT_DELAYED_WORK(&dfs_cache.dc_refresh, refresh_cache_worker);
> + dfs_cache.dc_ttl = -1;
> + dfs_cache.dc_nlsc = load_nls_default();
> +
> + cifs_dbg(FYI, "%s: initialized DFS referral cache\n", __func__);
> + return 0;
> +}
> +
> +static inline unsigned int cache_entry_hash(const void *data, int size)
> +{
> + unsigned int h;
> +
> + h = jhash(data, size, 0);
> + return h & (DFS_CACHE_HTABLE_SIZE - 1);
> +}
> +
> +/* Check whether second path component of @path is SYSVOL or NETLOGON */
> +static inline bool is_sysvol_or_netlogon(const char *path)
> +{
> + const char *s;
> + char sep = path[0];
> +
> + s = strchr(path + 1, sep) + 1;
> + return !strncasecmp(s, "sysvol", strlen("sysvol")) ||
> + !strncasecmp(s, "netlogon", strlen("netlogon"));
> +}
> +
> +/* Return target hint of a DFS cache entry */
> +static inline char *get_tgt_name(const struct dfs_cache_entry *ce)
> +{
> + struct dfs_cache_tgt *t = ce->ce_tgthint;
> +
> + return t ? t->t_name : ERR_PTR(-ENOENT);
> +}
> +
> +/* Return expire time out of a new entry's TTL */
> +static inline struct timespec64 get_expire_time(int ttl)
> +{
> + struct timespec64 ts = {
> + .tv_sec = ttl,
> + .tv_nsec = 0,
> + };
> +
> + return timespec64_add(current_kernel_time64(), ts);
> +}
> +
> +/* Allocate a new DFS target */
> +static inline struct dfs_cache_tgt *alloc_tgt(const char *name)
> +{
> + struct dfs_cache_tgt *t;
> +
> + t = kmalloc(sizeof(*t), GFP_KERNEL);
> + if (!t)
> + return ERR_PTR(-ENOMEM);
> + t->t_name = kstrndup(name, strlen(name), GFP_KERNEL);
> + if (!t->t_name) {
> + kfree(t);
> + return ERR_PTR(-ENOMEM);
> + }
> + INIT_LIST_HEAD(&t->t_list);
> + return t;
> +}
> +
> +/*
> + * Copy DFS referral information to a cache entry and conditionally update
> + * target hint.
> + */
> +static int copy_ref_data(const struct dfs_info3_param *refs, int numrefs,
> + struct dfs_cache_entry *ce, const char *tgthint)
> +{
> + int i;
> +
> + ce->ce_ttl = refs[0].ttl;
> + ce->ce_etime = get_expire_time(ce->ce_ttl);
> + ce->ce_srvtype = refs[0].server_type;
> + ce->ce_flags = refs[0].ref_flag;
> + ce->ce_path_consumed = refs[0].path_consumed;
> +
> + for (i = 0; i < numrefs; i++) {
> + struct dfs_cache_tgt *t;
> +
> + t = alloc_tgt(refs[i].node_name);
> + if (IS_ERR(t)) {
> + free_tgts(ce);
> + return PTR_ERR(t);
> + }
> + if (tgthint && !strncasecmp(t->t_name, tgthint,
> + strlen(tgthint))) {
> + list_add(&t->t_list, &ce->ce_tlist);
> + tgthint = NULL;
> + } else {
> + list_add_tail(&t->t_list, &ce->ce_tlist);
> + }
> + ce->ce_numtgts++;
> + }
> +
> + ce->ce_tgthint = list_first_entry_or_null(&ce->ce_tlist,
> + struct dfs_cache_tgt, t_list);
> +
> + return 0;
> +}
> +
> +/* Allocate a new cache entry */
> +static struct dfs_cache_entry *
> +alloc_cache_entry(const char *path, const struct dfs_info3_param *refs,
> + int numrefs)
> +{
> + struct dfs_cache_entry *ce;
> + int rc;
> +
> + ce = kmem_cache_zalloc(dfs_cache_slab, GFP_KERNEL);
> + if (!ce)
> + return ERR_PTR(-ENOMEM);
> +
> + ce->ce_path = kstrdup_const(path, GFP_KERNEL);
> + if (!ce->ce_path) {
> + kfree(ce);
> + return ERR_PTR(-ENOMEM);
> + }
> + INIT_HLIST_NODE(&ce->ce_hlist);
> + INIT_LIST_HEAD(&ce->ce_tlist);
> +
> + rc = copy_ref_data(refs, numrefs, ce, NULL);
> + if (rc) {
> + kfree(ce->ce_path);
> + kfree(ce);
> + ce = ERR_PTR(rc);
> + }
> + return ce;
> +}
> +
> +static void remove_oldest_entry(void)
> +{
> + int bucket;
> + struct dfs_cache_entry *ce;
> + struct dfs_cache_entry *to_del = NULL;
> +
> + rcu_read_lock();
> + hash_for_each_rcu(dfs_cache_htable, bucket, ce, ce_hlist) {
> + if (!to_del || timespec64_compare(&ce->ce_etime,
> + &to_del->ce_etime) < 0)
> + to_del = ce;
> + }
> + if (!to_del) {
> + cifs_dbg(FYI, "%s: no entry to remove", __func__);
> + goto out;
> + }
> + cifs_dbg(FYI, "%s: removing entry", __func__);
> + dump_ce(to_del);
> + flush_cache_ent(to_del);
> +out:
> + rcu_read_unlock();
> +}
> +
> +/* Add a new DFS cache entry */
> +static inline struct dfs_cache_entry *
> +add_cache_entry(unsigned int hash, const char *path,
> + const struct dfs_info3_param *refs, int numrefs)
> +{
> + struct dfs_cache_entry *ce;
> +
> + ce = alloc_cache_entry(path, refs, numrefs);
> + if (IS_ERR(ce))
> + return ce;
> +
> + hlist_add_head_rcu(&ce->ce_hlist, &dfs_cache_htable[hash]);
> +
> + mutex_lock(&dfs_cache.dc_lock);
> + if (dfs_cache.dc_ttl < 0) {
> + dfs_cache.dc_ttl = ce->ce_ttl;
> + queue_delayed_work(cifsiod_wq, &dfs_cache.dc_refresh,
> + dfs_cache.dc_ttl * HZ);
> + } else {
> + dfs_cache.dc_ttl = min_t(int, dfs_cache.dc_ttl, ce->ce_ttl);
> + mod_delayed_work(cifsiod_wq, &dfs_cache.dc_refresh,
> + dfs_cache.dc_ttl * HZ);
> + }
> + mutex_unlock(&dfs_cache.dc_lock);
> +
> + return ce;
> +}
> +
> +static struct dfs_cache_entry *__find_cache_entry(unsigned int hash,
> + const char *path, int len)
> +{
> + struct dfs_cache_entry *ce;
> + bool found = false;
> +
> + rcu_read_lock();
> + hlist_for_each_entry_rcu(ce, &dfs_cache_htable[hash], ce_hlist) {
> + if (!strncasecmp(ce->ce_path, path, len)) {
> +#ifdef CONFIG_CIFS_DEBUG2
> + char *name = get_tgt_name(ce);
> +
> + if (unlikely(IS_ERR(name))) {
> + rcu_read_unlock();
> + return ERR_CAST(name);
> + }
> + cifs_dbg(FYI, "%s: cache hit\n", __func__);
> + cifs_dbg(FYI, "%s: target hint: %s\n", __func__, name);
> +#endif
> + found = true;
> + break;
> + }
> + }
> + rcu_read_unlock();
> + return found ? ce : ERR_PTR(-ENOENT);
> +}
> +
> +/*
> + * Find a DFS cache entry in hash table and optionally check prefix path against
> + * @path.
> + * Use whole path components in the match.
> + * Return ERR_PTR(-ENOENT) if the entry is not found.
> + */
> +static inline struct dfs_cache_entry *find_cache_entry(const char *path,
> + unsigned int *hash)
> +{
> + int len = strlen(path);
> +
> + *hash = cache_entry_hash(path, len);
> + return __find_cache_entry(*hash, path, len);
> +}
> +
> +static inline void destroy_slab_cache(void)
> +{
> + rcu_barrier();
> + kmem_cache_destroy(dfs_cache_slab);
> +}
> +
> +static inline void free_vol(struct dfs_cache_vol_info *vi)
> +{
> + list_del(&vi->vi_list);
> + kfree(vi->vi_fullpath);
> + cifs_cleanup_volume_info_contents(&vi->vi_vol);
> + kfree(vi);
> +}
> +
> +static inline void free_vol_list(void)
> +{
> + struct dfs_cache_vol_info *vi, *nvi;
> +
> + list_for_each_entry_safe(vi, nvi, &dfs_cache.dc_vol_list, vi_list)
> + free_vol(vi);
> +}
> +
> +/**
> + * dfs_cache_destroy - destroy DFS referral cache
> + */
> +void dfs_cache_destroy(void)
> +{
> + cancel_delayed_work_sync(&dfs_cache.dc_refresh);
> + unload_nls(dfs_cache.dc_nlsc);
> + free_vol_list();
> + mutex_destroy(&dfs_cache.dc_lock);
> +
> + flush_cache_ents();
> + destroy_slab_cache();
> + mutex_destroy(&dfs_cache_list_lock);
> +
> + cifs_dbg(FYI, "%s: destroyed DFS referral cache\n", __func__);
> +}
> +
> +static inline struct dfs_cache_entry *
> +__update_cache_entry(const char *path, const struct dfs_info3_param *refs,
> + int numrefs)
> +{
> + int rc;
> + unsigned int h;
> + struct dfs_cache_entry *ce;
> + char *s, *th = NULL;
> +
> + ce = find_cache_entry(path, &h);
> + if (IS_ERR(ce))
> + return ce;
> +
> + if (ce->ce_tgthint) {
> + s = ce->ce_tgthint->t_name;
> + th = kstrndup(s, strlen(s), GFP_KERNEL);
> + if (!th)
> + return ERR_PTR(-ENOMEM);
> + }
> +
> + free_tgts(ce);
> + ce->ce_numtgts = 0;
> +
> + rc = copy_ref_data(refs, numrefs, ce, th);
> + kfree(th);
> +
> + if (rc)
> + ce = ERR_PTR(rc);
> +
> + return ce;
> +}
> +
> +/* Update an expired cache entry by getting a new DFS referral from server */
> +static struct dfs_cache_entry *
> +update_cache_entry(const unsigned int xid, struct cifs_ses *ses,
> + const struct nls_table *nls_codepage, int remap,
> + const char *path, struct dfs_cache_entry *ce)
> +{
> + int rc;
> + struct dfs_info3_param *refs = NULL;
> + int numrefs = 0;
> +
> + cifs_dbg(FYI, "%s: update expired cache entry\n", __func__);
> + /*
> + * Check if caller provided enough parameters to update an expired
> + * entry.
> + */
> + if (!ses || !ses->server || !ses->server->ops->get_dfs_refer)
> + return ERR_PTR(-ETIME);
> + if (unlikely(!nls_codepage))
> + return ERR_PTR(-ETIME);
> +
> + cifs_dbg(FYI, "%s: DFS referral request for %s\n", __func__, path);
> +
> + rc = ses->server->ops->get_dfs_refer(xid, ses, path, &refs, &numrefs,
> + nls_codepage, remap);
> + if (rc)
> + ce = ERR_PTR(rc);
> + else
> + ce = __update_cache_entry(path, refs, numrefs);
> +
> + dump_refs(refs, numrefs);
> + free_dfs_info_array(refs, numrefs);
> +
> + return ce;
> +}
> +
> +/*
> + * Find, create or update a DFS cache entry.
> + *
> + * If the entry wasn't found, it will create a new one. Or if it was found but
> + * expired, then it will update the entry accordingly.
> + *
> + * For interlinks, __cifs_dfs_mount() and expand_dfs_referral() are supposed to
> + * handle them properly.
> + */
> +static struct dfs_cache_entry *
> +do_dfs_cache_find(const unsigned int xid, struct cifs_ses *ses,
> + const struct nls_table *nls_codepage, int remap,
> + const char *path, bool noreq)
> +{
> + int rc;
> + unsigned int h;
> + struct dfs_cache_entry *ce;
> + struct dfs_info3_param *nrefs;
> + int numnrefs;
> +
> + cifs_dbg(FYI, "%s: search path: %s\n", __func__, path);
> +
> + ce = find_cache_entry(path, &h);
> + if (IS_ERR(ce)) {
> + cifs_dbg(FYI, "%s: cache miss\n", __func__);
> + /*
> + * If @noreq is set, no requests will be sent to the server for
> + * either updating or getting a new DFS referral.
> + */
> + if (noreq)
> + return ce;
> + /*
> + * No cache entry was found, so check for valid parameters that
> + * will be required to get a new DFS referral and then create a
> + * new cache entry.
> + */
> + if (!ses || !ses->server || !ses->server->ops->get_dfs_refer) {
> + ce = ERR_PTR(-ENOSYS);
> + return ce;
> + }
> + if (unlikely(!nls_codepage)) {
> + ce = ERR_PTR(-EINVAL);
> + return ce;
> + }
> +
> + nrefs = NULL;
> + numnrefs = 0;
> +
> + cifs_dbg(FYI, "%s: DFS referral request for %s\n", __func__,
> + path);
> +
> + rc = ses->server->ops->get_dfs_refer(xid, ses, path, &nrefs,
> + &numnrefs, nls_codepage,
> + remap);
> + if (rc) {
> + ce = ERR_PTR(rc);
> + return ce;
> + }
> +
> + dump_refs(nrefs, numnrefs);
> +
> + cifs_dbg(FYI, "%s: new cache entry\n", __func__);
> +
> + if (dfs_cache_count >= DFS_CACHE_MAX_ENTRIES) {
> + cifs_dbg(FYI, "%s: reached max cache size (%d)",
> + __func__, DFS_CACHE_MAX_ENTRIES);
> + remove_oldest_entry();
> + }
> + ce = add_cache_entry(h, path, nrefs, numnrefs);
> + free_dfs_info_array(nrefs, numnrefs);
> +
> + if (IS_ERR(ce))
> + return ce;
> +
> + dfs_cache_count++;
> + }
> +
> + dump_ce(ce);
> +
> + /* Just return the found cache entry in case @noreq is set */
> + if (noreq)
> + return ce;
> +
> + if (cache_entry_expired(ce)) {
> + cifs_dbg(FYI, "%s: expired cache entry\n", __func__);
> + ce = update_cache_entry(xid, ses, nls_codepage, remap, path,
> + ce);
> + if (IS_ERR(ce)) {
> + cifs_dbg(FYI, "%s: failed to update expired entry\n",
> + __func__);
> + }
> + }
> + return ce;
> +}
> +
> +/* Set up a new DFS referral from a given cache entry */
> +static int setup_ref(const char *path, const struct dfs_cache_entry *ce,
> + struct dfs_info3_param *ref, const char *tgt)
> +{
> + int rc;
> +
> + cifs_dbg(FYI, "%s: set up new ref\n", __func__);
> +
> + memset(ref, 0, sizeof(*ref));
> +
> + ref->path_name = kstrndup(path, strlen(path), GFP_KERNEL);
> + if (!ref->path_name)
> + return -ENOMEM;
> +
> + ref->path_consumed = ce->ce_path_consumed;
> +
> + ref->node_name = kstrndup(tgt, strlen(tgt), GFP_KERNEL);
> + if (!ref->node_name) {
> + rc = -ENOMEM;
> + goto err_free_path;
> + }
> +
> + ref->ttl = ce->ce_ttl;
> + ref->server_type = ce->ce_srvtype;
> + ref->ref_flag = ce->ce_flags;
> +
> + return 0;
> +
> +err_free_path:
> + kfree(ref->path_name);
> + ref->path_name = NULL;
> + return rc;
> +}
> +
> +/* Return target list of a DFS cache entry */
> +static int get_tgt_list(const struct dfs_cache_entry *ce,
> + struct dfs_cache_tgt_list *tl)
> +{
> + int rc;
> + struct list_head *head = &tl->tl_list;
> + struct dfs_cache_tgt *t;
> + struct dfs_cache_tgt_iterator *it, *nit;
> +
> + memset(tl, 0, sizeof(*tl));
> + INIT_LIST_HEAD(head);
> +
> + list_for_each_entry(t, &ce->ce_tlist, t_list) {
> + it = kzalloc(sizeof(*it), GFP_KERNEL);
> + if (!it) {
> + rc = -ENOMEM;
> + goto err_free_it;
> + }
> +
> + it->it_name = kstrndup(t->t_name, strlen(t->t_name),
> + GFP_KERNEL);
> + if (!it->it_name) {
> + rc = -ENOMEM;
> + goto err_free_it;
> + }
> +
> + if (ce->ce_tgthint == t)
> + list_add(&it->it_list, head);
> + else
> + list_add_tail(&it->it_list, head);
> + }
> + tl->tl_numtgts = ce->ce_numtgts;
> +
> + return 0;
> +
> +err_free_it:
> + list_for_each_entry_safe(it, nit, head, it_list) {
> + kfree(it->it_name);
> + kfree(it);
> + }
> + return rc;
> +}
> +
> +/**
> + * dfs_cache_find - find a DFS cache entry
> + *
> + * If it doesn't find the cache entry, then it will get a DFS referral
> + * for @path and create a new entry.
> + *
> + * In case the cache entry exists but expired, it will get a DFS referral
> + * for @path and then update the respective cache entry.
> + *
> + * These parameters are passed down to the get_dfs_refer() call if it
> + * needs to be issued:
> + * @xid: syscall xid
> + * @ses: smb session to issue the request on
> + * @nls_codepage: charset conversion
> + * @remap: path character remapping type
> + * @path: path to lookup in DFS referral cache.
> + *
> + * @ref: when non-NULL, store single DFS referral result in it.
> + * @tgt_list: when non-NULL, store complete DFS target list in it.
> + *
> + * Return zero if the target was found, otherwise non-zero.
> + */
> +int dfs_cache_find(const unsigned int xid, struct cifs_ses *ses,
> + const struct nls_table *nls_codepage, int remap,
> + const char *path, struct dfs_info3_param *ref,
> + struct dfs_cache_tgt_list *tgt_list)
> +{
> + int rc;
> + char *npath;
> + struct dfs_cache_entry *ce;
> +
> + if (unlikely(!is_path_valid(path)))
> + return -EINVAL;
> +
> + rc = get_normalized_path(path, &npath);
> + if (rc)
> + return rc;
> +
> + mutex_lock(&dfs_cache_list_lock);
> + ce = do_dfs_cache_find(xid, ses, nls_codepage, remap, npath, false);
> + if (!IS_ERR(ce)) {
> + if (ref)
> + rc = setup_ref(path, ce, ref, get_tgt_name(ce));
> + else
> + rc = 0;
> + if (!rc && tgt_list)
> + rc = get_tgt_list(ce, tgt_list);
> + } else {
> + rc = PTR_ERR(ce);
> + }
> + mutex_unlock(&dfs_cache_list_lock);
> + free_normalized_path(path, npath);
> + return rc;
> +}
> +
> +/**
> + * dfs_cache_noreq_find - find a DFS cache entry without sending any requests to
> + * the currently connected server.
> + *
> + * NOTE: This function will neither update a cache entry in case it was
> + * expired, nor create a new cache entry if @path hasn't been found. It heavily
> + * relies on an existing cache entry.
> + *
> + * @path: path to lookup in the DFS referral cache.
> + * @ref: when non-NULL, store single DFS referral result in it.
> + * @tgt_list: when non-NULL, store complete DFS target list in it.
> + *
> + * Return 0 if successful.
> + * Return -ENOENT if the entry was not found.
> + * Return non-zero for other errors.
> + */
> +int dfs_cache_noreq_find(const char *path, struct dfs_info3_param *ref,
> + struct dfs_cache_tgt_list *tgt_list)
> +{
> + int rc;
> + char *npath;
> + struct dfs_cache_entry *ce;
> +
> + if (unlikely(!is_path_valid(path)))
> + return -EINVAL;
> +
> + rc = get_normalized_path(path, &npath);
> + if (rc)
> + return rc;
> +
> + mutex_lock(&dfs_cache_list_lock);
> + ce = do_dfs_cache_find(0, NULL, NULL, 0, npath, true);
> + if (IS_ERR(ce)) {
> + rc = PTR_ERR(ce);
> + goto out;
> + }
> +
> + if (ref)
> + rc = setup_ref(path, ce, ref, get_tgt_name(ce));
> + else
> + rc = 0;
> + if (!rc && tgt_list)
> + rc = get_tgt_list(ce, tgt_list);
> +out:
> + mutex_unlock(&dfs_cache_list_lock);
> + free_normalized_path(path, npath);
> + return rc;
> +}
> +
> +/**
> + * dfs_cache_update_tgthint - update target hint of a DFS cache entry
> + *
> + * If it doesn't find the cache entry, then it will get a DFS referral for @path
> + * and create a new entry.
> + *
> + * In case the cache entry exists but expired, it will get a DFS referral
> + * for @path and then update the respective cache entry.
> + *
> + * @xid: syscall id
> + * @ses: smb session
> + * @nls_codepage: charset conversion
> + * @remap: type of character remapping for paths
> + * @path: path to lookup in DFS referral cache.
> + * @it: DFS target iterator
> + *
> + * Return zero if the target hint was updated successfully, otherwise non-zero.
> + */
> +int dfs_cache_update_tgthint(const unsigned int xid, struct cifs_ses *ses,
> + const struct nls_table *nls_codepage, int remap,
> + const char *path,
> + const struct dfs_cache_tgt_iterator *it)
> +{
> + int rc;
> + char *npath;
> + struct dfs_cache_entry *ce;
> + struct dfs_cache_tgt *t;
> +
> + if (unlikely(!is_path_valid(path)))
> + return -EINVAL;
> +
> + rc = get_normalized_path(path, &npath);
> + if (rc)
> + return rc;
> +
> + cifs_dbg(FYI, "%s: path: %s\n", __func__, npath);
> +
> + mutex_lock(&dfs_cache_list_lock);
> + ce = do_dfs_cache_find(xid, ses, nls_codepage, remap, npath, false);
> + if (IS_ERR(ce)) {
> + rc = PTR_ERR(ce);
> + goto out;
> + }
> +
> + rc = 0;
> +
> + t = ce->ce_tgthint;
> +
> + if (likely(!strncasecmp(it->it_name, t->t_name, strlen(t->t_name))))
> + goto out;
> +
> + list_for_each_entry(t, &ce->ce_tlist, t_list) {
> + if (!strncasecmp(t->t_name, it->it_name, strlen(it->it_name))) {
> + ce->ce_tgthint = t;
> + cifs_dbg(FYI, "%s: new target hint: %s\n", __func__,
> + it->it_name);
> + break;
> + }
> + }
> +
> +out:
> + mutex_unlock(&dfs_cache_list_lock);
> + free_normalized_path(path, npath);
> + return rc;
> +}
> +
> +/**
> + * dfs_cache_noreq_update_tgthint - update target hint of a DFS cache entry
> + * without sending any requests to the currently connected server.
> + *
> + * NOTE: This function will neither update a cache entry in case it was
> + * expired, nor create a new cache entry if @path hasn't been found. It heavily
> + * relies on an existing cache entry.
> + *
> + * @path: path to lookup in DFS referral cache.
> + * @it: target iterator which contains the target hint to update the cache
> + * entry with.
> + *
> + * Return zero if the target hint was updated successfully, otherwise non-zero.
> + */
> +int dfs_cache_noreq_update_tgthint(const char *path,
> + const struct dfs_cache_tgt_iterator *it)
> +{
> + int rc;
> + char *npath;
> + struct dfs_cache_entry *ce;
> + struct dfs_cache_tgt *t;
> +
> + if (unlikely(!is_path_valid(path)) || !it)
> + return -EINVAL;
> +
> + rc = get_normalized_path(path, &npath);
> + if (rc)
> + return rc;
> +
> + cifs_dbg(FYI, "%s: path: %s\n", __func__, npath);
> +
> + mutex_lock(&dfs_cache_list_lock);
> +
> + ce = do_dfs_cache_find(0, NULL, NULL, 0, npath, true);
> + if (IS_ERR(ce)) {
> + rc = PTR_ERR(ce);
> + goto out;
> + }
> +
> + rc = 0;
> +
> + t = ce->ce_tgthint;
> +
> + if (unlikely(!strncasecmp(it->it_name, t->t_name, strlen(t->t_name))))
> + goto out;
> +
> + list_for_each_entry(t, &ce->ce_tlist, t_list) {
> + if (!strncasecmp(t->t_name, it->it_name, strlen(it->it_name))) {
> + ce->ce_tgthint = t;
> + cifs_dbg(FYI, "%s: new target hint: %s\n", __func__,
> + it->it_name);
> + break;
> + }
> + }
> +
> +out:
> + mutex_unlock(&dfs_cache_list_lock);
> + free_normalized_path(path, npath);
> + return rc;
> +}
> +
> +/**
> + * dfs_cache_get_tgt_referral - returns a DFS referral (@ref) from a given
> + * target iterator (@it).
> + *
> + * @path: path to lookup in DFS referral cache.
> + * @it: DFS target iterator.
> + * @ref: DFS referral pointer to set up the gathered information.
> + *
> + * Return zero if the DFS referral was set up correctly, otherwise non-zero.
> + */
> +int dfs_cache_get_tgt_referral(const char *path,
> + const struct dfs_cache_tgt_iterator *it,
> + struct dfs_info3_param *ref)
> +{
> + int rc;
> + char *npath;
> + struct dfs_cache_entry *ce;
> + unsigned int h;
> +
> + if (!it || !ref)
> + return -EINVAL;
> + if (unlikely(!is_path_valid(path)))
> + return -EINVAL;
> +
> + rc = get_normalized_path(path, &npath);
> + if (rc)
> + return rc;
> +
> + cifs_dbg(FYI, "%s: path: %s\n", __func__, npath);
> +
> + mutex_lock(&dfs_cache_list_lock);
> +
> + ce = find_cache_entry(npath, &h);
> + if (IS_ERR(ce)) {
> + rc = PTR_ERR(ce);
> + goto out;
> + }
> +
> + cifs_dbg(FYI, "%s: target name: %s\n", __func__, it->it_name);
> +
> + rc = setup_ref(path, ce, ref, it->it_name);
> +
> +out:
> + mutex_unlock(&dfs_cache_list_lock);
> + free_normalized_path(path, npath);
> + return rc;
> +}
> +
> +static int dup_vol(struct smb_vol *vol, struct smb_vol *new)
> +{
> + memcpy(new, vol, sizeof(*new));
> +
> + if (vol->username) {
> + new->username = kstrndup(vol->username, strlen(vol->username),
> + GFP_KERNEL);
> + if (!new->username)
> + return -ENOMEM;
> + }
> + if (vol->password) {
> + new->password = kstrndup(vol->password, strlen(vol->password),
> + GFP_KERNEL);
> + if (!new->password)
> + goto err_free_username;
> + }
> + if (vol->UNC) {
> + cifs_dbg(FYI, "%s: vol->UNC: %s\n", __func__, vol->UNC);
> + new->UNC = kstrndup(vol->UNC, strlen(vol->UNC), GFP_KERNEL);
> + if (!new->UNC)
> + goto err_free_password;
> + }
> + if (vol->domainname) {
> + new->domainname = kstrndup(vol->domainname,
> + strlen(vol->domainname), GFP_KERNEL);
> + if (!new->domainname)
> + goto err_free_unc;
> + }
> + if (vol->iocharset) {
> + new->iocharset = kstrndup(vol->iocharset,
> + strlen(vol->iocharset), GFP_KERNEL);
> + if (!new->iocharset)
> + goto err_free_domainname;
> + }
> + if (vol->prepath) {
> + cifs_dbg(FYI, "%s: vol->prepath: %s\n", __func__, vol->prepath);
> + new->prepath = kstrndup(vol->prepath, strlen(vol->prepath),
> + GFP_KERNEL);
> + if (!new->prepath)
> + goto err_free_iocharset;
> + }
> +
> + return 0;
> +
> +err_free_iocharset:
> + kfree(new->iocharset);
> +err_free_domainname:
> + kfree(new->domainname);
> +err_free_unc:
> + kfree(new->UNC);
> +err_free_password:
> + kfree(new->password);
> +err_free_username:
> + kfree(new->username);
> + kfree(new);
> + return -ENOMEM;
> +}
> +
> +/**
> + * dfs_cache_add_vol - add a cifs volume during mount() that will be handled by
> + * DFS cache refresh worker.
> + *
> + * @vol: cifs volume.
> + * @fullpath: origin full path.
> + *
> + * Return zero if volume was set up correctly, otherwise non-zero.
> + */
> +int dfs_cache_add_vol(struct smb_vol *vol, const char *fullpath)
> +{
> + int rc;
> + struct dfs_cache_vol_info *vi;
> +
> + if (!vol || !fullpath)
> + return -EINVAL;
> +
> + cifs_dbg(FYI, "%s: fullpath: %s\n", __func__, fullpath);
> +
> + vi = kzalloc(sizeof(*vi), GFP_KERNEL);
> + if (!vi)
> + return -ENOMEM;
> +
> + vi->vi_fullpath = kstrndup(fullpath, strlen(fullpath), GFP_KERNEL);
> + if (!vi->vi_fullpath) {
> + rc = -ENOMEM;
> + goto err_free_vi;
> + }
> +
> + rc = dup_vol(vol, &vi->vi_vol);
> + if (rc)
> + goto err_free_fullpath;
> +
> + mutex_lock(&dfs_cache.dc_lock);
> + list_add_tail(&vi->vi_list, &dfs_cache.dc_vol_list);
> + mutex_unlock(&dfs_cache.dc_lock);
> + return 0;
> +
> +err_free_fullpath:
> + kfree(vi->vi_fullpath);
> +err_free_vi:
> + kfree(vi);
> + return rc;
> +}
> +
> +static inline struct dfs_cache_vol_info *find_vol(const char *fullpath)
> +{
> + struct dfs_cache_vol_info *vi;
> +
> + list_for_each_entry(vi, &dfs_cache.dc_vol_list, vi_list) {
> + cifs_dbg(FYI, "%s: vi->vi_fullpath: %s\n", __func__,
> + vi->vi_fullpath);
> + if (!strncasecmp(vi->vi_fullpath, fullpath,
> + strlen(vi->vi_fullpath)))
> + return vi;
> + }
> + return ERR_PTR(-ENOENT);
> +}
> +
> +/**
> + * dfs_cache_update_vol - update vol info in DFS cache after failover
> + *
> + * @fullpath: fullpath to look up in volume list.
> + * @server: TCP ses pointer.
> + *
> + * Return zero if volume was updated, otherwise non-zero.
> + */
> +int dfs_cache_update_vol(const char *fullpath, struct TCP_Server_Info *server)
> +{
> + int rc;
> + struct dfs_cache_vol_info *vi;
> +
> + if (!fullpath || !server)
> + return -EINVAL;
> +
> + cifs_dbg(FYI, "%s: fullpath: %s\n", __func__, fullpath);
> +
> + mutex_lock(&dfs_cache.dc_lock);
> +
> + vi = find_vol(fullpath);
> + if (IS_ERR(vi)) {
> + rc = PTR_ERR(vi);
> + goto out;
> + }
> +
> + cifs_dbg(FYI, "%s: updating volume info\n", __func__);
> + memcpy(&vi->vi_vol.dstaddr, &server->dstaddr,
> + sizeof(vi->vi_vol.dstaddr));
> + rc = 0;
> +
> +out:
> + mutex_unlock(&dfs_cache.dc_lock);
> + return rc;
> +}
> +
> +/**
> + * dfs_cache_del_vol - remove volume info in DFS cache during umount()
> + *
> + * @fullpath: fullpath to look up in volume list.
> + *
> + * Return zero if volume was deleted, otherwise non-zero.
> + */
> +void dfs_cache_del_vol(const char *fullpath)
> +{
> + struct dfs_cache_vol_info *vi;
> +
> + if (!fullpath || !*fullpath)
> + return;
> +
> + cifs_dbg(FYI, "%s: fullpath: %s\n", __func__, fullpath);
> +
> + mutex_lock(&dfs_cache.dc_lock);
> + vi = find_vol(fullpath);
> + if (!IS_ERR(vi))
> + free_vol(vi);
> + mutex_unlock(&dfs_cache.dc_lock);
> +}
> +
> +/* Get all tcons that are within a DFS namespace and can be refreshed */
> +static void get_tcons(struct TCP_Server_Info *server, struct list_head *head)
> +{
> + struct cifs_ses *ses;
> + struct cifs_tcon *tcon;
> +
> + INIT_LIST_HEAD(head);
> +
> + spin_lock(&cifs_tcp_ses_lock);
> + list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
> + list_for_each_entry(tcon, &ses->tcon_list, tcon_list) {
> + if (!tcon->need_reconnect && !tcon->need_reopen_files &&
> + tcon->dfs_path) {
> + tcon->tc_count++;
> + list_add_tail(&tcon->ulist, head);
> + }
> + }
> + if (ses->tcon_ipc && !ses->tcon_ipc->need_reconnect &&
> + ses->tcon_ipc->dfs_path) {
> + list_add_tail(&ses->tcon_ipc->ulist, head);
> + }
> + }
> + spin_unlock(&cifs_tcp_ses_lock);
> +}
> +
> +/* Refresh DFS cache entry from a given tcon */
> +static void do_refresh_tcon(struct dfs_cache *dc, struct cifs_tcon *tcon)
> +{
> + int rc = 0;
> + unsigned int xid;
> + char *path, *npath;
> + unsigned int h;
> + struct dfs_cache_entry *ce;
> + struct dfs_info3_param *refs = NULL;
> + int numrefs = 0;
> +
> + xid = get_xid();
> +
> + path = tcon->dfs_path + 1;
> +
> + cifs_dbg(FYI, "%s: dfs path: %s\n", __func__, path);
> +
> + rc = get_normalized_path(path, &npath);
> + if (rc)
> + goto out;
> +
> + mutex_lock(&dfs_cache_list_lock);
> + ce = find_cache_entry(npath, &h);
> + mutex_unlock(&dfs_cache_list_lock);
> +
> + if (IS_ERR(ce)) {
> + rc = PTR_ERR(ce);
> + goto out;
> + }
> +
> + if (!cache_entry_expired(ce))
> + goto out;
> +
> + if (unlikely(!tcon->ses->server->ops->get_dfs_refer)) {
> + rc = -ENOSYS;
> + } else {
> + rc = tcon->ses->server->ops->get_dfs_refer(xid, tcon->ses, path,
> + &refs, &numrefs,
> + dc->dc_nlsc,
> + tcon->remap);
> + if (!rc) {
> + mutex_lock(&dfs_cache_list_lock);
> + ce = __update_cache_entry(npath, refs, numrefs);
> + mutex_unlock(&dfs_cache_list_lock);
> + dump_refs(refs, numrefs);
> + free_dfs_info_array(refs, numrefs);
> + if (IS_ERR(ce))
> + rc = PTR_ERR(ce);
> + }
> + }
> + if (rc)
> + cifs_dbg(FYI, "%s: failed to update expired entry\n", __func__);
> +out:
> + free_xid(xid);
> + free_normalized_path(path, npath);
> +}
> +
> +/*
> + * Worker that will refresh DFS cache based on lowest TTL value from a DFS
> + * referral.
> + *
> + * FIXME: ensure that all requests are sent to DFS root for refreshing the
> + * cache.
> + */
> +static void refresh_cache_worker(struct work_struct *work)
> +{
> + struct dfs_cache *dc = container_of(work, struct dfs_cache,
> + dc_refresh.work);
> + struct dfs_cache_vol_info *vi;
> + struct TCP_Server_Info *server;
> + LIST_HEAD(list);
> + struct cifs_tcon *tcon, *ntcon;
> +
> + cifs_dbg(FYI, "%s: refreshing DFS referral cache\n", __func__);
> +
> + mutex_lock(&dc->dc_lock);
> +
> + list_for_each_entry(vi, &dc->dc_vol_list, vi_list) {
> + cifs_dbg(FYI, "%s: vol path: %s\n", __func__, vi->vi_fullpath);
> + server = cifs_find_tcp_session(&vi->vi_vol);
> + if (!server)
> + continue;
> + cifs_dbg(FYI, "%s: found a tcp ses: %p\n", __func__, server);
> + if (server->tcpStatus != CifsGood)
> + goto next;
> + get_tcons(server, &list);
> + list_for_each_entry_safe(tcon, ntcon, &list, ulist) {
> + do_refresh_tcon(dc, tcon);
> + list_del_init(&tcon->ulist);
> + cifs_put_tcon(tcon);
> + }
> +next:
> + cifs_put_tcp_session(server, 0);
> + }
> + queue_delayed_work(cifsiod_wq, &dc->dc_refresh, dc->dc_ttl * HZ);
> + mutex_unlock(&dc->dc_lock);
> +
> + cifs_dbg(FYI, "%s: finished refreshing DFS referral cache\n", __func__);
> +}
> diff --git a/fs/cifs/dfs_cache.h b/fs/cifs/dfs_cache.h
> new file mode 100644
> index 000000000000..22f366514f3a
> --- /dev/null
> +++ b/fs/cifs/dfs_cache.h
> @@ -0,0 +1,97 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/*
> + * DFS referral cache routines
> + *
> + * Copyright (c) 2018 Paulo Alcantara <palcantara@xxxxxxx>
> + */
> +
> +#ifndef _CIFS_DFS_CACHE_H
> +#define _CIFS_DFS_CACHE_H
> +
> +#include <linux/nls.h>
> +#include <linux/list.h>
> +#include "cifsglob.h"
> +
> +struct dfs_cache_tgt_list {
> + int tl_numtgts;
> + struct list_head tl_list;
> +};
> +
> +struct dfs_cache_tgt_iterator {
> + char *it_name;
> + struct list_head it_list;
> +};
> +
> +extern int dfs_cache_init(void);
> +extern void dfs_cache_destroy(void);
> +extern const struct file_operations dfscache_proc_fops;
> +
> +extern int dfs_cache_find(const unsigned int xid, struct cifs_ses *ses,
> + const struct nls_table *nls_codepage, int remap,
> + const char *path, struct dfs_info3_param *ref,
> + struct dfs_cache_tgt_list *tgt_list);
> +extern int dfs_cache_noreq_find(const char *path, struct dfs_info3_param *ref,
> + struct dfs_cache_tgt_list *tgt_list);
> +extern int dfs_cache_update_tgthint(const unsigned int xid,
> + struct cifs_ses *ses,
> + const struct nls_table *nls_codepage,
> + int remap, const char *path,
> + const struct dfs_cache_tgt_iterator *it);
> +extern int
> +dfs_cache_noreq_update_tgthint(const char *path,
> + const struct dfs_cache_tgt_iterator *it);
> +extern int dfs_cache_get_tgt_referral(const char *path,
> + const struct dfs_cache_tgt_iterator *it,
> + struct dfs_info3_param *ref);
> +extern int dfs_cache_add_vol(struct smb_vol *vol, const char *fullpath);
> +extern int dfs_cache_update_vol(const char *fullpath,
> + struct TCP_Server_Info *server);
> +extern void dfs_cache_del_vol(const char *fullpath);
> +
> +static inline struct dfs_cache_tgt_iterator *
> +dfs_cache_get_next_tgt(struct dfs_cache_tgt_list *tl,
> + struct dfs_cache_tgt_iterator *it)
> +{
> + if (!tl || list_empty(&tl->tl_list) || !it ||
> + list_is_last(&it->it_list, &tl->tl_list))
> + return NULL;
> + return list_next_entry(it, it_list);
> +}
> +
> +static inline struct dfs_cache_tgt_iterator *
> +dfs_cache_get_tgt_iterator(struct dfs_cache_tgt_list *tl)
> +{
> + if (!tl)
> + return NULL;
> + return list_first_entry_or_null(&tl->tl_list,
> + struct dfs_cache_tgt_iterator,
> + it_list);
> +}
> +
> +static inline void dfs_cache_free_tgts(struct dfs_cache_tgt_list *tl)
> +{
> + struct dfs_cache_tgt_iterator *it, *nit;
> +
> + if (!tl || list_empty(&tl->tl_list))
> + return;
> + list_for_each_entry_safe(it, nit, &tl->tl_list, it_list) {
> + list_del(&it->it_list);
> + kfree(it->it_name);
> + kfree(it);
> + }
> + tl->tl_numtgts = 0;
> +}
> +
> +static inline const char *
> +dfs_cache_get_tgt_name(const struct dfs_cache_tgt_iterator *it)
> +{
> + return it ? it->it_name : NULL;
> +}
> +
> +static inline int
> +dfs_cache_get_nr_tgts(const struct dfs_cache_tgt_list *tl)
> +{
> + return tl ? tl->tl_numtgts : 0;
> +}
> +
> +#endif /* _CIFS_DFS_CACHE_H */
> --
> 2.13.7
>
--
Thanks,
Steve
