cifs: Avoid doing network I/O while holding cache lock
When creating or updating a cache entry, we need to get an DFS referral (get_dfs_referral), so avoid holding any locks during such network operation. To prevent that, do the following: * change cache hashtable sync method from RCU sync to a read/write lock. * use GFP_ATOMIC in memory allocations. Signed-off-by: Paulo Alcantara (SUSE) <pc@cjr.nz> Signed-off-by: Steve French <stfrench@microsoft.com>
This commit is contained in:
Paulo Alcantara (SUSE)
Steve French
parent
06d57378bc
commit
742d8de018
|
|
@ -5,8 +5,6 @@
|
|||
* Copyright (c) 2018-2019 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>
|
||||
|
|
@ -44,7 +42,6 @@ struct cache_entry {
|
|||
int numtgts;
|
||||
struct list_head tlist;
|
||||
struct cache_dfs_tgt *tgthint;
|
||||
struct rcu_head rcu;
|
||||
};
|
||||
|
||||
struct vol_info {
|
||||
|
|
@ -68,10 +65,10 @@ static struct nls_table *cache_nlsc;
|
|||
/*
|
||||
* Number of entries in the cache
|
||||
*/
|
||||
static size_t cache_count;
|
||||
static atomic_t cache_count;
|
||||
|
||||
static struct hlist_head cache_htable[CACHE_HTABLE_SIZE];
|
||||
static DEFINE_MUTEX(list_lock);
|
||||
static DECLARE_RWSEM(htable_rw_lock);
|
||||
|
||||
static LIST_HEAD(vol_list);
|
||||
static DEFINE_SPINLOCK(vol_list_lock);
|
||||
|
|
@ -121,38 +118,29 @@ static inline void free_tgts(struct cache_entry *ce)
|
|||
}
|
||||
}
|
||||
|
||||
static void free_cache_entry(struct rcu_head *rcu)
|
||||
{
|
||||
struct cache_entry *ce = container_of(rcu, struct cache_entry, rcu);
|
||||
|
||||
kmem_cache_free(cache_slab, ce);
|
||||
}
|
||||
|
||||
static inline void flush_cache_ent(struct cache_entry *ce)
|
||||
{
|
||||
if (hlist_unhashed(&ce->hlist))
|
||||
return;
|
||||
|
||||
hlist_del_init_rcu(&ce->hlist);
|
||||
hlist_del_init(&ce->hlist);
|
||||
kfree(ce->path);
|
||||
free_tgts(ce);
|
||||
cache_count--;
|
||||
call_rcu(&ce->rcu, free_cache_entry);
|
||||
atomic_dec(&cache_count);
|
||||
kmem_cache_free(cache_slab, ce);
|
||||
}
|
||||
|
||||
static void flush_cache_ents(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
rcu_read_lock();
|
||||
for (i = 0; i < CACHE_HTABLE_SIZE; i++) {
|
||||
struct hlist_head *l = &cache_htable[i];
|
||||
struct hlist_node *n;
|
||||
struct cache_entry *ce;
|
||||
|
||||
hlist_for_each_entry_rcu(ce, l, hlist)
|
||||
flush_cache_ent(ce);
|
||||
hlist_for_each_entry_safe(ce, n, l, hlist) {
|
||||
if (!hlist_unhashed(&ce->hlist))
|
||||
flush_cache_ent(ce);
|
||||
}
|
||||
}
|
||||
rcu_read_unlock();
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -160,36 +148,39 @@ static void flush_cache_ents(void)
|
|||
*/
|
||||
static int dfscache_proc_show(struct seq_file *m, void *v)
|
||||
{
|
||||
int bucket;
|
||||
int i;
|
||||
struct cache_entry *ce;
|
||||
struct cache_dfs_tgt *t;
|
||||
|
||||
seq_puts(m, "DFS cache\n---------\n");
|
||||
|
||||
mutex_lock(&list_lock);
|
||||
down_read(&htable_rw_lock);
|
||||
for (i = 0; i < CACHE_HTABLE_SIZE; i++) {
|
||||
struct hlist_head *l = &cache_htable[i];
|
||||
|
||||
rcu_read_lock();
|
||||
hash_for_each_rcu(cache_htable, bucket, ce, hlist) {
|
||||
seq_printf(m,
|
||||
"cache entry: path=%s,type=%s,ttl=%d,etime=%ld,"
|
||||
"interlink=%s,path_consumed=%d,expired=%s\n",
|
||||
ce->path,
|
||||
ce->srvtype == DFS_TYPE_ROOT ? "root" : "link",
|
||||
ce->ttl, ce->etime.tv_nsec,
|
||||
IS_INTERLINK_SET(ce->flags) ? "yes" : "no",
|
||||
ce->path_consumed,
|
||||
cache_entry_expired(ce) ? "yes" : "no");
|
||||
hlist_for_each_entry(ce, l, hlist) {
|
||||
if (hlist_unhashed(&ce->hlist))
|
||||
continue;
|
||||
|
||||
list_for_each_entry(t, &ce->tlist, list) {
|
||||
seq_printf(m, " %s%s\n",
|
||||
t->name,
|
||||
ce->tgthint == t ? " (target hint)" : "");
|
||||
seq_printf(m,
|
||||
"cache entry: path=%s,type=%s,ttl=%d,etime=%ld,"
|
||||
"interlink=%s,path_consumed=%d,expired=%s\n",
|
||||
ce->path,
|
||||
ce->srvtype == DFS_TYPE_ROOT ? "root" : "link",
|
||||
ce->ttl, ce->etime.tv_nsec,
|
||||
IS_INTERLINK_SET(ce->flags) ? "yes" : "no",
|
||||
ce->path_consumed,
|
||||
cache_entry_expired(ce) ? "yes" : "no");
|
||||
|
||||
list_for_each_entry(t, &ce->tlist, list) {
|
||||
seq_printf(m, " %s%s\n",
|
||||
t->name,
|
||||
ce->tgthint == t ? " (target hint)" : "");
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
rcu_read_unlock();
|
||||
up_read(&htable_rw_lock);
|
||||
|
||||
mutex_unlock(&list_lock);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -207,9 +198,10 @@ static ssize_t dfscache_proc_write(struct file *file, const char __user *buffer,
|
|||
return -EINVAL;
|
||||
|
||||
cifs_dbg(FYI, "clearing dfs cache");
|
||||
mutex_lock(&list_lock);
|
||||
|
||||
down_write(&htable_rw_lock);
|
||||
flush_cache_ents();
|
||||
mutex_unlock(&list_lock);
|
||||
up_write(&htable_rw_lock);
|
||||
|
||||
return count;
|
||||
}
|
||||
|
|
@ -305,6 +297,7 @@ int dfs_cache_init(void)
|
|||
for (i = 0; i < CACHE_HTABLE_SIZE; i++)
|
||||
INIT_HLIST_HEAD(&cache_htable[i]);
|
||||
|
||||
atomic_set(&cache_count, 0);
|
||||
cache_nlsc = load_nls_default();
|
||||
|
||||
cifs_dbg(FYI, "%s: initialized DFS referral cache\n", __func__);
|
||||
|
|
@ -356,14 +349,14 @@ static inline struct timespec64 get_expire_time(int ttl)
|
|||
}
|
||||
|
||||
/* Allocate a new DFS target */
|
||||
static inline struct cache_dfs_tgt *alloc_tgt(const char *name)
|
||||
static struct cache_dfs_tgt *alloc_target(const char *name)
|
||||
{
|
||||
struct cache_dfs_tgt *t;
|
||||
|
||||
t = kmalloc(sizeof(*t), GFP_KERNEL);
|
||||
t = kmalloc(sizeof(*t), GFP_ATOMIC);
|
||||
if (!t)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
t->name = kstrndup(name, strlen(name), GFP_KERNEL);
|
||||
t->name = kstrndup(name, strlen(name), GFP_ATOMIC);
|
||||
if (!t->name) {
|
||||
kfree(t);
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
|
@ -390,7 +383,7 @@ static int copy_ref_data(const struct dfs_info3_param *refs, int numrefs,
|
|||
for (i = 0; i < numrefs; i++) {
|
||||
struct cache_dfs_tgt *t;
|
||||
|
||||
t = alloc_tgt(refs[i].node_name);
|
||||
t = alloc_target(refs[i].node_name);
|
||||
if (IS_ERR(t)) {
|
||||
free_tgts(ce);
|
||||
return PTR_ERR(t);
|
||||
|
|
@ -439,41 +432,44 @@ static struct cache_entry *alloc_cache_entry(const char *path,
|
|||
return ce;
|
||||
}
|
||||
|
||||
/* Must be called with htable_rw_lock held */
|
||||
static void remove_oldest_entry(void)
|
||||
{
|
||||
int bucket;
|
||||
int i;
|
||||
struct cache_entry *ce;
|
||||
struct cache_entry *to_del = NULL;
|
||||
|
||||
rcu_read_lock();
|
||||
hash_for_each_rcu(cache_htable, bucket, ce, hlist) {
|
||||
if (!to_del || timespec64_compare(&ce->etime,
|
||||
&to_del->etime) < 0)
|
||||
to_del = ce;
|
||||
for (i = 0; i < CACHE_HTABLE_SIZE; i++) {
|
||||
struct hlist_head *l = &cache_htable[i];
|
||||
|
||||
hlist_for_each_entry(ce, l, hlist) {
|
||||
if (hlist_unhashed(&ce->hlist))
|
||||
continue;
|
||||
if (!to_del || timespec64_compare(&ce->etime,
|
||||
&to_del->etime) < 0)
|
||||
to_del = ce;
|
||||
}
|
||||
}
|
||||
|
||||
if (!to_del) {
|
||||
cifs_dbg(FYI, "%s: no entry to remove", __func__);
|
||||
goto out;
|
||||
return;
|
||||
}
|
||||
|
||||
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 cache_entry *
|
||||
add_cache_entry(unsigned int hash, const char *path,
|
||||
const struct dfs_info3_param *refs, int numrefs)
|
||||
static int add_cache_entry(const char *path, unsigned int hash,
|
||||
struct dfs_info3_param *refs, int numrefs)
|
||||
{
|
||||
struct cache_entry *ce;
|
||||
|
||||
ce = alloc_cache_entry(path, refs, numrefs);
|
||||
if (IS_ERR(ce))
|
||||
return ce;
|
||||
|
||||
hlist_add_head_rcu(&ce->hlist, &cache_htable[hash]);
|
||||
return PTR_ERR(ce);
|
||||
|
||||
spin_lock(&cache_ttl_lock);
|
||||
if (!cache_ttl) {
|
||||
|
|
@ -485,13 +481,20 @@ add_cache_entry(unsigned int hash, const char *path,
|
|||
}
|
||||
spin_unlock(&cache_ttl_lock);
|
||||
|
||||
return ce;
|
||||
down_write(&htable_rw_lock);
|
||||
hlist_add_head(&ce->hlist, &cache_htable[hash]);
|
||||
dump_ce(ce);
|
||||
up_write(&htable_rw_lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Find a DFS cache entry in hash table and optionally check prefix path against
|
||||
* @path.
|
||||
* Use whole path components in the match.
|
||||
* Must be called with htable_rw_lock held.
|
||||
*
|
||||
* Return ERR_PTR(-ENOENT) if the entry is not found.
|
||||
*/
|
||||
static struct cache_entry *lookup_cache_entry(const char *path,
|
||||
|
|
@ -503,15 +506,13 @@ static struct cache_entry *lookup_cache_entry(const char *path,
|
|||
|
||||
h = cache_entry_hash(path, strlen(path));
|
||||
|
||||
rcu_read_lock();
|
||||
hlist_for_each_entry_rcu(ce, &cache_htable[h], hlist) {
|
||||
hlist_for_each_entry(ce, &cache_htable[h], hlist) {
|
||||
if (!strcasecmp(path, ce->path)) {
|
||||
found = true;
|
||||
dump_ce(ce);
|
||||
break;
|
||||
}
|
||||
}
|
||||
rcu_read_unlock();
|
||||
|
||||
if (!found)
|
||||
ce = ERR_PTR(-ENOENT);
|
||||
|
|
@ -521,12 +522,6 @@ static struct cache_entry *lookup_cache_entry(const char *path,
|
|||
return ce;
|
||||
}
|
||||
|
||||
static inline void destroy_slab_cache(void)
|
||||
{
|
||||
rcu_barrier();
|
||||
kmem_cache_destroy(cache_slab);
|
||||
}
|
||||
|
||||
static void __vol_release(struct vol_info *vi)
|
||||
{
|
||||
kfree(vi->fullpath);
|
||||
|
|
@ -564,77 +559,74 @@ void dfs_cache_destroy(void)
|
|||
unload_nls(cache_nlsc);
|
||||
free_vol_list();
|
||||
flush_cache_ents();
|
||||
destroy_slab_cache();
|
||||
kmem_cache_destroy(cache_slab);
|
||||
destroy_workqueue(dfscache_wq);
|
||||
|
||||
cifs_dbg(FYI, "%s: destroyed DFS referral cache\n", __func__);
|
||||
}
|
||||
|
||||
static inline struct cache_entry *
|
||||
__update_cache_entry(const char *path, const struct dfs_info3_param *refs,
|
||||
int numrefs)
|
||||
/* Must be called with htable_rw_lock held */
|
||||
static int __update_cache_entry(const char *path,
|
||||
const struct dfs_info3_param *refs,
|
||||
int numrefs)
|
||||
{
|
||||
int rc;
|
||||
unsigned int h;
|
||||
struct cache_entry *ce;
|
||||
char *s, *th = NULL;
|
||||
|
||||
ce = lookup_cache_entry(path, &h);
|
||||
ce = lookup_cache_entry(path, NULL);
|
||||
if (IS_ERR(ce))
|
||||
return ce;
|
||||
return PTR_ERR(ce);
|
||||
|
||||
if (ce->tgthint) {
|
||||
s = ce->tgthint->name;
|
||||
th = kstrndup(s, strlen(s), GFP_KERNEL);
|
||||
th = kstrndup(s, strlen(s), GFP_ATOMIC);
|
||||
if (!th)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
free_tgts(ce);
|
||||
ce->numtgts = 0;
|
||||
|
||||
rc = copy_ref_data(refs, numrefs, ce, th);
|
||||
|
||||
kfree(th);
|
||||
|
||||
if (rc)
|
||||
ce = ERR_PTR(rc);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return ce;
|
||||
static int get_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
|
||||
const struct nls_table *nls_codepage, int remap,
|
||||
const char *path, struct dfs_info3_param **refs,
|
||||
int *numrefs)
|
||||
{
|
||||
cifs_dbg(FYI, "%s: get an DFS referral for %s\n", __func__, path);
|
||||
|
||||
if (!ses || !ses->server || !ses->server->ops->get_dfs_refer)
|
||||
return -EOPNOTSUPP;
|
||||
if (unlikely(!nls_codepage))
|
||||
return -EINVAL;
|
||||
|
||||
*refs = NULL;
|
||||
*numrefs = 0;
|
||||
|
||||
return ses->server->ops->get_dfs_refer(xid, ses, path, refs, numrefs,
|
||||
nls_codepage, remap);
|
||||
}
|
||||
|
||||
/* Update an expired cache entry by getting a new DFS referral from server */
|
||||
static struct 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 cache_entry *ce)
|
||||
static int update_cache_entry(const char *path,
|
||||
const struct dfs_info3_param *refs,
|
||||
int numrefs)
|
||||
{
|
||||
|
||||
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);
|
||||
down_write(&htable_rw_lock);
|
||||
rc = __update_cache_entry(path, refs, numrefs);
|
||||
up_write(&htable_rw_lock);
|
||||
|
||||
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;
|
||||
return rc;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -646,95 +638,86 @@ update_cache_entry(const unsigned int xid, struct cifs_ses *ses,
|
|||
* For interlinks, __cifs_dfs_mount() and expand_dfs_referral() are supposed to
|
||||
* handle them properly.
|
||||
*/
|
||||
static struct 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)
|
||||
static int __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;
|
||||
unsigned int hash;
|
||||
struct cache_entry *ce;
|
||||
struct dfs_info3_param *nrefs;
|
||||
int numnrefs;
|
||||
struct dfs_info3_param *refs = NULL;
|
||||
int numrefs = 0;
|
||||
bool newent = false;
|
||||
|
||||
cifs_dbg(FYI, "%s: search path: %s\n", __func__, path);
|
||||
|
||||
ce = lookup_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(-EOPNOTSUPP);
|
||||
return ce;
|
||||
}
|
||||
if (unlikely(!nls_codepage)) {
|
||||
ce = ERR_PTR(-EINVAL);
|
||||
return ce;
|
||||
}
|
||||
down_read(&htable_rw_lock);
|
||||
|
||||
nrefs = NULL;
|
||||
numnrefs = 0;
|
||||
ce = lookup_cache_entry(path, &hash);
|
||||
|
||||
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 (cache_count >= CACHE_MAX_ENTRIES) {
|
||||
cifs_dbg(FYI, "%s: reached max cache size (%d)",
|
||||
__func__, 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;
|
||||
|
||||
cache_count++;
|
||||
/*
|
||||
* If @noreq is set, no requests will be sent to the server. Just return
|
||||
* the cache entry.
|
||||
*/
|
||||
if (noreq) {
|
||||
up_read(&htable_rw_lock);
|
||||
return IS_ERR(ce) ? PTR_ERR(ce) : 0;
|
||||
}
|
||||
|
||||
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__);
|
||||
if (!IS_ERR(ce)) {
|
||||
if (!cache_entry_expired(ce)) {
|
||||
dump_ce(ce);
|
||||
up_read(&htable_rw_lock);
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
newent = true;
|
||||
}
|
||||
return ce;
|
||||
|
||||
up_read(&htable_rw_lock);
|
||||
|
||||
/*
|
||||
* No entry was found.
|
||||
*
|
||||
* Request a new DFS referral in order to create a new cache entry, or
|
||||
* updating an existing one.
|
||||
*/
|
||||
rc = get_dfs_referral(xid, ses, nls_codepage, remap, path,
|
||||
&refs, &numrefs);
|
||||
if (rc)
|
||||
return rc;
|
||||
|
||||
dump_refs(refs, numrefs);
|
||||
|
||||
if (!newent) {
|
||||
rc = update_cache_entry(path, refs, numrefs);
|
||||
goto out_free_refs;
|
||||
}
|
||||
|
||||
if (atomic_read(&cache_count) >= CACHE_MAX_ENTRIES) {
|
||||
cifs_dbg(FYI, "%s: reached max cache size (%d)", __func__,
|
||||
CACHE_MAX_ENTRIES);
|
||||
down_write(&htable_rw_lock);
|
||||
remove_oldest_entry();
|
||||
up_write(&htable_rw_lock);
|
||||
}
|
||||
|
||||
rc = add_cache_entry(path, hash, refs, numrefs);
|
||||
if (!rc)
|
||||
atomic_inc(&cache_count);
|
||||
|
||||
out_free_refs:
|
||||
free_dfs_info_array(refs, numrefs);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/* Set up a new DFS referral from a given cache entry */
|
||||
static int setup_ref(const char *path, const struct cache_entry *ce,
|
||||
struct dfs_info3_param *ref, const char *tgt)
|
||||
/*
|
||||
* Set up a DFS referral from a given cache entry.
|
||||
*
|
||||
* Must be called with htable_rw_lock held.
|
||||
*/
|
||||
static int setup_referral(const char *path, struct cache_entry *ce,
|
||||
struct dfs_info3_param *ref, const char *target)
|
||||
{
|
||||
int rc;
|
||||
|
||||
|
|
@ -742,18 +725,17 @@ static int setup_ref(const char *path, const struct cache_entry *ce,
|
|||
|
||||
memset(ref, 0, sizeof(*ref));
|
||||
|
||||
ref->path_name = kstrndup(path, strlen(path), GFP_KERNEL);
|
||||
ref->path_name = kstrndup(path, strlen(path), GFP_ATOMIC);
|
||||
if (!ref->path_name)
|
||||
return -ENOMEM;
|
||||
|
||||
ref->path_consumed = ce->path_consumed;
|
||||
|
||||
ref->node_name = kstrndup(tgt, strlen(tgt), GFP_KERNEL);
|
||||
ref->node_name = kstrndup(target, strlen(target), GFP_ATOMIC);
|
||||
if (!ref->node_name) {
|
||||
rc = -ENOMEM;
|
||||
goto err_free_path;
|
||||
}
|
||||
|
||||
ref->path_consumed = ce->path_consumed;
|
||||
ref->ttl = ce->ttl;
|
||||
ref->server_type = ce->srvtype;
|
||||
ref->ref_flag = ce->flags;
|
||||
|
|
@ -767,8 +749,7 @@ err_free_path:
|
|||
}
|
||||
|
||||
/* Return target list of a DFS cache entry */
|
||||
static int get_tgt_list(const struct cache_entry *ce,
|
||||
struct dfs_cache_tgt_list *tl)
|
||||
static int get_targets(struct cache_entry *ce, struct dfs_cache_tgt_list *tl)
|
||||
{
|
||||
int rc;
|
||||
struct list_head *head = &tl->tl_list;
|
||||
|
|
@ -779,14 +760,13 @@ static int get_tgt_list(const struct cache_entry *ce,
|
|||
INIT_LIST_HEAD(head);
|
||||
|
||||
list_for_each_entry(t, &ce->tlist, list) {
|
||||
it = kzalloc(sizeof(*it), GFP_KERNEL);
|
||||
it = kzalloc(sizeof(*it), GFP_ATOMIC);
|
||||
if (!it) {
|
||||
rc = -ENOMEM;
|
||||
goto err_free_it;
|
||||
}
|
||||
|
||||
it->it_name = kstrndup(t->name, strlen(t->name),
|
||||
GFP_KERNEL);
|
||||
it->it_name = kstrndup(t->name, strlen(t->name), GFP_ATOMIC);
|
||||
if (!it->it_name) {
|
||||
kfree(it);
|
||||
rc = -ENOMEM;
|
||||
|
|
@ -798,6 +778,7 @@ static int get_tgt_list(const struct cache_entry *ce,
|
|||
else
|
||||
list_add_tail(&it->it_list, head);
|
||||
}
|
||||
|
||||
tl->tl_numtgts = ce->numtgts;
|
||||
|
||||
return 0;
|
||||
|
|
@ -845,19 +826,29 @@ int dfs_cache_find(const unsigned int xid, struct cifs_ses *ses,
|
|||
if (rc)
|
||||
return rc;
|
||||
|
||||
mutex_lock(&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 = __dfs_cache_find(xid, ses, nls_codepage, remap, npath, false);
|
||||
if (rc)
|
||||
goto out_free_path;
|
||||
|
||||
down_read(&htable_rw_lock);
|
||||
|
||||
ce = lookup_cache_entry(npath, NULL);
|
||||
if (IS_ERR(ce)) {
|
||||
up_read(&htable_rw_lock);
|
||||
rc = PTR_ERR(ce);
|
||||
goto out_free_path;
|
||||
}
|
||||
mutex_unlock(&list_lock);
|
||||
|
||||
if (ref)
|
||||
rc = setup_referral(path, ce, ref, get_tgt_name(ce));
|
||||
else
|
||||
rc = 0;
|
||||
if (!rc && tgt_list)
|
||||
rc = get_targets(ce, tgt_list);
|
||||
|
||||
up_read(&htable_rw_lock);
|
||||
|
||||
out_free_path:
|
||||
free_normalized_path(path, npath);
|
||||
return rc;
|
||||
}
|
||||
|
|
@ -889,22 +880,27 @@ int dfs_cache_noreq_find(const char *path, struct dfs_info3_param *ref,
|
|||
if (rc)
|
||||
return rc;
|
||||
|
||||
mutex_lock(&list_lock);
|
||||
ce = do_dfs_cache_find(0, NULL, NULL, 0, npath, true);
|
||||
cifs_dbg(FYI, "%s: path: %s\n", __func__, npath);
|
||||
|
||||
down_read(&htable_rw_lock);
|
||||
|
||||
ce = lookup_cache_entry(npath, NULL);
|
||||
if (IS_ERR(ce)) {
|
||||
rc = PTR_ERR(ce);
|
||||
goto out;
|
||||
goto out_unlock;
|
||||
}
|
||||
|
||||
if (ref)
|
||||
rc = setup_ref(path, ce, ref, get_tgt_name(ce));
|
||||
rc = setup_referral(path, ce, ref, get_tgt_name(ce));
|
||||
else
|
||||
rc = 0;
|
||||
if (!rc && tgt_list)
|
||||
rc = get_tgt_list(ce, tgt_list);
|
||||
out:
|
||||
mutex_unlock(&list_lock);
|
||||
rc = get_targets(ce, tgt_list);
|
||||
|
||||
out_unlock:
|
||||
up_read(&htable_rw_lock);
|
||||
free_normalized_path(path, npath);
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
|
@ -940,21 +936,24 @@ int dfs_cache_update_tgthint(const unsigned int xid, struct cifs_ses *ses,
|
|||
if (rc)
|
||||
return rc;
|
||||
|
||||
cifs_dbg(FYI, "%s: path: %s\n", __func__, npath);
|
||||
cifs_dbg(FYI, "%s: update target hint - path: %s\n", __func__, npath);
|
||||
|
||||
mutex_lock(&list_lock);
|
||||
ce = do_dfs_cache_find(xid, ses, nls_codepage, remap, npath, false);
|
||||
rc = __dfs_cache_find(xid, ses, nls_codepage, remap, npath, false);
|
||||
if (rc)
|
||||
goto out_free_path;
|
||||
|
||||
down_write(&htable_rw_lock);
|
||||
|
||||
ce = lookup_cache_entry(npath, NULL);
|
||||
if (IS_ERR(ce)) {
|
||||
rc = PTR_ERR(ce);
|
||||
goto out;
|
||||
goto out_unlock;
|
||||
}
|
||||
|
||||
rc = 0;
|
||||
|
||||
t = ce->tgthint;
|
||||
|
||||
if (likely(!strcasecmp(it->it_name, t->name)))
|
||||
goto out;
|
||||
goto out_unlock;
|
||||
|
||||
list_for_each_entry(t, &ce->tlist, list) {
|
||||
if (!strcasecmp(t->name, it->it_name)) {
|
||||
|
|
@ -965,9 +964,11 @@ int dfs_cache_update_tgthint(const unsigned int xid, struct cifs_ses *ses,
|
|||
}
|
||||
}
|
||||
|
||||
out:
|
||||
mutex_unlock(&list_lock);
|
||||
out_unlock:
|
||||
up_write(&htable_rw_lock);
|
||||
out_free_path:
|
||||
free_normalized_path(path, npath);
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
|
@ -1002,20 +1003,19 @@ int dfs_cache_noreq_update_tgthint(const char *path,
|
|||
|
||||
cifs_dbg(FYI, "%s: path: %s\n", __func__, npath);
|
||||
|
||||
mutex_lock(&list_lock);
|
||||
down_write(&htable_rw_lock);
|
||||
|
||||
ce = do_dfs_cache_find(0, NULL, NULL, 0, npath, true);
|
||||
ce = lookup_cache_entry(npath, NULL);
|
||||
if (IS_ERR(ce)) {
|
||||
rc = PTR_ERR(ce);
|
||||
goto out;
|
||||
goto out_unlock;
|
||||
}
|
||||
|
||||
rc = 0;
|
||||
|
||||
t = ce->tgthint;
|
||||
|
||||
if (unlikely(!strcasecmp(it->it_name, t->name)))
|
||||
goto out;
|
||||
goto out_unlock;
|
||||
|
||||
list_for_each_entry(t, &ce->tlist, list) {
|
||||
if (!strcasecmp(t->name, it->it_name)) {
|
||||
|
|
@ -1026,9 +1026,10 @@ int dfs_cache_noreq_update_tgthint(const char *path,
|
|||
}
|
||||
}
|
||||
|
||||
out:
|
||||
mutex_unlock(&list_lock);
|
||||
out_unlock:
|
||||
up_write(&htable_rw_lock);
|
||||
free_normalized_path(path, npath);
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
|
@ -1049,7 +1050,6 @@ int dfs_cache_get_tgt_referral(const char *path,
|
|||
int rc;
|
||||
char *npath;
|
||||
struct cache_entry *ce;
|
||||
unsigned int h;
|
||||
|
||||
if (!it || !ref)
|
||||
return -EINVAL;
|
||||
|
|
@ -1060,21 +1060,22 @@ int dfs_cache_get_tgt_referral(const char *path,
|
|||
|
||||
cifs_dbg(FYI, "%s: path: %s\n", __func__, npath);
|
||||
|
||||
mutex_lock(&list_lock);
|
||||
down_read(&htable_rw_lock);
|
||||
|
||||
ce = lookup_cache_entry(npath, &h);
|
||||
ce = lookup_cache_entry(npath, NULL);
|
||||
if (IS_ERR(ce)) {
|
||||
rc = PTR_ERR(ce);
|
||||
goto out;
|
||||
goto out_unlock;
|
||||
}
|
||||
|
||||
cifs_dbg(FYI, "%s: target name: %s\n", __func__, it->it_name);
|
||||
|
||||
rc = setup_ref(path, ce, ref, it->it_name);
|
||||
rc = setup_referral(path, ce, ref, it->it_name);
|
||||
|
||||
out:
|
||||
mutex_unlock(&list_lock);
|
||||
out_unlock:
|
||||
up_read(&htable_rw_lock);
|
||||
free_normalized_path(path, npath);
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
|
@ -1343,6 +1344,7 @@ static struct cifs_ses *find_root_ses(struct vol_info *vi,
|
|||
{
|
||||
char *rpath;
|
||||
int rc;
|
||||
struct cache_entry *ce;
|
||||
struct dfs_info3_param ref = {0};
|
||||
char *mdata = NULL, *devname = NULL;
|
||||
struct TCP_Server_Info *server;
|
||||
|
|
@ -1353,15 +1355,26 @@ static struct cifs_ses *find_root_ses(struct vol_info *vi,
|
|||
if (IS_ERR(rpath))
|
||||
return ERR_CAST(rpath);
|
||||
|
||||
memset(&vol, 0, sizeof(vol));
|
||||
down_read(&htable_rw_lock);
|
||||
|
||||
rc = dfs_cache_noreq_find(rpath, &ref, NULL);
|
||||
ce = lookup_cache_entry(rpath, NULL);
|
||||
if (IS_ERR(ce)) {
|
||||
up_read(&htable_rw_lock);
|
||||
ses = ERR_CAST(ce);
|
||||
goto out;
|
||||
}
|
||||
|
||||
rc = setup_referral(path, ce, &ref, get_tgt_name(ce));
|
||||
if (rc) {
|
||||
up_read(&htable_rw_lock);
|
||||
ses = ERR_PTR(rc);
|
||||
goto out;
|
||||
}
|
||||
|
||||
mdata = cifs_compose_mount_options(vi->mntdata, rpath, &ref, &devname);
|
||||
up_read(&htable_rw_lock);
|
||||
|
||||
mdata = cifs_compose_mount_options(vi->mntdata, rpath, &ref,
|
||||
&devname);
|
||||
free_dfs_info_param(&ref);
|
||||
|
||||
if (IS_ERR(mdata)) {
|
||||
|
|
@ -1395,16 +1408,15 @@ out:
|
|||
}
|
||||
|
||||
/* Refresh DFS cache entry from a given tcon */
|
||||
static void refresh_tcon(struct vol_info *vi, struct cifs_tcon *tcon)
|
||||
static int refresh_tcon(struct vol_info *vi, struct cifs_tcon *tcon)
|
||||
{
|
||||
int rc = 0;
|
||||
unsigned int xid;
|
||||
char *path, *npath;
|
||||
unsigned int h;
|
||||
struct cache_entry *ce;
|
||||
struct cifs_ses *root_ses = NULL, *ses;
|
||||
struct dfs_info3_param *refs = NULL;
|
||||
int numrefs = 0;
|
||||
struct cifs_ses *root_ses = NULL, *ses;
|
||||
|
||||
xid = get_xid();
|
||||
|
||||
|
|
@ -1412,19 +1424,23 @@ static void refresh_tcon(struct vol_info *vi, struct cifs_tcon *tcon)
|
|||
|
||||
rc = get_normalized_path(path, &npath);
|
||||
if (rc)
|
||||
goto out;
|
||||
goto out_free_xid;
|
||||
|
||||
mutex_lock(&list_lock);
|
||||
ce = lookup_cache_entry(npath, &h);
|
||||
mutex_unlock(&list_lock);
|
||||
down_read(&htable_rw_lock);
|
||||
|
||||
ce = lookup_cache_entry(npath, NULL);
|
||||
if (IS_ERR(ce)) {
|
||||
rc = PTR_ERR(ce);
|
||||
goto out;
|
||||
up_read(&htable_rw_lock);
|
||||
goto out_free_path;
|
||||
}
|
||||
|
||||
if (!cache_entry_expired(ce))
|
||||
goto out;
|
||||
if (!cache_entry_expired(ce)) {
|
||||
up_read(&htable_rw_lock);
|
||||
goto out_free_path;
|
||||
}
|
||||
|
||||
up_read(&htable_rw_lock);
|
||||
|
||||
/* If it's a DFS Link, then use root SMB session for refreshing it */
|
||||
if (is_dfs_link(npath)) {
|
||||
|
|
@ -1432,35 +1448,29 @@ static void refresh_tcon(struct vol_info *vi, struct cifs_tcon *tcon)
|
|||
if (IS_ERR(ses)) {
|
||||
rc = PTR_ERR(ses);
|
||||
root_ses = NULL;
|
||||
goto out;
|
||||
goto out_free_path;
|
||||
}
|
||||
} else {
|
||||
ses = tcon->ses;
|
||||
}
|
||||
|
||||
if (unlikely(!ses->server->ops->get_dfs_refer)) {
|
||||
rc = -EOPNOTSUPP;
|
||||
} else {
|
||||
rc = ses->server->ops->get_dfs_refer(xid, ses, path, &refs,
|
||||
&numrefs, cache_nlsc,
|
||||
tcon->remap);
|
||||
if (!rc) {
|
||||
mutex_lock(&list_lock);
|
||||
ce = __update_cache_entry(npath, refs, numrefs);
|
||||
mutex_unlock(&list_lock);
|
||||
dump_refs(refs, numrefs);
|
||||
free_dfs_info_array(refs, numrefs);
|
||||
if (IS_ERR(ce))
|
||||
rc = PTR_ERR(ce);
|
||||
}
|
||||
rc = get_dfs_referral(xid, ses, cache_nlsc, tcon->remap, npath, &refs,
|
||||
&numrefs);
|
||||
if (!rc) {
|
||||
dump_refs(refs, numrefs);
|
||||
rc = update_cache_entry(npath, refs, numrefs);
|
||||
free_dfs_info_array(refs, numrefs);
|
||||
}
|
||||
|
||||
out:
|
||||
if (root_ses)
|
||||
cifs_put_smb_ses(root_ses);
|
||||
|
||||
free_xid(xid);
|
||||
out_free_path:
|
||||
free_normalized_path(path, npath);
|
||||
|
||||
out_free_xid:
|
||||
free_xid(xid);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -1474,6 +1484,7 @@ static void refresh_cache_worker(struct work_struct *work)
|
|||
LIST_HEAD(vols);
|
||||
LIST_HEAD(tcons);
|
||||
struct cifs_tcon *tcon, *ntcon;
|
||||
int rc;
|
||||
|
||||
/*
|
||||
* Find SMB volumes that are eligible (server->tcpStatus == CifsGood)
|
||||
|
|
@ -1501,8 +1512,16 @@ static void refresh_cache_worker(struct work_struct *work)
|
|||
goto next_vol;
|
||||
|
||||
get_tcons(server, &tcons);
|
||||
rc = 0;
|
||||
|
||||
list_for_each_entry_safe(tcon, ntcon, &tcons, ulist) {
|
||||
refresh_tcon(vi, tcon);
|
||||
/*
|
||||
* Skip tcp server if any of its tcons failed to refresh
|
||||
* (possibily due to reconnects).
|
||||
*/
|
||||
if (!rc)
|
||||
rc = refresh_tcon(vi, tcon);
|
||||
|
||||
list_del_init(&tcon->ulist);
|
||||
cifs_put_tcon(tcon);
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue