* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2013, Intel Corporation.
+ * Copyright (c) 2011, 2014, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
*
* i_mutex
* PG_locked
- * ->coh_lock_guard
* ->coh_attr_guard
* ->ls_guard
*/
#include <libcfs/list.h>
#include <libcfs/libcfs_hash.h> /* for cfs_hash stuff */
#include <cl_object.h>
+#include <lu_object.h>
#include "cl_internal.h"
static struct kmem_cache *cl_env_kmem;
-/** Lock class of cl_object_header::coh_lock_guard */
-static struct lock_class_key cl_lock_guard_class;
/** Lock class of cl_object_header::coh_attr_guard */
static struct lock_class_key cl_attr_guard_class;
-extern __u32 lu_context_tags_default;
-extern __u32 lu_session_tags_default;
/**
* Initialize cl_object_header.
*/
int cl_object_header_init(struct cl_object_header *h)
{
- int result;
+ int result;
- ENTRY;
- result = lu_object_header_init(&h->coh_lu);
- if (result == 0) {
- spin_lock_init(&h->coh_lock_guard);
+ ENTRY;
+ result = lu_object_header_init(&h->coh_lu);
+ if (result == 0) {
spin_lock_init(&h->coh_attr_guard);
- lockdep_set_class(&h->coh_lock_guard, &cl_lock_guard_class);
lockdep_set_class(&h->coh_attr_guard, &cl_attr_guard_class);
- CFS_INIT_LIST_HEAD(&h->coh_locks);
- h->coh_page_bufsize = ALIGN(sizeof(struct cl_page), 8);
- }
- RETURN(result);
+ h->coh_page_bufsize = 0;
+ }
+ RETURN(result);
}
EXPORT_SYMBOL(cl_object_header_init);
*/
void cl_object_header_fini(struct cl_object_header *h)
{
- LASSERT(cfs_list_empty(&h->coh_locks));
lu_object_header_fini(&h->coh_lu);
}
EXPORT_SYMBOL(cl_object_header_fini);
/**
* Returns the top-object for a given \a o.
*
- * \see cl_page_top(), cl_io_top()
+ * \see cl_io_top()
*/
struct cl_object *cl_object_top(struct cl_object *o)
{
*
* Prevents data-attributes from changing, until lock is released by
* cl_object_attr_unlock(). This has to be called before calls to
- * cl_object_attr_get(), cl_object_attr_set().
+ * cl_object_attr_get(), cl_object_attr_update().
*/
void cl_object_attr_lock(struct cl_object *o)
+__acquires(cl_object_attr_guard(o))
{
spin_lock(cl_object_attr_guard(o));
}
* Releases data-attributes lock, acquired by cl_object_attr_lock().
*/
void cl_object_attr_unlock(struct cl_object *o)
+__releases(cl_object_attr_guard(o))
{
spin_unlock(cl_object_attr_guard(o));
}
struct lu_object_header *top;
int result;
- LASSERT(spin_is_locked(cl_object_attr_guard(obj)));
+ assert_spin_locked(cl_object_attr_guard(obj));
ENTRY;
top = obj->co_lu.lo_header;
result = 0;
- cfs_list_for_each_entry(obj, &top->loh_layers, co_lu.lo_linkage) {
+ list_for_each_entry(obj, &top->loh_layers, co_lu.lo_linkage) {
if (obj->co_ops->coo_attr_get != NULL) {
result = obj->co_ops->coo_attr_get(env, obj, attr);
if (result != 0) {
* Updates data-attributes of an object \a obj.
*
* Only attributes, mentioned in a validness bit-mask \a v are
- * updated. Calls cl_object_operations::coo_attr_set() on every layer, bottom
+ * updated. Calls cl_object_operations::coo_upd_attr() on every layer, bottom
* to top.
*/
-int cl_object_attr_set(const struct lu_env *env, struct cl_object *obj,
- const struct cl_attr *attr, unsigned v)
+int cl_object_attr_update(const struct lu_env *env, struct cl_object *obj,
+ const struct cl_attr *attr, unsigned v)
{
struct lu_object_header *top;
int result;
- LASSERT(spin_is_locked(cl_object_attr_guard(obj)));
+ assert_spin_locked(cl_object_attr_guard(obj));
ENTRY;
- top = obj->co_lu.lo_header;
- result = 0;
- cfs_list_for_each_entry_reverse(obj, &top->loh_layers,
- co_lu.lo_linkage) {
- if (obj->co_ops->coo_attr_set != NULL) {
- result = obj->co_ops->coo_attr_set(env, obj, attr, v);
- if (result != 0) {
- if (result > 0)
- result = 0;
- break;
- }
- }
- }
- RETURN(result);
+ top = obj->co_lu.lo_header;
+ result = 0;
+ list_for_each_entry_reverse(obj, &top->loh_layers, co_lu.lo_linkage) {
+ if (obj->co_ops->coo_attr_update != NULL) {
+ result = obj->co_ops->coo_attr_update(env, obj, attr,
+ v);
+ if (result != 0) {
+ if (result > 0)
+ result = 0;
+ break;
+ }
+ }
+ }
+ RETURN(result);
}
-EXPORT_SYMBOL(cl_object_attr_set);
+EXPORT_SYMBOL(cl_object_attr_update);
/**
* Notifies layers (bottom-to-top) that glimpse AST was received.
ENTRY;
top = obj->co_lu.lo_header;
result = 0;
- cfs_list_for_each_entry_reverse(obj, &top->loh_layers,
- co_lu.lo_linkage) {
+ list_for_each_entry_reverse(obj, &top->loh_layers, co_lu.lo_linkage) {
if (obj->co_ops->coo_glimpse != NULL) {
result = obj->co_ops->coo_glimpse(env, obj, lvb);
if (result != 0)
ENTRY;
top = obj->co_lu.lo_header;
result = 0;
- cfs_list_for_each_entry(obj, &top->loh_layers, co_lu.lo_linkage) {
+ list_for_each_entry(obj, &top->loh_layers, co_lu.lo_linkage) {
if (obj->co_ops->coo_conf_set != NULL) {
result = obj->co_ops->coo_conf_set(env, obj, conf);
if (result != 0)
/**
* Prunes caches of pages and locks for this object.
*/
-void cl_object_prune(const struct lu_env *env, struct cl_object *obj)
+int cl_object_prune(const struct lu_env *env, struct cl_object *obj)
{
struct lu_object_header *top;
struct cl_object *o;
top = obj->co_lu.lo_header;
result = 0;
- cfs_list_for_each_entry(o, &top->loh_layers, co_lu.lo_linkage) {
+ list_for_each_entry(o, &top->loh_layers, co_lu.lo_linkage) {
if (o->co_ops->coo_prune != NULL) {
result = o->co_ops->coo_prune(env, o);
if (result != 0)
}
}
- /* TODO: pruning locks will be moved into layers after cl_lock
- * simplification is done */
- cl_locks_prune(env, obj, 1);
- EXIT;
+ RETURN(result);
}
EXPORT_SYMBOL(cl_object_prune);
/**
+ * Get stripe information of this object.
+ */
+int cl_object_getstripe(const struct lu_env *env, struct cl_object *obj,
+ struct lov_user_md __user *uarg)
+{
+ struct lu_object_header *top;
+ int result = 0;
+ ENTRY;
+
+ top = obj->co_lu.lo_header;
+ list_for_each_entry(obj, &top->loh_layers, co_lu.lo_linkage) {
+ if (obj->co_ops->coo_getstripe != NULL) {
+ result = obj->co_ops->coo_getstripe(env, obj, uarg);
+ if (result != 0)
+ break;
+ }
+ }
+ RETURN(result);
+}
+EXPORT_SYMBOL(cl_object_getstripe);
+
+/**
* Helper function removing all object locks, and marking object for
* deletion. All object pages must have been deleted at this point.
*
*/
void cl_object_kill(const struct lu_env *env, struct cl_object *obj)
{
- struct cl_object_header *hdr;
-
- hdr = cl_object_header(obj);
+ struct cl_object_header *hdr = cl_object_header(obj);
set_bit(LU_OBJECT_HEARD_BANSHEE, &hdr->coh_lu.loh_flags);
- /*
- * Destroy all locks. Object destruction (including cl_inode_fini())
- * cannot cancel the locks, because in the case of a local client,
- * where client and server share the same thread running
- * prune_icache(), this can dead-lock with ldlm_cancel_handler()
- * waiting on __wait_on_freeing_inode().
- */
- cl_locks_prune(env, obj, 0);
}
EXPORT_SYMBOL(cl_object_kill);
-/**
- * Check if the object has locks.
- */
-int cl_object_has_locks(struct cl_object *obj)
-{
- struct cl_object_header *head = cl_object_header(obj);
- int has;
-
- spin_lock(&head->coh_lock_guard);
- has = cfs_list_empty(&head->coh_locks);
- spin_unlock(&head->coh_lock_guard);
-
- return (has == 0);
-}
-EXPORT_SYMBOL(cl_object_has_locks);
-
void cache_stats_init(struct cache_stats *cs, const char *name)
{
int i;
cs->cs_name = name;
for (i = 0; i < CS_NR; i++)
- cfs_atomic_set(&cs->cs_stats[i], 0);
+ atomic_set(&cs->cs_stats[i], 0);
}
-int cache_stats_print(const struct cache_stats *cs,
- char *page, int count, int h)
+static int cache_stats_print(const struct cache_stats *cs,
+ struct seq_file *m, int h)
{
- int nob = 0;
int i;
+
/*
* lookup hit total cached create
* env: ...... ...... ...... ...... ......
if (h) {
const char *names[CS_NR] = CS_NAMES;
- nob += snprintf(page + nob, count - nob, "%6s", " ");
+ seq_printf(m, "%6s", " ");
for (i = 0; i < CS_NR; i++)
- nob += snprintf(page + nob, count - nob,
- "%8s", names[i]);
- nob += snprintf(page + nob, count - nob, "\n");
+ seq_printf(m, "%8s", names[i]);
+ seq_printf(m, "\n");
}
- nob += snprintf(page + nob, count - nob, "%5.5s:", cs->cs_name);
+ seq_printf(m, "%5.5s:", cs->cs_name);
for (i = 0; i < CS_NR; i++)
- nob += snprintf(page + nob, count - nob, "%8u",
- cfs_atomic_read(&cs->cs_stats[i]));
- return nob;
+ seq_printf(m, "%8u", atomic_read(&cs->cs_stats[i]));
+ return 0;
}
static void cl_env_percpu_refill(void);
*/
int cl_site_init(struct cl_site *s, struct cl_device *d)
{
- int i;
+ size_t i;
int result;
result = lu_site_init(&s->cs_lu, &d->cd_lu_dev);
if (result == 0) {
cache_stats_init(&s->cs_pages, "pages");
- cache_stats_init(&s->cs_locks, "locks");
for (i = 0; i < ARRAY_SIZE(s->cs_pages_state); ++i)
- cfs_atomic_set(&s->cs_pages_state[0], 0);
- for (i = 0; i < ARRAY_SIZE(s->cs_locks_state); ++i)
- cfs_atomic_set(&s->cs_locks_state[i], 0);
+ atomic_set(&s->cs_pages_state[0], 0);
cl_env_percpu_refill();
}
return result;
static struct cache_stats cl_env_stats = {
.cs_name = "envs",
- .cs_stats = { CFS_ATOMIC_INIT(0), }
+ .cs_stats = { ATOMIC_INIT(0), }
};
/**
* Outputs client site statistical counters into a buffer. Suitable for
* ll_rd_*()-style functions.
*/
-int cl_site_stats_print(const struct cl_site *site, char *page, int count)
-{
- int nob;
- int i;
- static const char *pstate[] = {
- [CPS_CACHED] = "c",
- [CPS_OWNED] = "o",
- [CPS_PAGEOUT] = "w",
- [CPS_PAGEIN] = "r",
- [CPS_FREEING] = "f"
- };
- static const char *lstate[] = {
- [CLS_NEW] = "n",
- [CLS_QUEUING] = "q",
- [CLS_ENQUEUED] = "e",
- [CLS_HELD] = "h",
- [CLS_INTRANSIT] = "t",
- [CLS_CACHED] = "c",
- [CLS_FREEING] = "f"
- };
+int cl_site_stats_print(const struct cl_site *site, struct seq_file *m)
+{
+ static const char *pstate[] = {
+ [CPS_CACHED] = "c",
+ [CPS_OWNED] = "o",
+ [CPS_PAGEOUT] = "w",
+ [CPS_PAGEIN] = "r",
+ [CPS_FREEING] = "f"
+ };
+ size_t i;
+
/*
lookup hit total busy create
pages: ...... ...... ...... ...... ...... [...... ...... ...... ......]
locks: ...... ...... ...... ...... ...... [...... ...... ...... ...... ......]
env: ...... ...... ...... ...... ......
*/
- nob = lu_site_stats_print(&site->cs_lu, page, count);
- nob += cache_stats_print(&site->cs_pages, page + nob, count - nob, 1);
- nob += snprintf(page + nob, count - nob, " [");
- for (i = 0; i < ARRAY_SIZE(site->cs_pages_state); ++i)
- nob += snprintf(page + nob, count - nob, "%s: %u ",
- pstate[i],
- cfs_atomic_read(&site->cs_pages_state[i]));
- nob += snprintf(page + nob, count - nob, "]\n");
- nob += cache_stats_print(&site->cs_locks, page + nob, count - nob, 0);
- nob += snprintf(page + nob, count - nob, " [");
- for (i = 0; i < ARRAY_SIZE(site->cs_locks_state); ++i)
- nob += snprintf(page + nob, count - nob, "%s: %u ",
- lstate[i],
- cfs_atomic_read(&site->cs_locks_state[i]));
- nob += snprintf(page + nob, count - nob, "]\n");
- nob += cache_stats_print(&cl_env_stats, page + nob, count - nob, 0);
- nob += snprintf(page + nob, count - nob, "\n");
- return nob;
+ lu_site_stats_seq_print(&site->cs_lu, m);
+ cache_stats_print(&site->cs_pages, m, 1);
+ seq_printf(m, " [");
+ for (i = 0; i < ARRAY_SIZE(site->cs_pages_state); ++i)
+ seq_printf(m, "%s: %u ", pstate[i],
+ atomic_read(&site->cs_pages_state[i]));
+ seq_printf(m, "]\n");
+ cache_stats_print(&cl_env_stats, m, 0);
+ seq_printf(m, "\n");
+ return 0;
}
EXPORT_SYMBOL(cl_site_stats_print);
* bz20044, bz22683.
*/
-static CFS_LIST_HEAD(cl_envs);
+static struct list_head cl_envs;
static unsigned cl_envs_cached_nr = 0;
static unsigned cl_envs_cached_max = 128; /* XXX: prototype: arbitrary limit
* for now. */
* This allows cl_env to be entered into cl_env_hash which implements
* the current thread -> client environment lookup.
*/
- cfs_hlist_node_t ce_node;
+ struct hlist_node ce_node;
#endif
/**
* Owner for the current cl_env.
* Linkage into global list of all client environments. Used for
* garbage collection.
*/
- cfs_list_t ce_linkage;
+ struct list_head ce_linkage;
/*
*
*/
};
#ifdef CONFIG_DEBUG_PAGESTATE_TRACKING
-#define CL_ENV_INC(counter) cfs_atomic_inc(&cl_env_stats.cs_stats[CS_##counter])
+#define CL_ENV_INC(counter) atomic_inc(&cl_env_stats.cs_stats[CS_##counter])
#define CL_ENV_DEC(counter) do { \
- LASSERT(cfs_atomic_read(&cl_env_stats.cs_stats[CS_##counter]) > 0); \
- cfs_atomic_dec(&cl_env_stats.cs_stats[CS_##counter]); \
+ LASSERT(atomic_read(&cl_env_stats.cs_stats[CS_##counter]) > 0); \
+ atomic_dec(&cl_env_stats.cs_stats[CS_##counter]); \
} while (0)
#else
#define CL_ENV_INC(counter)
#endif
}
-static void *cl_env_hops_obj(cfs_hlist_node_t *hn)
+static void *cl_env_hops_obj(struct hlist_node *hn)
{
- struct cl_env *cle = cfs_hlist_entry(hn, struct cl_env, ce_node);
- LASSERT(cle->ce_magic == &cl_env_init0);
- return (void *)cle;
+ struct cl_env *cle = hlist_entry(hn, struct cl_env, ce_node);
+
+ LASSERT(cle->ce_magic == &cl_env_init0);
+ return (void *)cle;
}
-static int cl_env_hops_keycmp(const void *key, cfs_hlist_node_t *hn)
+static int cl_env_hops_keycmp(const void *key, struct hlist_node *hn)
{
struct cl_env *cle = cl_env_hops_obj(hn);
return (key == cle->ce_owner);
}
-static void cl_env_hops_noop(cfs_hash_t *hs, cfs_hlist_node_t *hn)
+static void cl_env_hops_noop(cfs_hash_t *hs, struct hlist_node *hn)
{
- struct cl_env *cle = cfs_hlist_entry(hn, struct cl_env, ce_node);
+ struct cl_env *cle = hlist_entry(hn, struct cl_env, ce_node);
LASSERT(cle->ce_magic == &cl_env_init0);
}
static struct lu_env *cl_env_new(__u32 ctx_tags, __u32 ses_tags, void *debug)
{
- struct lu_env *env;
- struct cl_env *cle;
+ struct lu_env *env;
+ struct cl_env *cle;
- OBD_SLAB_ALLOC_PTR_GFP(cle, cl_env_kmem, __GFP_IO);
- if (cle != NULL) {
- int rc;
+ OBD_SLAB_ALLOC_PTR_GFP(cle, cl_env_kmem, GFP_NOFS);
+ if (cle != NULL) {
+ int rc;
- CFS_INIT_LIST_HEAD(&cle->ce_linkage);
- cle->ce_magic = &cl_env_init0;
- env = &cle->ce_lu;
- rc = lu_env_init(env, LCT_CL_THREAD|ctx_tags);
- if (rc == 0) {
- rc = lu_context_init(&cle->ce_ses,
- LCT_SESSION | ses_tags);
- if (rc == 0) {
- lu_context_enter(&cle->ce_ses);
- env->le_ses = &cle->ce_ses;
- cl_env_init0(cle, debug);
- } else
- lu_env_fini(env);
- }
- if (rc != 0) {
- OBD_SLAB_FREE_PTR(cle, cl_env_kmem);
- env = ERR_PTR(rc);
- } else {
- CL_ENV_INC(create);
- CL_ENV_INC(total);
- }
- } else
- env = ERR_PTR(-ENOMEM);
- return env;
+ INIT_LIST_HEAD(&cle->ce_linkage);
+ cle->ce_magic = &cl_env_init0;
+ env = &cle->ce_lu;
+ rc = lu_env_init(env, LCT_CL_THREAD|ctx_tags);
+ if (rc == 0) {
+ rc = lu_context_init(&cle->ce_ses,
+ LCT_SESSION | ses_tags);
+ if (rc == 0) {
+ lu_context_enter(&cle->ce_ses);
+ env->le_ses = &cle->ce_ses;
+ cl_env_init0(cle, debug);
+ } else
+ lu_env_fini(env);
+ }
+ if (rc != 0) {
+ OBD_SLAB_FREE_PTR(cle, cl_env_kmem);
+ env = ERR_PTR(rc);
+ } else {
+ CL_ENV_INC(create);
+ CL_ENV_INC(total);
+ }
+ } else
+ env = ERR_PTR(-ENOMEM);
+ return env;
}
static void cl_env_fini(struct cl_env *cle)
ENTRY;
spin_lock(&cl_envs_guard);
- LASSERT(equi(cl_envs_cached_nr == 0, cfs_list_empty(&cl_envs)));
+ LASSERT(equi(cl_envs_cached_nr == 0, list_empty(&cl_envs)));
if (cl_envs_cached_nr > 0) {
int rc;
cle = container_of(cl_envs.next, struct cl_env, ce_linkage);
- cfs_list_del_init(&cle->ce_linkage);
+ list_del_init(&cle->ce_linkage);
cl_envs_cached_nr--;
spin_unlock(&cl_envs_guard);
ENTRY;
spin_lock(&cl_envs_guard);
- for (; !cfs_list_empty(&cl_envs) && nr > 0; --nr) {
+ for (; !list_empty(&cl_envs) && nr > 0; --nr) {
cle = container_of(cl_envs.next, struct cl_env, ce_linkage);
- cfs_list_del_init(&cle->ce_linkage);
+ list_del_init(&cle->ce_linkage);
LASSERT(cl_envs_cached_nr > 0);
cl_envs_cached_nr--;
spin_unlock(&cl_envs_guard);
cl_env_fini(cle);
spin_lock(&cl_envs_guard);
}
- LASSERT(equi(cl_envs_cached_nr == 0, cfs_list_empty(&cl_envs)));
+ LASSERT(equi(cl_envs_cached_nr == 0, list_empty(&cl_envs)));
spin_unlock(&cl_envs_guard);
RETURN(nr);
}
(env->le_ctx.lc_tags & ~LCT_HAS_EXIT) == LCT_CL_THREAD &&
(env->le_ses->lc_tags & ~LCT_HAS_EXIT) == LCT_SESSION) {
spin_lock(&cl_envs_guard);
- cfs_list_add(&cle->ce_linkage, &cl_envs);
+ list_add(&cle->ce_linkage, &cl_envs);
cl_envs_cached_nr++;
spin_unlock(&cl_envs_guard);
} else
cle = &cl_env_percpu[i];
env = &cle->ce_lu;
- CFS_INIT_LIST_HEAD(&cle->ce_linkage);
+ INIT_LIST_HEAD(&cle->ce_linkage);
cle->ce_magic = &cl_env_init0;
rc = lu_env_init(env, LCT_CL_THREAD | tags);
if (rc == 0) {
}
EXPORT_SYMBOL(cl_stack_fini);
-int cl_lock_init(void);
-void cl_lock_fini(void);
-
-int cl_page_init(void);
-void cl_page_fini(void);
-
static struct lu_context_key cl_key;
struct cl_thread_info *cl_env_info(const struct lu_env *env)
info = cl0_key_init(ctx, key);
if (!IS_ERR(info)) {
- int i;
+ size_t i;
for (i = 0; i < ARRAY_SIZE(info->clt_counters); ++i)
lu_ref_init(&info->clt_counters[i].ctc_locks_locked);
static void cl_key_fini(const struct lu_context *ctx,
struct lu_context_key *key, void *data)
{
- struct cl_thread_info *info;
- int i;
+ struct cl_thread_info *info;
+ size_t i;
info = data;
for (i = 0; i < ARRAY_SIZE(info->clt_counters); ++i)
static void cl_key_exit(const struct lu_context *ctx,
struct lu_context_key *key, void *data)
{
- struct cl_thread_info *info = data;
- int i;
+ struct cl_thread_info *info = data;
+ size_t i;
for (i = 0; i < ARRAY_SIZE(info->clt_counters); ++i) {
LASSERT(info->clt_counters[i].ctc_nr_held == 0);
*/
int cl_global_init(void)
{
- int result;
+ int result;
- result = cl_env_store_init();
- if (result)
- return result;
+ INIT_LIST_HEAD(&cl_envs);
+
+ result = cl_env_store_init();
+ if (result)
+ return result;
result = lu_kmem_init(cl_object_caches);
if (result)
if (result)
goto out_kmem;
- result = cl_lock_init();
- if (result)
- goto out_context;
-
- result = cl_page_init();
- if (result)
- goto out_lock;
-
result = cl_env_percpu_init();
if (result)
/* no cl_env_percpu_fini on error */
- goto out_lock;
+ goto out_context;
return 0;
-out_lock:
- cl_lock_fini();
+
out_context:
lu_context_key_degister(&cl_key);
out_kmem:
void cl_global_fini(void)
{
cl_env_percpu_fini();
- cl_lock_fini();
- cl_page_fini();
lu_context_key_degister(&cl_key);
lu_kmem_fini(cl_object_caches);
cl_env_store_fini();
git://git.whamcloud.com / fs / lustre-release.git / blobdiff