From: Eric Mei Date: Tue, 21 Sep 2010 18:28:03 +0000 (+0400) Subject: b=22683 store cl_env in task_struct for redhat kernel and liblustre. X-Git-Tag: 2.0.53.0~34 X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=commitdiff_plain;h=e409c8d33474dd4dc1ae1200bfc94207b2a33093 b=22683 store cl_env in task_struct for redhat kernel and liblustre. r=andreas.dilger --- diff --git a/lustre/autoconf/lustre-core.m4 b/lustre/autoconf/lustre-core.m4 index 3958e0b..9e6e33d 100644 --- a/lustre/autoconf/lustre-core.m4 +++ b/lustre/autoconf/lustre-core.m4 @@ -1912,6 +1912,7 @@ AC_DEFUN([LC_PROG_LINUX], LC_COOKIE_FOLLOW_LINK LC_FUNC_RCU LC_PERCPU_COUNTER + LC_TASK_CLENV_STORE LC_QUOTA64 LC_4ARGS_VFS_SYMLINK @@ -2399,6 +2400,30 @@ LB_LINUX_TRY_COMPILE([ ]) ]) +AC_DEFUN([LC_TASK_CLENV_TUX_INFO], +[AC_MSG_CHECKING([tux_info]) +LB_LINUX_TRY_COMPILE([ + #include +],[ + struct task_struct task; + &task.tux_info; +],[ + AC_MSG_RESULT([yes]) + AC_DEFINE(LL_TASK_CL_ENV, tux_info, [have tux_info]) + have_task_clenv_store='yes' +],[ + AC_MSG_RESULT([no]) +]) +]) + +AC_DEFUN([LC_TASK_CLENV_STORE], +[ + AC_MSG_CHECKING([if we can store cl_env in task_struct]) + if test x$have_task_clenv_store != xyes ; then + LC_TASK_CLENV_TUX_INFO + fi +]) + # # LC_CONFIGURE # diff --git a/lustre/include/liblustre.h b/lustre/include/liblustre.h index 89ee6c5..b008dcb 100644 --- a/lustre/include/liblustre.h +++ b/lustre/include/liblustre.h @@ -262,6 +262,9 @@ struct signal { int signal; }; +#undef LL_TASK_CL_ENV +#define LL_TASK_CL_ENV cl_env + struct task_struct { int state; struct signal pending; @@ -274,6 +277,7 @@ struct task_struct { int max_groups; int ngroups; gid_t *groups; + void *cl_env; __u32 cap_effective; }; diff --git a/lustre/obdclass/cl_object.c b/lustre/obdclass/cl_object.c index 1d6572d..eefba72 100644 --- a/lustre/obdclass/cl_object.c +++ b/lustre/obdclass/cl_object.c @@ -519,6 +519,24 @@ EXPORT_SYMBOL(cl_site_stats_print); * */ +/** + * The most efficient way is to store cl_env pointer in task specific + * structures. On Linux, it wont' be easy to use task_struct->journal_info + * because Lustre code may call into other fs which has certain assumptions + * about journal_info. Currently following fields in task_struct are identified + * can be used for this purpose: + * - cl_env: for liblustre. + * - tux_info: ony on RedHat kernel. + * - ... + * \note As long as we use task_struct to store cl_env, we assume that once + * called into Lustre, we'll never call into the other part of the kernel + * which will use those fields in task_struct without explicitly exiting + * Lustre. + * + * If there's no space in task_struct is available, hash will be used. + * bz20044, bz22683. + */ + static CFS_LIST_HEAD(cl_envs); static unsigned cl_envs_cached_nr = 0; static unsigned cl_envs_cached_max = 128; /* XXX: prototype: arbitrary limit @@ -529,19 +547,29 @@ struct cl_env { void *ce_magic; struct lu_env ce_lu; struct lu_context ce_ses; + +#ifdef LL_TASK_CL_ENV + void *ce_prev; +#else /** * 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; +#endif /** - * Owner for the current cl_env, the key for cfs_hash. + * Owner for the current cl_env. + * + * If LL_TASK_CL_ENV is defined, this point to the owning cfs_current(), + * only for debugging purpose ; + * Otherwise hash is used, and this is the key for cfs_hash. * Now current thread pid is stored. Note using thread pointer would * lead to unbalanced hash because of its specific allocation locality * and could be varied for different platforms and OSes, even different * OS versions. */ void *ce_owner; + /* * Linkage into global list of all client environments. Used for * garbage collection. @@ -566,14 +594,24 @@ struct cl_env { cfs_atomic_dec(&cl_env_stats.counter); \ } while (0) -/***************************************************************************** - * Routins to use cfs_hash functionality to bind the current thread - * to cl_env +static void cl_env_init0(struct cl_env *cle, void *debug) +{ + LASSERT(cle->ce_ref == 0); + LASSERT(cle->ce_magic == &cl_env_init0); + LASSERT(cle->ce_debug == NULL && cle->ce_owner == NULL); + + cle->ce_ref = 1; + cle->ce_debug = debug; + CL_ENV_INC(cs_busy); +} + + +#ifndef LL_TASK_CL_ENV +/* + * The implementation of using hash table to connect cl_env and thread */ -/** lustre hash to manage the cl_env for current thread */ static cfs_hash_t *cl_env_hash; -static void cl_env_init0(struct cl_env *cle, void *debug); static unsigned cl_env_hops_hash(cfs_hash_t *lh, void *key, unsigned mask) { @@ -610,6 +648,7 @@ static cfs_hash_ops_t cl_env_hops = { static inline struct cl_env *cl_env_fetch(void) { struct cl_env *cle; + cle = cfs_hash_lookup(cl_env_hash, (void *) (long) cfs_current()->pid); LASSERT(ergo(cle, cle->ce_magic == &cl_env_init0)); return cle; @@ -619,6 +658,7 @@ static inline void cl_env_attach(struct cl_env *cle) { if (cle) { int rc; + LASSERT(cle->ce_owner == NULL); cle->ce_owner = (void *) (long) cfs_current()->pid; rc = cfs_hash_add_unique(cl_env_hash, cle->ce_owner, @@ -627,31 +667,74 @@ static inline void cl_env_attach(struct cl_env *cle) } } -static inline struct cl_env *cl_env_detach(struct cl_env *cle) +static inline void cl_env_do_detach(struct cl_env *cle) { - if (cle == NULL) - cle = cl_env_fetch(); - if (cle && cle->ce_owner) { - void *cookie; - LASSERT(cle->ce_owner == (void *) (long) cfs_current()->pid); - cookie = cfs_hash_del(cl_env_hash, cle->ce_owner, - &cle->ce_node); - cle->ce_owner = NULL; - LASSERT(cookie == cle); - } + void *cookie; + + LASSERT(cle->ce_owner == (void *) (long) cfs_current()->pid); + cookie = cfs_hash_del(cl_env_hash, cle->ce_owner, + &cle->ce_node); + LASSERT(cookie == cle); + cle->ce_owner = NULL; +} + +static int cl_env_store_init(void) { + cl_env_hash = cfs_hash_create("cl_env", 8, 10, &cl_env_hops, + CFS_HASH_REHASH); + return cl_env_hash != NULL ? 0 :-ENOMEM; +} + +static void cl_env_store_fini(void) { + cfs_hash_putref(cl_env_hash); +} + +#else /* LL_TASK_CL_ENV */ +/* + * The implementation of store cl_env directly in thread structure. + */ + +static inline struct cl_env *cl_env_fetch(void) +{ + struct cl_env *cle; + + cle = cfs_current()->LL_TASK_CL_ENV; + if (cle && cle->ce_magic != &cl_env_init0) + cle = NULL; return cle; } -/* ----------------------- hash routines end ---------------------------- */ -static void cl_env_init0(struct cl_env *cle, void *debug) +static inline void cl_env_attach(struct cl_env *cle) { - LASSERT(cle->ce_ref == 0); - LASSERT(cle->ce_magic == &cl_env_init0); - LASSERT(cle->ce_debug == NULL && cle->ce_owner == NULL); + if (cle) { + LASSERT(cle->ce_owner == NULL); + cle->ce_owner = cfs_current(); + cle->ce_prev = cfs_current()->LL_TASK_CL_ENV; + cfs_current()->LL_TASK_CL_ENV = cle; + } +} - cle->ce_ref = 1; - cle->ce_debug = debug; - CL_ENV_INC(cs_busy); +static inline void cl_env_do_detach(struct cl_env *cle) +{ + LASSERT(cle->ce_owner == cfs_current()); + LASSERT(cfs_current()->LL_TASK_CL_ENV == cle); + cfs_current()->LL_TASK_CL_ENV = cle->ce_prev; + cle->ce_owner = NULL; +} + +static int cl_env_store_init(void) { return 0; } +static void cl_env_store_fini(void) { } + +#endif /* LL_TASK_CL_ENV */ + +static inline struct cl_env *cl_env_detach(struct cl_env *cle) +{ + if (cle == NULL) + cle = cl_env_fetch(); + + if (cle && cle->ce_owner) + cl_env_do_detach(cle); + + return cle; } static struct lu_env *cl_env_new(__u32 tags, void *debug) @@ -1142,10 +1225,9 @@ int cl_global_init(void) { int result; - cl_env_hash = cfs_hash_create("cl_env", 8, 10, &cl_env_hops, - CFS_HASH_REHASH); - if (cl_env_hash == NULL) - return -ENOMEM; + result = cl_env_store_init(); + if (result) + return result; result = lu_kmem_init(cl_object_caches); if (result == 0) { @@ -1158,7 +1240,7 @@ int cl_global_init(void) } } if (result) - cfs_hash_putref(cl_env_hash); + cl_env_store_fini(); return result; } @@ -1171,5 +1253,5 @@ void cl_global_fini(void) cl_page_fini(); lu_context_key_degister(&cl_key); lu_kmem_fini(cl_object_caches); - cfs_hash_putref(cl_env_hash); + cl_env_store_fini(); }