X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Flmv%2Flmv_objmgr.c;h=5ed25448da050755b887462dc3e75f15894961c5;hb=8291fd759cb6ab776e7c10238a560766bf73a19d;hp=34042a79d5b81142450d38d564f92c2d9b41847c;hpb=ac606470fe01743b1af98b29c07cadbd792c9614;p=fs%2Flustre-release.git diff --git a/lustre/lmv/lmv_objmgr.c b/lustre/lmv/lmv_objmgr.c index 34042a7..5ed2544 100644 --- a/lustre/lmv/lmv_objmgr.c +++ b/lustre/lmv/lmv_objmgr.c @@ -48,8 +48,13 @@ #include #include "lmv_internal.h" -static LIST_HEAD(lmv_obj_list); -static spinlock_t lmv_obj_list_lock = SPIN_LOCK_UNLOCKED; +/* objects cache. */ +extern kmem_cache_t *obj_cache; +extern atomic_t obj_cache_count; + +/* object list and its guard. */ +static LIST_HEAD(obj_list); +static spinlock_t obj_list_lock = SPIN_LOCK_UNLOCKED; /* creates new obj on passed @id and @mea. */ struct lmv_obj * @@ -65,10 +70,13 @@ lmv_alloc_obj(struct obd_device *obd, LASSERT(mea->mea_magic == MEA_MAGIC_LAST_CHAR || mea->mea_magic == MEA_MAGIC_ALL_CHARS); - OBD_ALLOC(obj, sizeof(*obj)); + OBD_SLAB_ALLOC(obj, obj_cache, GFP_NOFS, + sizeof(*obj)); if (!obj) return NULL; + atomic_inc(&obj_cache_count); + obj->id = *id; obj->obd = obd; obj->state = 0; @@ -92,6 +100,7 @@ lmv_alloc_obj(struct obd_device *obd, CDEBUG(D_OTHER, "subobj "DLID4"\n", OLID4(&mea->mea_ids[i])); obj->objs[i].id = mea->mea_ids[i]; + LASSERT(id_ino(&obj->objs[i].id)); LASSERT(id_fid(&obj->objs[i].id)); } @@ -109,34 +118,34 @@ lmv_free_obj(struct lmv_obj *obj) unsigned int obj_size; struct lmv_obd *lmv = &obj->obd->u.lmv; + LASSERT(!atomic_read(&obj->count)); + obj_size = sizeof(struct lmv_inode) * lmv->desc.ld_tgt_count; OBD_FREE(obj->objs, obj_size); - OBD_FREE(obj, sizeof(*obj)); + OBD_SLAB_FREE(obj, obj_cache, sizeof(*obj)); + atomic_dec(&obj_cache_count); } static void __add_obj(struct lmv_obj *obj) { atomic_inc(&obj->count); - list_add(&obj->list, &lmv_obj_list); + list_add(&obj->list, &obj_list); } void lmv_add_obj(struct lmv_obj *obj) { - spin_lock(&lmv_obj_list_lock); + spin_lock(&obj_list_lock); __add_obj(obj); - spin_unlock(&lmv_obj_list_lock); + spin_unlock(&obj_list_lock); } static void __del_obj(struct lmv_obj *obj) { - if (!(obj->state & O_FREEING)) - LBUG(); - list_del(&obj->list); lmv_free_obj(obj); } @@ -144,15 +153,15 @@ __del_obj(struct lmv_obj *obj) void lmv_del_obj(struct lmv_obj *obj) { - spin_lock(&lmv_obj_list_lock); + spin_lock(&obj_list_lock); __del_obj(obj); - spin_unlock(&lmv_obj_list_lock); + spin_unlock(&obj_list_lock); } static struct lmv_obj * __get_obj(struct lmv_obj *obj) { - LASSERT(obj); + LASSERT(obj != NULL); atomic_inc(&obj->count); return obj; } @@ -160,10 +169,9 @@ __get_obj(struct lmv_obj *obj) struct lmv_obj * lmv_get_obj(struct lmv_obj *obj) { - spin_lock(&lmv_obj_list_lock); + spin_lock(&obj_list_lock); __get_obj(obj); - spin_unlock(&lmv_obj_list_lock); - + spin_unlock(&obj_list_lock); return obj; } @@ -183,9 +191,9 @@ __put_obj(struct lmv_obj *obj) void lmv_put_obj(struct lmv_obj *obj) { - spin_lock(&lmv_obj_list_lock); + spin_lock(&obj_list_lock); __put_obj(obj); - spin_unlock(&lmv_obj_list_lock); + spin_unlock(&obj_list_lock); } static struct lmv_obj * @@ -194,7 +202,7 @@ __grab_obj(struct obd_device *obd, struct lustre_id *id) struct lmv_obj *obj; struct list_head *cur; - list_for_each(cur, &lmv_obj_list) { + list_for_each(cur, &obj_list) { obj = list_entry(cur, struct lmv_obj, list); /* check if object is in progress of destroying. If so - skip @@ -202,6 +210,16 @@ __grab_obj(struct obd_device *obd, struct lustre_id *id) if (obj->state & O_FREEING) continue; + /* + * we should make sure, that we have found object belong to + * passed obd. It is possible that, object manager will have two + * objects with the same fid belong to different obds, if client + * and mds runs on the same host. May be it is good idea to have + * objects list assosiated with obd. + */ + if (obj->obd != obd) + continue; + /* check if this is what we're looking for. */ if (id_equal_fid(&obj->id, id)) return __get_obj(obj); @@ -216,9 +234,9 @@ lmv_grab_obj(struct obd_device *obd, struct lustre_id *id) struct lmv_obj *obj; ENTRY; - spin_lock(&lmv_obj_list_lock); + spin_lock(&obj_list_lock); obj = __grab_obj(obd, id); - spin_unlock(&lmv_obj_list_lock); + spin_unlock(&obj_list_lock); RETURN(obj); } @@ -242,19 +260,19 @@ __create_obj(struct obd_device *obd, struct lustre_id *id, struct mea *mea) /* check if someone create it already while we were dealing with * allocating @obj. */ - spin_lock(&lmv_obj_list_lock); + spin_lock(&obj_list_lock); obj = __grab_obj(obd, id); if (obj) { /* someone created it already - put @obj and getting out. */ lmv_free_obj(new); - spin_unlock(&lmv_obj_list_lock); + spin_unlock(&obj_list_lock); RETURN(obj); } __add_obj(new); __get_obj(new); - spin_unlock(&lmv_obj_list_lock); + spin_unlock(&obj_list_lock); CDEBUG(D_OTHER, "new obj in lmv cache: "DLID4"\n", OLID4(id)); @@ -273,25 +291,26 @@ lmv_create_obj(struct obd_export *exp, struct lustre_id *id, struct mea *mea) struct ptlrpc_request *req = NULL; struct lmv_obj *obj; struct lustre_md md; - int mealen, i, rc; + int mealen, rc; ENTRY; CDEBUG(D_OTHER, "get mea for "DLID4" and create lmv obj\n", OLID4(id)); - if (!mea) { - unsigned long valid; + md.mea = NULL; + + if (mea == NULL) { + __u64 valid; CDEBUG(D_OTHER, "mea isn't passed in, get it now\n"); mealen = MEA_SIZE_LMV(lmv); /* time to update mea of parent id */ - i = id->li_fid.lf_group; md.mea = NULL; - - valid = OBD_MD_FLEASIZE | OBD_MD_FLDIREA; - rc = md_getattr(lmv->tgts[id->li_fid.lf_group].ltd_exp, - id, valid, mealen, &req); + valid = OBD_MD_FLEASIZE | OBD_MD_FLDIREA | OBD_MD_MEA; + + rc = md_getattr(lmv->tgts[id_group(id)].ltd_exp, + id, valid, NULL, 0, mealen, &req); if (rc) { CERROR("md_getattr() failed, error %d\n", rc); GOTO(cleanup, obj = ERR_PTR(rc)); @@ -303,7 +322,7 @@ lmv_create_obj(struct obd_export *exp, struct lustre_id *id, struct mea *mea) GOTO(cleanup, obj = ERR_PTR(rc)); } - if (!md.mea) + if (md.mea == NULL) GOTO(cleanup, obj = ERR_PTR(-ENODATA)); mea = md.mea; @@ -316,16 +335,23 @@ lmv_create_obj(struct obd_export *exp, struct lustre_id *id, struct mea *mea) OLID4(id)); GOTO(cleanup, obj = ERR_PTR(-ENOMEM)); } + + if (md.mea != NULL) + obd_free_memmd(exp, (struct lov_stripe_md **)&md.mea); + + EXIT; cleanup: - if (req) + if (req) ptlrpc_req_finished(req); - RETURN(obj); + return obj; } -/* looks for object with @id and orders to destroy it. It is possible the - * object will not be destroyed right now, because it is still using by - * someone. In this case it will be marked as "freeing" and will not be - * accessible anymore for subsequent callers of lmv_grab_obj(). */ +/* + * looks for object with @id and orders to destroy it. It is possible the object + * will not be destroyed right now, because it is still using by someone. In + * this case it will be marked as "freeing" and will not be accessible anymore + * for subsequent callers of lmv_grab_obj(). + */ int lmv_delete_obj(struct obd_export *exp, struct lustre_id *id) { @@ -334,53 +360,55 @@ lmv_delete_obj(struct obd_export *exp, struct lustre_id *id) int rc = 0; ENTRY; - spin_lock(&lmv_obj_list_lock); - + spin_lock(&obj_list_lock); obj = __grab_obj(obd, id); if (obj) { obj->state |= O_FREEING; - - if (atomic_read(&obj->count) > 1) - CERROR("obj "DLID4" has count > 2 (%d)\n", - OLID4(&obj->id), atomic_read(&obj->count)); __put_obj(obj); __put_obj(obj); rc = 1; } + spin_unlock(&obj_list_lock); - spin_unlock(&lmv_obj_list_lock); RETURN(rc); } int lmv_setup_mgr(struct obd_device *obd) { + ENTRY; + LASSERT(obd != NULL); + CDEBUG(D_INFO, "LMV object manager setup (%s)\n", obd->obd_uuid.uuid); - return 0; + + RETURN(0); } void lmv_cleanup_mgr(struct obd_device *obd) { - struct lmv_obj *obj; struct list_head *cur, *tmp; + struct lmv_obj *obj; + ENTRY; CDEBUG(D_INFO, "LMV object manager cleanup (%s)\n", obd->obd_uuid.uuid); - spin_lock(&lmv_obj_list_lock); - list_for_each_safe(cur, tmp, &lmv_obj_list) { + spin_lock(&obj_list_lock); + list_for_each_safe(cur, tmp, &obj_list) { obj = list_entry(cur, struct lmv_obj, list); if (obj->obd != obd) continue; obj->state |= O_FREEING; - if (atomic_read(&obj->count) > 1) + if (atomic_read(&obj->count) > 1) { CERROR("obj "DLID4" has count > 1 (%d)\n", OLID4(&obj->id), atomic_read(&obj->count)); + } __put_obj(obj); } - spin_unlock(&lmv_obj_list_lock); + spin_unlock(&obj_list_lock); + EXIT; }