[v1,08/14] cifs: Add DFS cache routines

From: Paulo Alcantara <paulo@paulo.ac>

* 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@suse.de>
Signed-off-by: Aurelien Aptel <aaptel@suse.com>
---
 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

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@suse.com> wrote:
>
> From: Paulo Alcantara <paulo@paulo.ac>
>
> * 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@suse.de>
> Signed-off-by: Aurelien Aptel <aaptel@suse.com>
> ---
>  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@suse.de>
> + */
> +
> +#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@suse.de>
> + */
> +
> +#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
>