X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fobdclass%2Flu_object.c;h=cc43d7c64d6e4ae711f1eb8a17d5999102160614;hp=91b3693909af872750cb0c245b6437b9d1bdb45a;hb=8701e7e4b5ec1b34700c95b9b6588f4745730b72;hpb=a9c51c03eaecb5234ba754b738877323a35bed51 diff --git a/lustre/obdclass/lu_object.c b/lustre/obdclass/lu_object.c index 91b3693..cc43d7c 100644 --- a/lustre/obdclass/lu_object.c +++ b/lustre/obdclass/lu_object.c @@ -60,8 +60,6 @@ #include #include -extern spinlock_t obd_types_lock; - enum { LU_CACHE_PERCENT_MAX = 50, LU_CACHE_PERCENT_DEFAULT = 20 @@ -121,10 +119,10 @@ void lu_object_put(const struct lu_env *env, struct lu_object *o) if (fid_is_zero(fid)) { LASSERT(top->loh_hash.next == NULL && top->loh_hash.pprev == NULL); - LASSERT(cfs_list_empty(&top->loh_lru)); + LASSERT(list_empty(&top->loh_lru)); if (!atomic_dec_and_test(&top->loh_ref)) return; - cfs_list_for_each_entry_reverse(o, &top->loh_layers, lo_linkage) { + list_for_each_entry_reverse(o, &top->loh_layers, lo_linkage) { if (o->lo_ops->loo_object_release != NULL) o->lo_ops->loo_object_release(env, o); } @@ -153,14 +151,14 @@ void lu_object_put(const struct lu_env *env, struct lu_object *o) * When last reference is released, iterate over object * layers, and notify them that object is no longer busy. */ - cfs_list_for_each_entry_reverse(o, &top->loh_layers, lo_linkage) { + list_for_each_entry_reverse(o, &top->loh_layers, lo_linkage) { if (o->lo_ops->loo_object_release != NULL) o->lo_ops->loo_object_release(env, o); } if (!lu_object_is_dying(top)) { - LASSERT(cfs_list_empty(&top->loh_lru)); - cfs_list_add_tail(&top->loh_lru, &bkt->lsb_lru); + LASSERT(list_empty(&top->loh_lru)); + list_add_tail(&top->loh_lru, &bkt->lsb_lru); cfs_hash_bd_unlock(site->ls_obj_hash, &bd, 1); return; } @@ -213,7 +211,7 @@ void lu_object_unhash(const struct lu_env *env, struct lu_object *o) cfs_hash_bd_t bd; cfs_hash_bd_get_and_lock(obj_hash, &top->loh_fid, &bd, 1); - cfs_list_del_init(&top->loh_lru); + list_del_init(&top->loh_lru); cfs_hash_bd_del_locked(obj_hash, &bd, &top->loh_hash); cfs_hash_bd_unlock(obj_hash, &bd, 1); } @@ -233,7 +231,7 @@ static struct lu_object *lu_object_alloc(const struct lu_env *env, { struct lu_object *scan; struct lu_object *top; - cfs_list_t *layers; + struct list_head *layers; unsigned int init_mask = 0; unsigned int init_flag; int clean; @@ -263,7 +261,7 @@ static struct lu_object *lu_object_alloc(const struct lu_env *env, */ clean = 1; init_flag = 1; - cfs_list_for_each_entry(scan, layers, lo_linkage) { + list_for_each_entry(scan, layers, lo_linkage) { if (init_mask & init_flag) goto next; clean = 0; @@ -279,7 +277,7 @@ next: } } while (!clean); - cfs_list_for_each_entry_reverse(scan, layers, lo_linkage) { + list_for_each_entry_reverse(scan, layers, lo_linkage) { if (scan->lo_ops->loo_object_start != NULL) { result = scan->lo_ops->loo_object_start(env, scan); if (result != 0) { @@ -298,11 +296,11 @@ next: */ static void lu_object_free(const struct lu_env *env, struct lu_object *o) { - struct lu_site_bkt_data *bkt; - struct lu_site *site; - struct lu_object *scan; - cfs_list_t *layers; - cfs_list_t splice; + struct lu_site_bkt_data *bkt; + struct lu_site *site; + struct lu_object *scan; + struct list_head *layers; + struct list_head splice; site = o->lo_dev->ld_site; layers = &o->lo_header->loh_layers; @@ -310,7 +308,7 @@ static void lu_object_free(const struct lu_env *env, struct lu_object *o) /* * First call ->loo_object_delete() method to release all resources. */ - cfs_list_for_each_entry_reverse(scan, layers, lo_linkage) { + list_for_each_entry_reverse(scan, layers, lo_linkage) { if (scan->lo_ops->loo_object_delete != NULL) scan->lo_ops->loo_object_delete(env, scan); } @@ -321,16 +319,16 @@ static void lu_object_free(const struct lu_env *env, struct lu_object *o) * necessary, because lu_object_header is freed together with the * top-level slice. */ - CFS_INIT_LIST_HEAD(&splice); - cfs_list_splice_init(layers, &splice); - while (!cfs_list_empty(&splice)) { + INIT_LIST_HEAD(&splice); + list_splice_init(layers, &splice); + while (!list_empty(&splice)) { /* * Free layers in bottom-to-top order, so that object header * lives as long as possible and ->loo_object_free() methods * can look at its contents. */ o = container_of0(splice.prev, struct lu_object, lo_linkage); - cfs_list_del_init(&o->lo_linkage); + list_del_init(&o->lo_linkage); LASSERT(o->lo_ops->loo_object_free != NULL); o->lo_ops->loo_object_free(env, o); } @@ -349,7 +347,7 @@ int lu_site_purge(const struct lu_env *env, struct lu_site *s, int nr) struct lu_site_bkt_data *bkt; cfs_hash_bd_t bd; cfs_hash_bd_t bd2; - cfs_list_t dispose; + struct list_head dispose; int did_sth; int start; int count; @@ -359,7 +357,7 @@ int lu_site_purge(const struct lu_env *env, struct lu_site *s, int nr) if (OBD_FAIL_CHECK(OBD_FAIL_OBD_NO_LRU)) RETURN(0); - CFS_INIT_LIST_HEAD(&dispose); + INIT_LIST_HEAD(&dispose); /* * Under LRU list lock, scan LRU list and move unreferenced objects to * the dispose list, removing them from LRU and hash table. @@ -367,6 +365,11 @@ int lu_site_purge(const struct lu_env *env, struct lu_site *s, int nr) start = s->ls_purge_start; bnr = (nr == ~0) ? -1 : nr / CFS_HASH_NBKT(s->ls_obj_hash) + 1; again: + /* + * It doesn't make any sense to make purge threads parallel, that can + * only bring troubles to us. See LU-5331. + */ + mutex_lock(&s->ls_purge_mutex); did_sth = 0; cfs_hash_for_each_bucket(s->ls_obj_hash, &bd, i) { if (i < start) @@ -375,7 +378,7 @@ int lu_site_purge(const struct lu_env *env, struct lu_site *s, int nr) cfs_hash_bd_lock(s->ls_obj_hash, &bd, 1); bkt = cfs_hash_bd_extra_get(s->ls_obj_hash, &bd); - cfs_list_for_each_entry_safe(h, temp, &bkt->lsb_lru, loh_lru) { + list_for_each_entry_safe(h, temp, &bkt->lsb_lru, loh_lru) { LASSERT(atomic_read(&h->loh_ref) == 0); cfs_hash_bd_get(s->ls_obj_hash, &h->loh_fid, &bd2); @@ -383,7 +386,7 @@ int lu_site_purge(const struct lu_env *env, struct lu_site *s, int nr) cfs_hash_bd_del_locked(s->ls_obj_hash, &bd2, &h->loh_hash); - cfs_list_move(&h->loh_lru, &dispose); + list_move(&h->loh_lru, &dispose); if (did_sth == 0) did_sth = 1; @@ -400,17 +403,18 @@ int lu_site_purge(const struct lu_env *env, struct lu_site *s, int nr) * Free everything on the dispose list. This is safe against * races due to the reasons described in lu_object_put(). */ - while (!cfs_list_empty(&dispose)) { - h = container_of0(dispose.next, - struct lu_object_header, loh_lru); - cfs_list_del_init(&h->loh_lru); - lu_object_free(env, lu_object_top(h)); - lprocfs_counter_incr(s->ls_stats, LU_SS_LRU_PURGED); - } + while (!list_empty(&dispose)) { + h = container_of0(dispose.next, + struct lu_object_header, loh_lru); + list_del_init(&h->loh_lru); + lu_object_free(env, lu_object_top(h)); + lprocfs_counter_incr(s->ls_stats, LU_SS_LRU_PURGED); + } if (nr == 0) break; } + mutex_unlock(&s->ls_purge_mutex); if (nr != 0 && did_sth && start != 0) { start = 0; /* restart from the first bucket */ @@ -494,8 +498,8 @@ int lu_cdebug_printer(const struct lu_env *env, vsnprintf(key->lck_area + used, ARRAY_SIZE(key->lck_area) - used, format, args); if (complete) { - if (cfs_cdebug_show(msgdata->msg_mask, msgdata->msg_subsys)) - libcfs_debug_msg(msgdata, "%s", key->lck_area); + if (cfs_cdebug_show(msgdata->msg_mask, msgdata->msg_subsys)) + libcfs_debug_msg(msgdata, "%s\n", key->lck_area); key->lck_area[0] = 0; } va_end(args); @@ -510,13 +514,13 @@ void lu_object_header_print(const struct lu_env *env, void *cookie, lu_printer_t printer, const struct lu_object_header *hdr) { - (*printer)(env, cookie, "header@%p[%#lx, %d, "DFID"%s%s%s]", + (*printer)(env, cookie, "header@%p[%#lx, %d, "DFID"%s%s%s]", hdr, hdr->loh_flags, atomic_read(&hdr->loh_ref), - PFID(&hdr->loh_fid), - cfs_hlist_unhashed(&hdr->loh_hash) ? "" : " hash", - cfs_list_empty((cfs_list_t *)&hdr->loh_lru) ? \ - "" : " lru", - hdr->loh_attr & LOHA_EXISTS ? " exist":""); + PFID(&hdr->loh_fid), + hlist_unhashed(&hdr->loh_hash) ? "" : " hash", + list_empty((struct list_head *)&hdr->loh_lru) ? \ + "" : " lru", + hdr->loh_attr & LOHA_EXISTS ? " exist" : ""); } EXPORT_SYMBOL(lu_object_header_print); @@ -534,7 +538,7 @@ void lu_object_print(const struct lu_env *env, void *cookie, lu_object_header_print(env, cookie, printer, top); (*printer)(env, cookie, "{\n"); - cfs_list_for_each_entry(o, &top->loh_layers, lo_linkage) { + list_for_each_entry(o, &top->loh_layers, lo_linkage) { /* * print `.' \a depth times followed by type name and address */ @@ -559,7 +563,7 @@ int lu_object_invariant(const struct lu_object *o) struct lu_object_header *top; top = o->lo_header; - cfs_list_for_each_entry(o, &top->loh_layers, lo_linkage) { + list_for_each_entry(o, &top->loh_layers, lo_linkage) { if (o->lo_ops->loo_object_invariant != NULL && !o->lo_ops->loo_object_invariant(o)) return 0; @@ -574,10 +578,10 @@ static struct lu_object *htable_lookup(struct lu_site *s, wait_queue_t *waiter, __u64 *version) { - struct lu_site_bkt_data *bkt; - struct lu_object_header *h; - cfs_hlist_node_t *hnode; - __u64 ver = cfs_hash_bd_version_get(bd); + struct lu_site_bkt_data *bkt; + struct lu_object_header *h; + struct hlist_node *hnode; + __u64 ver = cfs_hash_bd_version_get(bd); if (*version == ver) return ERR_PTR(-ENOENT); @@ -596,7 +600,7 @@ static struct lu_object *htable_lookup(struct lu_site *s, if (likely(!lu_object_is_dying(h))) { cfs_hash_get(s->ls_obj_hash, hnode); lprocfs_counter_incr(s->ls_stats, LU_SS_CACHE_HIT); - cfs_list_del_init(&h->loh_lru); + list_del_init(&h->loh_lru); return lu_object_top(h); } @@ -617,7 +621,7 @@ static struct lu_object *htable_lookup_nowait(struct lu_site *s, cfs_hash_bd_t *bd, const struct lu_fid *f) { - cfs_hlist_node_t *hnode; + struct hlist_node *hnode; struct lu_object_header *h; /* cfs_hash_bd_peek_locked is a somehow "internal" function @@ -634,7 +638,7 @@ static struct lu_object *htable_lookup_nowait(struct lu_site *s, cfs_hash_get(s->ls_obj_hash, hnode); lprocfs_counter_incr(s->ls_stats, LU_SS_CACHE_HIT); - cfs_list_del_init(&h->loh_lru); + list_del_init(&h->loh_lru); return lu_object_top(h); } @@ -858,7 +862,7 @@ EXPORT_SYMBOL(lu_object_find_slice); /** * Global list of all device types. */ -static CFS_LIST_HEAD(lu_device_types); +static struct list_head lu_device_types; int lu_device_type_init(struct lu_device_type *ldt) { @@ -892,7 +896,7 @@ EXPORT_SYMBOL(lu_device_type_fini); /** * Global list of all sites on this node */ -static CFS_LIST_HEAD(lu_sites); +static struct list_head lu_sites; static DEFINE_MUTEX(lu_sites_guard); /** @@ -908,23 +912,23 @@ struct lu_site_print_arg { static int lu_site_obj_print(cfs_hash_t *hs, cfs_hash_bd_t *bd, - cfs_hlist_node_t *hnode, void *data) + struct hlist_node *hnode, void *data) { - struct lu_site_print_arg *arg = (struct lu_site_print_arg *)data; - struct lu_object_header *h; + struct lu_site_print_arg *arg = (struct lu_site_print_arg *)data; + struct lu_object_header *h; - h = cfs_hlist_entry(hnode, struct lu_object_header, loh_hash); - if (!cfs_list_empty(&h->loh_layers)) { - const struct lu_object *o; + h = hlist_entry(hnode, struct lu_object_header, loh_hash); + if (!list_empty(&h->loh_layers)) { + const struct lu_object *o; - o = lu_object_top(h); - lu_object_print(arg->lsp_env, arg->lsp_cookie, - arg->lsp_printer, o); - } else { - lu_object_header_print(arg->lsp_env, arg->lsp_cookie, - arg->lsp_printer, h); - } - return 0; + o = lu_object_top(h); + lu_object_print(arg->lsp_env, arg->lsp_cookie, + arg->lsp_printer, o); + } else { + lu_object_header_print(arg->lsp_env, arg->lsp_cookie, + arg->lsp_printer, h); + } + return 0; } /** @@ -1015,43 +1019,43 @@ static unsigned lu_obj_hop_hash(cfs_hash_t *hs, return hash & mask; } -static void *lu_obj_hop_object(cfs_hlist_node_t *hnode) +static void *lu_obj_hop_object(struct hlist_node *hnode) { - return cfs_hlist_entry(hnode, struct lu_object_header, loh_hash); + return hlist_entry(hnode, struct lu_object_header, loh_hash); } -static void *lu_obj_hop_key(cfs_hlist_node_t *hnode) +static void *lu_obj_hop_key(struct hlist_node *hnode) { - struct lu_object_header *h; + struct lu_object_header *h; - h = cfs_hlist_entry(hnode, struct lu_object_header, loh_hash); - return &h->loh_fid; + h = hlist_entry(hnode, struct lu_object_header, loh_hash); + return &h->loh_fid; } -static int lu_obj_hop_keycmp(const void *key, cfs_hlist_node_t *hnode) +static int lu_obj_hop_keycmp(const void *key, struct hlist_node *hnode) { - struct lu_object_header *h; + struct lu_object_header *h; - h = cfs_hlist_entry(hnode, struct lu_object_header, loh_hash); - return lu_fid_eq(&h->loh_fid, (struct lu_fid *)key); + h = hlist_entry(hnode, struct lu_object_header, loh_hash); + return lu_fid_eq(&h->loh_fid, (struct lu_fid *)key); } -static void lu_obj_hop_get(cfs_hash_t *hs, cfs_hlist_node_t *hnode) +static void lu_obj_hop_get(cfs_hash_t *hs, struct hlist_node *hnode) { - struct lu_object_header *h; + struct lu_object_header *h; - h = cfs_hlist_entry(hnode, struct lu_object_header, loh_hash); + h = hlist_entry(hnode, struct lu_object_header, loh_hash); if (atomic_add_return(1, &h->loh_ref) == 1) { - struct lu_site_bkt_data *bkt; - cfs_hash_bd_t bd; + struct lu_site_bkt_data *bkt; + cfs_hash_bd_t bd; - cfs_hash_bd_get(hs, &h->loh_fid, &bd); - bkt = cfs_hash_bd_extra_get(hs, &bd); - bkt->lsb_busy++; - } + cfs_hash_bd_get(hs, &h->loh_fid, &bd); + bkt = cfs_hash_bd_extra_get(hs, &bd); + bkt->lsb_busy++; + } } -static void lu_obj_hop_put_locked(cfs_hash_t *hs, cfs_hlist_node_t *hnode) +static void lu_obj_hop_put_locked(cfs_hash_t *hs, struct hlist_node *hnode) { LBUG(); /* we should never called it */ } @@ -1068,8 +1072,8 @@ cfs_hash_ops_t lu_site_hash_ops = { void lu_dev_add_linkage(struct lu_site *s, struct lu_device *d) { spin_lock(&s->ls_ld_lock); - if (cfs_list_empty(&d->ld_linkage)) - cfs_list_add(&d->ld_linkage, &s->ls_ld_linkage); + if (list_empty(&d->ld_linkage)) + list_add(&d->ld_linkage, &s->ls_ld_linkage); spin_unlock(&s->ls_ld_lock); } EXPORT_SYMBOL(lu_dev_add_linkage); @@ -1077,7 +1081,7 @@ EXPORT_SYMBOL(lu_dev_add_linkage); void lu_dev_del_linkage(struct lu_site *s, struct lu_device *d) { spin_lock(&s->ls_ld_lock); - cfs_list_del_init(&d->ld_linkage); + list_del_init(&d->ld_linkage); spin_unlock(&s->ls_ld_lock); } EXPORT_SYMBOL(lu_dev_del_linkage); @@ -1094,7 +1098,10 @@ int lu_site_init(struct lu_site *s, struct lu_device *top) int i; ENTRY; + INIT_LIST_HEAD(&lu_sites); + memset(s, 0, sizeof *s); + mutex_init(&s->ls_purge_mutex); bits = lu_htable_order(top); snprintf(name, 16, "lu_site_%s", top->ld_type->ldt_name); for (bits = min(max(LU_SITE_BITS_MIN, bits), LU_SITE_BITS_MAX); @@ -1119,7 +1126,7 @@ int lu_site_init(struct lu_site *s, struct lu_device *top) cfs_hash_for_each_bucket(s->ls_obj_hash, &bd, i) { bkt = cfs_hash_bd_extra_get(s->ls_obj_hash, &bd); - CFS_INIT_LIST_HEAD(&bkt->lsb_lru); + INIT_LIST_HEAD(&bkt->lsb_lru); init_waitqueue_head(&bkt->lsb_marche_funebre); } @@ -1143,13 +1150,13 @@ int lu_site_init(struct lu_site *s, struct lu_device *top) lprocfs_counter_init(s->ls_stats, LU_SS_LRU_PURGED, 0, "lru_purged", "lru_purged"); - CFS_INIT_LIST_HEAD(&s->ls_linkage); + INIT_LIST_HEAD(&s->ls_linkage); s->ls_top_dev = top; top->ld_site = s; lu_device_get(top); lu_ref_add(&top->ld_reference, "site-top", s); - CFS_INIT_LIST_HEAD(&s->ls_ld_linkage); + INIT_LIST_HEAD(&s->ls_ld_linkage); spin_lock_init(&s->ls_ld_lock); lu_dev_add_linkage(s, top); @@ -1164,7 +1171,7 @@ EXPORT_SYMBOL(lu_site_init); void lu_site_fini(struct lu_site *s) { mutex_lock(&lu_sites_guard); - cfs_list_del_init(&s->ls_linkage); + list_del_init(&s->ls_linkage); mutex_unlock(&lu_sites_guard); if (s->ls_obj_hash != NULL) { @@ -1193,7 +1200,7 @@ int lu_site_init_finish(struct lu_site *s) mutex_lock(&lu_sites_guard); result = lu_context_refill(&lu_shrink_env.le_ctx); if (result == 0) - cfs_list_add(&s->ls_linkage, &lu_sites); + list_add(&s->ls_linkage, &lu_sites); mutex_unlock(&lu_sites_guard); return result; } @@ -1271,7 +1278,7 @@ int lu_object_init(struct lu_object *o, struct lu_object_header *h, o->lo_dev = d; lu_device_get(d); lu_ref_add_at(&d->ld_reference, &o->lo_dev_ref, "lu_object", o); - CFS_INIT_LIST_HEAD(&o->lo_linkage); + INIT_LIST_HEAD(&o->lo_linkage); return 0; } @@ -1284,7 +1291,7 @@ void lu_object_fini(struct lu_object *o) { struct lu_device *dev = o->lo_dev; - LASSERT(cfs_list_empty(&o->lo_linkage)); + LASSERT(list_empty(&o->lo_linkage)); if (dev != NULL) { lu_ref_del_at(&dev->ld_reference, &o->lo_dev_ref, @@ -1303,7 +1310,7 @@ EXPORT_SYMBOL(lu_object_fini); */ void lu_object_add_top(struct lu_object_header *h, struct lu_object *o) { - cfs_list_move(&o->lo_linkage, &h->loh_layers); + list_move(&o->lo_linkage, &h->loh_layers); } EXPORT_SYMBOL(lu_object_add_top); @@ -1315,7 +1322,7 @@ EXPORT_SYMBOL(lu_object_add_top); */ void lu_object_add(struct lu_object *before, struct lu_object *o) { - cfs_list_move(&o->lo_linkage, &before->lo_linkage); + list_move(&o->lo_linkage, &before->lo_linkage); } EXPORT_SYMBOL(lu_object_add); @@ -1326,9 +1333,9 @@ int lu_object_header_init(struct lu_object_header *h) { memset(h, 0, sizeof *h); atomic_set(&h->loh_ref, 1); - CFS_INIT_HLIST_NODE(&h->loh_hash); - CFS_INIT_LIST_HEAD(&h->loh_lru); - CFS_INIT_LIST_HEAD(&h->loh_layers); + INIT_HLIST_NODE(&h->loh_hash); + INIT_LIST_HEAD(&h->loh_lru); + INIT_LIST_HEAD(&h->loh_layers); lu_ref_init(&h->loh_reference); return 0; } @@ -1339,9 +1346,9 @@ EXPORT_SYMBOL(lu_object_header_init); */ void lu_object_header_fini(struct lu_object_header *h) { - LASSERT(cfs_list_empty(&h->loh_layers)); - LASSERT(cfs_list_empty(&h->loh_lru)); - LASSERT(cfs_hlist_unhashed(&h->loh_hash)); + LASSERT(list_empty(&h->loh_layers)); + LASSERT(list_empty(&h->loh_lru)); + LASSERT(hlist_unhashed(&h->loh_hash)); lu_ref_fini(&h->loh_reference); } EXPORT_SYMBOL(lu_object_header_fini); @@ -1353,18 +1360,16 @@ EXPORT_SYMBOL(lu_object_header_fini); struct lu_object *lu_object_locate(struct lu_object_header *h, const struct lu_device_type *dtype) { - struct lu_object *o; + struct lu_object *o; - cfs_list_for_each_entry(o, &h->loh_layers, lo_linkage) { - if (o->lo_dev->ld_type == dtype) - return o; - } - return NULL; + list_for_each_entry(o, &h->loh_layers, lo_linkage) { + if (o->lo_dev->ld_type == dtype) + return o; + } + return NULL; } EXPORT_SYMBOL(lu_object_locate); - - /** * Finalize and free devices in the device stack. * @@ -1597,7 +1602,7 @@ EXPORT_SYMBOL(lu_context_key_get); /** * List of remembered contexts. XXX document me. */ -static CFS_LIST_HEAD(lu_context_remembered); +static struct list_head lu_context_remembered; /** * Destroy \a key in all remembered contexts. This is used to destroy key @@ -1619,8 +1624,8 @@ void lu_context_key_quiesce(struct lu_context_key *key) * XXX memory barrier has to go here. */ spin_lock(&lu_keys_guard); - cfs_list_for_each_entry(ctx, &lu_context_remembered, - lc_remember) + list_for_each_entry(ctx, &lu_context_remembered, + lc_remember) key_fini(ctx, key->lct_index); spin_unlock(&lu_keys_guard); ++key_set_version; @@ -1714,10 +1719,10 @@ int lu_context_init(struct lu_context *ctx, __u32 tags) ctx->lc_tags = tags; if (tags & LCT_REMEMBER) { spin_lock(&lu_keys_guard); - cfs_list_add(&ctx->lc_remember, &lu_context_remembered); + list_add(&ctx->lc_remember, &lu_context_remembered); spin_unlock(&lu_keys_guard); } else { - CFS_INIT_LIST_HEAD(&ctx->lc_remember); + INIT_LIST_HEAD(&ctx->lc_remember); } rc = keys_init(ctx); @@ -1737,13 +1742,13 @@ void lu_context_fini(struct lu_context *ctx) ctx->lc_state = LCS_FINALIZED; if ((ctx->lc_tags & LCT_REMEMBER) == 0) { - LASSERT(cfs_list_empty(&ctx->lc_remember)); + LASSERT(list_empty(&ctx->lc_remember)); keys_fini(ctx); } else { /* could race with key degister */ spin_lock(&lu_keys_guard); keys_fini(ctx); - cfs_list_del_init(&ctx->lc_remember); + list_del_init(&ctx->lc_remember); spin_unlock(&lu_keys_guard); } } @@ -1917,7 +1922,7 @@ static void lu_site_stats_get(cfs_hash_t *hs, cfs_hash_for_each_bucket(hs, &bd, i) { struct lu_site_bkt_data *bkt = cfs_hash_bd_extra_get(hs, &bd); - cfs_hlist_head_t *hhead; + struct hlist_head *hhead; cfs_hash_bd_lock(hs, &bd, 1); stats->lss_busy += bkt->lsb_busy; @@ -1930,7 +1935,7 @@ static void lu_site_stats_get(cfs_hash_t *hs, } cfs_hash_bd_for_each_hlist(hs, &bd, hhead) { - if (!cfs_hlist_empty(hhead)) + if (!hlist_empty(hhead)) stats->lss_populated++; } cfs_hash_bd_unlock(hs, &bd, 1); @@ -2105,6 +2110,9 @@ int lu_global_init(void) CDEBUG(D_INFO, "Lustre LU module (%p).\n", &lu_keys); + INIT_LIST_HEAD(&lu_device_types); + INIT_LIST_HEAD(&lu_context_remembered); + result = lu_ref_global_init(); if (result != 0) return result;