*/
static void lu_object_free(const struct lu_env *env, struct lu_object *o)
{
- struct list_head splice;
+ struct list_head splice;
struct lu_object *scan;
- struct lu_site *site;
- struct list_head *layers;
+ struct lu_site *site;
+ struct list_head *layers;
site = o->lo_dev->ld_site;
layers = &o->lo_header->loh_layers;
struct lu_cdebug_data *key;
int used;
int complete;
- va_list args;
+ va_list args;
va_start(args, format);
ARRAY_SIZE(key->lck_area) - used, format, args);
if (complete) {
if (cdebug_show(info->lpi_mask, info->lpi_subsys))
- libcfs_debug_msg(NULL, info->lpi_subsys, info->lpi_mask,
- (char *)info->lpi_file, info->lpi_fn,
- info->lpi_line, "%s", key->lck_area);
+ libcfs_debug_msg(NULL, info->lpi_subsys, info->lpi_mask,
+ (char *)info->lpi_file, info->lpi_fn,
+ info->lpi_line, "%s", key->lck_area);
key->lck_area[0] = 0;
}
va_end(args);
*/
void lu_object_header_print(const struct lu_env *env, void *cookie,
lu_printer_t printer,
- const struct lu_object_header *hdr)
+ const struct lu_object_header *hdr)
{
(*printer)(env, cookie, "header@%p[%#lx, %d, "DFID"%s%s%s]",
hdr, hdr->loh_flags, atomic_read(&hdr->loh_ref),
(*printer)(env, cookie, "%*.*s%s@%p", depth, depth, ruler,
o->lo_dev->ld_type->ldt_name, o);
if (o->lo_ops->loo_object_print != NULL)
- o->lo_ops->loo_object_print(env, cookie, printer, o);
+ o->lo_ops->loo_object_print(env, cookie, printer, o);
(*printer)(env, cookie, "\n");
}
(*printer)(env, cookie, "} header@%p\n", top);
cfs_waitlink_t *waiter)
{
struct lu_site *s;
- struct lu_object *o;
- struct lu_object *shadow;
+ struct lu_object *o;
+ struct lu_object *shadow;
struct hlist_head *bucket;
/*
struct lu_device_type *t;
t = d->ld_type;
- if (d->ld_obd != NULL)
- /* finish lprocfs */
- lprocfs_obd_cleanup(d->ld_obd);
+ if (d->ld_obd != NULL) {
+ d->ld_obd->obd_lu_dev = NULL;
+ d->ld_obd = NULL;
+ }
lu_ref_fini(&d->ld_reference);
LASSERTF(atomic_read(&d->ld_ref) == 0,
/**
* Finalize and free devices in the device stack.
- *
+ *
* Finalize device stack by purging object cache, and calling
* lu_device_type_operations::ldto_device_fini() and
* lu_device_type_operations::ldto_device_free() on all devices in the stack.
next = ldt->ldt_ops->ldto_device_free(env, scan);
type = ldt->ldt_obd_type;
if (type != NULL) {
- type->typ_refcnt--;
- class_put_type(type);
- }
+ type->typ_refcnt--;
+ class_put_type(type);
+ }
}
}
EXPORT_SYMBOL(lu_stack_fini);
static void key_fini(struct lu_context *ctx, int index)
{
- if (ctx->lc_value[index] != NULL) {
+ if (ctx->lc_value != NULL && ctx->lc_value[index] != NULL) {
struct lu_context_key *key;
key = lu_keys[index];
LASSERT(atomic_read(&key->lct_used) >= 1);
LINVRNT(0 <= key->lct_index && key->lct_index < ARRAY_SIZE(lu_keys));
- ++key_set_version;
- key_fini(&lu_shrink_env.le_ctx, key->lct_index);
+ lu_context_key_quiesce(key);
- if (atomic_read(&key->lct_used) > 1)
- CERROR("key has instances.\n");
+ ++key_set_version;
spin_lock(&lu_keys_guard);
- lu_keys[key->lct_index] = NULL;
+ key_fini(&lu_shrink_env.le_ctx, key->lct_index);
+ if (lu_keys[key->lct_index]) {
+ lu_keys[key->lct_index] = NULL;
+ lu_ref_fini(&key->lct_reference);
+ }
spin_unlock(&lu_keys_guard);
+
+ LASSERTF(atomic_read(&key->lct_used) == 1, "key has instances: %d\n",
+ atomic_read(&key->lct_used));
}
EXPORT_SYMBOL(lu_context_key_degister);
{
LINVRNT(ctx->lc_state == LCS_ENTERED);
LINVRNT(0 <= key->lct_index && key->lct_index < ARRAY_SIZE(lu_keys));
+ LASSERT(lu_keys[key->lct_index] == key);
return ctx->lc_value[key->lct_index];
}
EXPORT_SYMBOL(lu_context_key_get);
void lu_context_key_quiesce(struct lu_context_key *key)
{
struct lu_context *ctx;
+ extern unsigned cl_env_cache_purge(unsigned nr);
if (!(key->lct_tags & LCT_QUIESCENT)) {
+ /*
+ * XXX layering violation.
+ */
+ cl_env_cache_purge(~0);
key->lct_tags |= LCT_QUIESCENT;
/*
* XXX memory barrier has to go here.
{
int i;
+ spin_lock(&lu_keys_guard);
if (ctx->lc_value != NULL) {
for (i = 0; i < ARRAY_SIZE(lu_keys); ++i)
key_fini(ctx, i);
ARRAY_SIZE(lu_keys) * sizeof ctx->lc_value[0]);
ctx->lc_value = NULL;
}
+ spin_unlock(&lu_keys_guard);
}
static int keys_fill(struct lu_context *ctx)
value = key->lct_init(ctx, key);
if (unlikely(IS_ERR(value)))
return PTR_ERR(value);
+
LASSERT(key->lct_owner != NULL);
if (!(ctx->lc_tags & LCT_NOREF))
try_module_get(key->lct_owner);
}
EXPORT_SYMBOL(lu_context_refill);
-static int lu_env_setup(struct lu_env *env, struct lu_context *ses,
- __u32 tags, int noref)
+int lu_env_init(struct lu_env *env, __u32 tags)
{
int result;
- LINVRNT(ergo(!noref, !(tags & LCT_NOREF)));
-
- env->le_ses = ses;
+ env->le_ses = NULL;
result = lu_context_init(&env->le_ctx, tags);
if (likely(result == 0))
lu_context_enter(&env->le_ctx);
return result;
}
-
-static int lu_env_init_noref(struct lu_env *env, struct lu_context *ses,
- __u32 tags)
-{
- return lu_env_setup(env, ses, tags, 1);
-}
-
-int lu_env_init(struct lu_env *env, struct lu_context *ses, __u32 tags)
-{
- return lu_env_setup(env, ses, tags, 0);
-}
EXPORT_SYMBOL(lu_env_init);
void lu_env_fini(struct lu_env *env)
int remain = nr;
CFS_LIST_HEAD(splice);
- if (nr != 0 && !(gfp_mask & __GFP_FS))
- return -1;
+ if (nr != 0) {
+ if (!(gfp_mask & __GFP_FS))
+ return -1;
+ CDEBUG(D_INODE, "Shrink %d objects\n", nr);
+ }
down(&lu_sites_guard);
list_for_each_entry_safe(s, tmp, &lu_sites, ls_linkage) {
read_lock(&s->ls_guard);
cached += s->ls_total - s->ls_busy;
read_unlock(&s->ls_guard);
- if (remain <= 0)
+ if (nr && remain <= 0)
break;
}
list_splice(&splice, lu_sites.prev);
up(&lu_sites_guard);
+
+ cached = (cached / 100) * sysctl_vfs_cache_pressure;
+ if (nr == 0)
+ CDEBUG(D_INODE, "%d objects cached\n", cached);
return cached;
}
+/*
+ * Debugging stuff.
+ */
+
+/**
+ * Environment to be used in debugger, contains all tags.
+ */
+struct lu_env lu_debugging_env;
+
+/**
+ * Debugging printer function using printk().
+ */
+int lu_printk_printer(const struct lu_env *env,
+ void *unused, const char *format, ...)
+{
+ va_list args;
+
+ va_start(args, format);
+ vprintk(format, args);
+ va_end(args);
+ return 0;
+}
+
+void lu_debugging_setup(void)
+{
+ lu_env_init(&lu_debugging_env, ~0);
+}
+
+void lu_context_keys_dump(void)
+{
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(lu_keys); ++i) {
+ struct lu_context_key *key;
+
+ key = lu_keys[i];
+ if (key != NULL) {
+ CERROR("[%i]: %p %x (%p,%p,%p) %i %i \"%s\"@%p\n",
+ i, key, key->lct_tags,
+ key->lct_init, key->lct_fini, key->lct_exit,
+ key->lct_index, atomic_read(&key->lct_used),
+ key->lct_owner ? key->lct_owner->name : "",
+ key->lct_owner);
+ lu_ref_print(&key->lct_reference);
+ }
+ }
+}
+EXPORT_SYMBOL(lu_context_keys_dump);
#else /* !__KERNEL__ */
static int lu_cache_shrink(int nr, unsigned int gfp_mask)
{
}
#endif /* __KERNEL__ */
+int cl_global_init(void);
+void cl_global_fini(void);
int lu_ref_global_init(void);
void lu_ref_global_fini(void);
+int dt_global_init(void);
+void dt_global_fini(void);
+
+int llo_global_init(void);
+void llo_global_fini(void);
+
/**
* Initialization of global lu_* data.
*/
CDEBUG(D_CONSOLE, "Lustre LU module (%p).\n", &lu_keys);
+ result = lu_ref_global_init();
+ if (result != 0)
+ return result;
+
LU_CONTEXT_KEY_INIT(&lu_global_key);
result = lu_context_key_register(&lu_global_key);
if (result != 0)
return result;
- /*
+ /*
* At this level, we don't know what tags are needed, so allocate them
* conservatively. This should not be too bad, because this
* environment is global.
- */
- down(&lu_sites_guard);
- result = lu_env_init_noref(&lu_shrink_env, NULL, LCT_SHRINKER);
- up(&lu_sites_guard);
+ */
+ down(&lu_sites_guard);
+ result = lu_env_init(&lu_shrink_env, LCT_SHRINKER);
+ up(&lu_sites_guard);
if (result != 0)
return result;
- result = lu_ref_global_init();
- if (result != 0)
- return result;
- /*
+ /*
* seeks estimation: 3 seeks to read a record from oi, one to read
* inode, one for ea. Unfortunately setting this high value results in
* lu_object/inode cache consuming all the memory.
if (lu_site_shrinker == NULL)
return -ENOMEM;
- result = lu_time_global_init();
+ result = lu_time_global_init();
+ if (result)
+ GOTO(out, result);
+
+#ifdef __KERNEL__
+ result = dt_global_init();
+ if (result)
+ GOTO(out, result);
+
+ result = llo_global_init();
+ if (result)
+ GOTO(out, result);
+#endif
+ result = cl_global_init();
+out:
+
return result;
}
*/
void lu_global_fini(void)
{
+ cl_global_fini();
+#ifdef __KERNEL__
+ llo_global_fini();
+ dt_global_fini();
+#endif
lu_time_global_fini();
if (lu_site_shrinker != NULL) {
remove_shrinker(lu_site_shrinker);
}
EXPORT_SYMBOL(lu_site_stats_print);
+#ifdef __KERNEL__
/*
* XXX: Functions below logically belong to the fid module, but they are used
* by dt_store_open(). Put them here until better place is found.
*/
CLASSERT(LUSTRE_SEQ_MAX_WIDTH < 0xffffull);
- if (fid_is_igif(fid) ||
- seq > 0xffffffull || oid > 0xffff || fid_ver(fid) != 0) {
+ /* fid can be packed in six bytes (first byte as length of packed fid,
+ * three bytes of seq and two bytes of oid).
+ * this reduces IO overhead specially for OSD Object Index. */
+
+ if (seq < FID_SEQ_START ||
+ seq > (0xffffffull + FID_SEQ_START) ||
+ oid > 0xffff || fid_ver(fid) != 0) {
fid_cpu_to_be(befider, fid);
recsize = sizeof *befider;
} else {
unsigned char *small_befider;
- small_befider = (char *)befider;
+ /* as lower 24 bits of FID_SEQ_START are zero, no need to
+ * subtract its value from seq */
+
+ CLASSERT((FID_SEQ_START & 0xffffff) == 0);
+
+ small_befider = (unsigned char *)befider;
small_befider[0] = seq >> 16;
small_befider[1] = seq >> 8;
case 6: {
const unsigned char *area;
- area = pack->fp_area;
+ area = (unsigned char *)pack->fp_area;
fid->f_seq = (area[0] << 16) | (area[1] << 8) | area[2];
+ fid->f_seq += FID_SEQ_START;
fid->f_oid = (area[3] << 8) | area[4];
fid->f_ver = 0;
break;
return result;
}
EXPORT_SYMBOL(fid_unpack);
+#endif /* #ifdef __KERNEL__ */
const char *lu_time_names[LU_TIME_NR] = {
[LU_TIME_FIND_LOOKUP] = "find_lookup",
}
}
EXPORT_SYMBOL(lu_kmem_fini);
-
git://git.whamcloud.com / fs / lustre-release.git / blobdiff