X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fosd-ldiskfs%2Fosd_iam.c;h=8d10fe9e4c6ca79d2626d5d505786192a341aad2;hb=6630a5fccdc287b61d1cf532aed37b98bb7103f2;hp=4db8b1d6e4a956ec3f45c4e57a005731925bc5e8;hpb=9fb46705ae86aa2c0ac29427f0ff24f923560eb7;p=fs%2Flustre-release.git diff --git a/lustre/osd-ldiskfs/osd_iam.c b/lustre/osd-ldiskfs/osd_iam.c index 4db8b1d..8d10fe9 100644 --- a/lustre/osd-ldiskfs/osd_iam.c +++ b/lustre/osd-ldiskfs/osd_iam.c @@ -27,7 +27,7 @@ * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2012, Whamcloud, Inc. + * Copyright (c) 2011, 2014, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -147,23 +147,26 @@ #include #include #include + +#include +#include +#undef ENTRY + #include "osd_internal.h" -#include "xattr.h" -#include "acl.h" +#include /* * List of all registered formats. * * No locking. Callers synchronize. */ -static CFS_LIST_HEAD(iam_formats); +static struct list_head iam_formats = LIST_HEAD_INIT(iam_formats); void iam_format_register(struct iam_format *fmt) { - cfs_list_add(&fmt->if_linkage, &iam_formats); + list_add(&fmt->if_linkage, &iam_formats); } -EXPORT_SYMBOL(iam_format_register); static struct buffer_head * iam_load_idle_blocks(struct iam_container *c, iam_ptr_t blk) @@ -173,7 +176,7 @@ iam_load_idle_blocks(struct iam_container *c, iam_ptr_t blk) struct buffer_head *bh; int err; - LASSERT_SEM_LOCKED(&c->ic_idle_sem); + LASSERT(mutex_is_locked(&c->ic_idle_mutex)); if (blk == 0) return NULL; @@ -222,7 +225,7 @@ static int iam_format_guess(struct iam_container *c) } result = -ENOENT; - cfs_list_for_each_entry(fmt, &iam_formats, if_linkage) { + list_for_each_entry(fmt, &iam_formats, if_linkage) { result = fmt->if_guess(c); if (result == 0) break; @@ -237,13 +240,13 @@ static int iam_format_guess(struct iam_container *c) idle_blocks = (__u32 *)(c->ic_root_bh->b_data + c->ic_descr->id_root_gap + sizeof(struct dx_countlimit)); - down(&c->ic_idle_sem); + mutex_lock(&c->ic_idle_mutex); bh = iam_load_idle_blocks(c, le32_to_cpu(*idle_blocks)); if (bh != NULL && IS_ERR(bh)) result = PTR_ERR(bh); else c->ic_idle_bh = bh; - up(&c->ic_idle_sem); + mutex_unlock(&c->ic_idle_mutex); } return result; @@ -260,10 +263,9 @@ int iam_container_init(struct iam_container *c, c->ic_object = inode; init_rwsem(&c->ic_sem); dynlock_init(&c->ic_tree_lock); - sema_init(&c->ic_idle_sem, 1); + mutex_init(&c->ic_idle_mutex); return 0; } -EXPORT_SYMBOL(iam_container_init); /* * Determine container format. @@ -272,7 +274,6 @@ int iam_container_setup(struct iam_container *c) { return iam_format_guess(c); } -EXPORT_SYMBOL(iam_container_setup); /* * Finalize container @c, release all resources. @@ -284,7 +285,6 @@ void iam_container_fini(struct iam_container *c) brelse(c->ic_root_bh); c->ic_root_bh = NULL; } -EXPORT_SYMBOL(iam_container_fini); void iam_path_init(struct iam_path *path, struct iam_container *c, struct iam_path_descr *pd) @@ -350,12 +350,10 @@ struct iam_path_descr *iam_ipd_alloc(void *area, int keysize) ipd->ipd_key_scratch[i] = karea; return ipd; } -EXPORT_SYMBOL(iam_ipd_alloc); void iam_ipd_free(struct iam_path_descr *ipd) { } -EXPORT_SYMBOL(iam_ipd_free); int iam_node_read(struct iam_container *c, iam_ptr_t ptr, handle_t *h, struct buffer_head **bh) @@ -456,33 +454,33 @@ static int iam_path_check(struct iam_path *p) static int iam_leaf_load(struct iam_path *path) { - iam_ptr_t block; - int err; - struct iam_container *c; - struct buffer_head *bh; - struct iam_leaf *leaf; - struct iam_descr *descr; - - c = path->ip_container; - leaf = &path->ip_leaf; - descr = iam_path_descr(path); - block = path->ip_frame->leaf; - if (block == 0) { - /* XXX bug 11027 */ - printk(CFS_KERN_EMERG "wrong leaf: %lu %d [%p %p %p]\n", - (long unsigned)path->ip_frame->leaf, - dx_get_count(dx_node_get_entries(path, path->ip_frame)), - path->ip_frames[0].bh, path->ip_frames[1].bh, - path->ip_frames[2].bh); - } - err = descr->id_ops->id_node_read(c, block, NULL, &bh); - if (err == 0) { - leaf->il_bh = bh; - leaf->il_curidx = block; - err = iam_leaf_ops(leaf)->init(leaf); - assert_inv(ergo(err == 0, iam_leaf_check(leaf))); - } - return err; + iam_ptr_t block; + int err; + struct iam_container *c; + struct buffer_head *bh; + struct iam_leaf *leaf; + struct iam_descr *descr; + + c = path->ip_container; + leaf = &path->ip_leaf; + descr = iam_path_descr(path); + block = path->ip_frame->leaf; + if (block == 0) { + /* XXX bug 11027 */ + printk(KERN_EMERG "wrong leaf: %lu %d [%p %p %p]\n", + (long unsigned)path->ip_frame->leaf, + dx_get_count(dx_node_get_entries(path, path->ip_frame)), + path->ip_frames[0].bh, path->ip_frames[1].bh, + path->ip_frames[2].bh); + } + err = descr->id_ops->id_node_read(c, block, NULL, &bh); + if (err == 0) { + leaf->il_bh = bh; + leaf->il_curidx = block; + err = iam_leaf_ops(leaf)->init(leaf); + assert_inv(ergo(err == 0, iam_leaf_check(leaf))); + } + return err; } static void iam_unlock_htree(struct iam_container *ic, @@ -543,7 +541,8 @@ int iam_leaf_at_end(const struct iam_leaf *leaf) return iam_leaf_ops(leaf)->at_end(leaf); } -void iam_leaf_split(struct iam_leaf *l, struct buffer_head **bh, iam_ptr_t nr) +static void iam_leaf_split(struct iam_leaf *l, struct buffer_head **bh, + iam_ptr_t nr) { iam_leaf_ops(l)->split(l, bh, nr); } @@ -604,7 +603,7 @@ static int iam_txn_dirty(handle_t *handle, { int result; - result = ldiskfs_journal_dirty_metadata(handle, bh); + result = ldiskfs_handle_dirty_metadata(handle, NULL, bh); if (result != 0) ldiskfs_std_error(iam_path_obj(path)->i_sb, result); return result; @@ -724,7 +723,6 @@ int iam_it_init(struct iam_iterator *it, struct iam_container *c, __u32 flags, iam_path_init(&it->ii_path, c, pd); return 0; } -EXPORT_SYMBOL(iam_it_init); /* * Finalize iterator and release all resources. @@ -736,7 +734,6 @@ void iam_it_fini(struct iam_iterator *it) assert_corr(it_state(it) == IAM_IT_DETACHED); iam_path_fini(&it->ii_path); } -EXPORT_SYMBOL(iam_it_fini); /* * this locking primitives are used to protect parts @@ -749,7 +746,7 @@ static struct dynlock_handle *iam_lock_htree(struct iam_container *ic, return dynlock_lock(&ic->ic_tree_lock, value, lt, GFP_NOFS); } -int iam_index_lock(struct iam_path *path, struct dynlock_handle **lh) +static int iam_index_lock(struct iam_path *path, struct dynlock_handle **lh) { struct iam_frame *f; @@ -809,8 +806,8 @@ int dx_index_is_compat(struct iam_path *path) * */ -struct iam_entry *iam_find_position(struct iam_path *path, - struct iam_frame *frame) +static struct iam_entry *iam_find_position(struct iam_path *path, + struct iam_frame *frame) { int count; struct iam_entry *p; @@ -1036,13 +1033,11 @@ static int iam_check_full_path(struct iam_path *path, int search) * Performs path lookup and returns with found leaf (if any) locked by htree * lock. */ -int iam_lookup_lock(struct iam_path *path, - struct dynlock_handle **dl, enum dynlock_type lt) +static int iam_lookup_lock(struct iam_path *path, + struct dynlock_handle **dl, enum dynlock_type lt) { int result; - struct inode *dir; - dir = iam_path_obj(path); while ((result = __iam_path_lookup(path)) == 0) { do_corr(schedule()); *dl = iam_lock_htree(path->ip_container, path->ip_frame->leaf, @@ -1072,13 +1067,11 @@ int iam_lookup_lock(struct iam_path *path, static int iam_path_lookup(struct iam_path *path, int index) { struct iam_container *c; - struct iam_descr *descr; struct iam_leaf *leaf; int result; c = path->ip_container; leaf = &path->ip_leaf; - descr = iam_path_descr(path); result = iam_lookup_lock(path, &leaf->il_lock, DLT_WRITE); assert_inv(iam_path_check(path)); do_corr(schedule()); @@ -1199,7 +1192,6 @@ int iam_it_get(struct iam_iterator *it, const struct iam_key *k) it_keycmp(it, k) <= 0)); return result; } -EXPORT_SYMBOL(iam_it_get); /* * Attach iterator by index key. @@ -1238,7 +1230,6 @@ int iam_it_get_at(struct iam_iterator *it, const struct iam_key *k) assert_corr(ergo(result >= 0, it_state(it) == IAM_IT_ATTACHED)); return result; } -EXPORT_SYMBOL(iam_it_get_at); /* * Duplicates iterator. @@ -1279,7 +1270,6 @@ void iam_it_put(struct iam_iterator *it) iam_leaf_fini(&it->ii_path.ip_leaf); } } -EXPORT_SYMBOL(iam_it_put); static struct iam_ikey *iam_it_ikey_get(const struct iam_iterator *it, struct iam_ikey *ikey); @@ -1415,7 +1405,7 @@ static void iam_unlock_array(struct iam_container *ic, int iam_index_next(struct iam_container *c, struct iam_path *path) { iam_ptr_t cursor; - struct dynlock_handle *lh[DX_MAX_TREE_HEIGHT] = { 0, }; + struct dynlock_handle *lh[DX_MAX_TREE_HEIGHT] = { NULL, }; int result; struct inode *object; @@ -1500,7 +1490,6 @@ int iam_it_next(struct iam_iterator *it) int result; struct iam_path *path; struct iam_leaf *leaf; - struct inode *obj; do_corr(struct iam_ikey *ik_orig); /* assert_corr(it->ii_flags&IAM_IT_MOVE); */ @@ -1509,7 +1498,6 @@ int iam_it_next(struct iam_iterator *it) path = &it->ii_path; leaf = &path->ip_leaf; - obj = iam_path_obj(path); assert_corr(iam_leaf_is_locked(leaf)); @@ -1559,7 +1547,6 @@ int iam_it_next(struct iam_iterator *it) it_ikeycmp(it, ik_orig) >= 0)); return result; } -EXPORT_SYMBOL(iam_it_next); /* * Return pointer to the record under iterator. @@ -1573,7 +1560,6 @@ struct iam_rec *iam_it_rec_get(const struct iam_iterator *it) assert_corr(it_at_rec(it)); return iam_leaf_rec(&it->ii_path.ip_leaf); } -EXPORT_SYMBOL(iam_it_rec_get); static void iam_it_reccpy(struct iam_iterator *it, const struct iam_rec *r) { @@ -1611,7 +1597,6 @@ int iam_it_rec_set(handle_t *h, } return result; } -EXPORT_SYMBOL(iam_it_rec_set); /* * Return pointer to the index key under iterator. @@ -1641,7 +1626,6 @@ struct iam_key *iam_it_key_get(const struct iam_iterator *it) assert_corr(it_at_rec(it)); return iam_leaf_key(&it->ii_path.ip_leaf); } -EXPORT_SYMBOL(iam_it_key_get); /* * Return size of key under iterator (in bytes) @@ -1656,9 +1640,8 @@ int iam_it_key_size(const struct iam_iterator *it) assert_corr(it_at_rec(it)); return iam_leaf_key_size(&it->ii_path.ip_leaf); } -EXPORT_SYMBOL(iam_it_key_size); -struct buffer_head * +static struct buffer_head * iam_new_node(handle_t *h, struct iam_container *c, iam_ptr_t *b, int *e) { struct inode *inode = c->ic_object; @@ -1671,9 +1654,9 @@ iam_new_node(handle_t *h, struct iam_container *c, iam_ptr_t *b, int *e) if (c->ic_idle_bh == NULL) goto newblock; - down(&c->ic_idle_sem); + mutex_lock(&c->ic_idle_mutex); if (unlikely(c->ic_idle_bh == NULL)) { - up(&c->ic_idle_sem); + mutex_unlock(&c->ic_idle_mutex); goto newblock; } @@ -1687,11 +1670,11 @@ iam_new_node(handle_t *h, struct iam_container *c, iam_ptr_t *b, int *e) --count; *b = le32_to_cpu(head->iih_blks[count]); head->iih_count = cpu_to_le16(count); - *e = ldiskfs_journal_dirty_metadata(h, c->ic_idle_bh); + *e = ldiskfs_handle_dirty_metadata(h, inode, c->ic_idle_bh); if (*e != 0) goto fail; - up(&c->ic_idle_sem); + mutex_unlock(&c->ic_idle_mutex); bh = ldiskfs_bread(NULL, inode, *b, 0, e); if (bh == NULL) return NULL; @@ -1711,7 +1694,7 @@ iam_new_node(handle_t *h, struct iam_container *c, iam_ptr_t *b, int *e) iam_lock_bh(c->ic_root_bh); *idle_blocks = head->iih_next; iam_unlock_bh(c->ic_root_bh); - *e = ldiskfs_journal_dirty_metadata(h, c->ic_root_bh); + *e = ldiskfs_handle_dirty_metadata(h, inode, c->ic_root_bh); if (*e != 0) { iam_lock_bh(c->ic_root_bh); *idle_blocks = cpu_to_le32(*b); @@ -1729,7 +1712,7 @@ iam_new_node(handle_t *h, struct iam_container *c, iam_ptr_t *b, int *e) } c->ic_idle_bh = idle; - up(&c->ic_idle_sem); + mutex_unlock(&c->ic_idle_mutex); got: /* get write access for the found buffer head */ @@ -1746,11 +1729,11 @@ got: return bh; newblock: - bh = ldiskfs_append(h, inode, b, e); + bh = osd_ldiskfs_append(h, inode, b, e); return bh; fail: - up(&c->ic_idle_sem); + mutex_unlock(&c->ic_idle_mutex); ldiskfs_std_error(inode->i_sb, *e); return NULL; } @@ -1820,12 +1803,12 @@ static int iam_new_leaf(handle_t *handle, struct iam_leaf *leaf) iam_unlock_htree(path->ip_container, lh); do_corr(schedule()); err = iam_txn_dirty(handle, path, new_leaf); - brelse(new_leaf); if (err == 0) err = ldiskfs_mark_inode_dirty(handle, obj); do_corr(schedule()); } else err = -ENOMEM; + brelse(new_leaf); } assert_inv(iam_leaf_check(leaf)); assert_inv(iam_leaf_check(&iam_leaf_path(leaf)->ip_leaf)); @@ -1898,8 +1881,8 @@ int split_index_node(handle_t *handle, struct iam_path *path, struct iam_entry *entries; /* old block contents */ struct iam_entry *entries2; /* new block contents */ - struct iam_frame *frame, *safe; - struct buffer_head *bh_new[DX_MAX_TREE_HEIGHT] = {0}; + struct iam_frame *frame, *safe; + struct buffer_head *bh_new[DX_MAX_TREE_HEIGHT] = {NULL}; u32 newblock[DX_MAX_TREE_HEIGHT] = {0}; struct dynlock_handle *lock[DX_MAX_TREE_HEIGHT] = {NULL,}; struct dynlock_handle *new_lock[DX_MAX_TREE_HEIGHT] = {NULL,}; @@ -2073,7 +2056,7 @@ int split_index_node(handle_t *handle, struct iam_path *path, ++ frame; assert_inv(dx_node_check(path, frame)); bh_new[0] = NULL; /* buffer head is "consumed" */ - err = ldiskfs_journal_dirty_metadata(handle, bh2); + err = ldiskfs_handle_dirty_metadata(handle, NULL, bh2); if (err) goto journal_error; do_corr(schedule()); @@ -2105,16 +2088,17 @@ int split_index_node(handle_t *handle, struct iam_path *path, dxtrace(dx_show_index ("node", frame->entries)); dxtrace(dx_show_index ("node", ((struct dx_node *) bh2->b_data)->entries)); - err = ldiskfs_journal_dirty_metadata(handle, bh2); + err = ldiskfs_handle_dirty_metadata(handle, NULL, bh2); if (err) goto journal_error; do_corr(schedule()); - err = ldiskfs_journal_dirty_metadata(handle, parent->bh); + err = ldiskfs_handle_dirty_metadata(handle, NULL, + parent->bh); if (err) goto journal_error; } do_corr(schedule()); - err = ldiskfs_journal_dirty_metadata(handle, bh); + err = ldiskfs_handle_dirty_metadata(handle, NULL, bh); if (err) goto journal_error; } @@ -2247,7 +2231,6 @@ int iam_it_rec_insert(handle_t *h, struct iam_iterator *it, it_keycmp(it, k) == 0)); return result; } -EXPORT_SYMBOL(iam_it_rec_insert); static inline int iam_idle_blocks_limit(struct inode *inode) { @@ -2388,7 +2371,7 @@ static void iam_recycle_leaf(handle_t *h, struct iam_path *p, int count; int rc; - down(&c->ic_idle_sem); + mutex_lock(&c->ic_idle_mutex); if (unlikely(c->ic_idle_failed)) { rc = -EFAULT; goto unlock; @@ -2421,7 +2404,7 @@ static void iam_recycle_leaf(handle_t *h, struct iam_path *p, rc = iam_txn_dirty(h, p, c->ic_idle_bh); unlock: - up(&c->ic_idle_sem); + mutex_unlock(&c->ic_idle_mutex); if (rc != 0) CWARN("%.16s: idle blocks failed, will lose the blk %u\n", LDISKFS_SB(inode->i_sb)->s_es->s_volume_name, blk); @@ -2482,7 +2465,6 @@ int iam_it_rec_delete(handle_t *h, struct iam_iterator *it) it_state(it) == IAM_IT_DETACHED); return result; } -EXPORT_SYMBOL(iam_it_rec_delete); /* * Convert iterator to cookie. @@ -2503,7 +2485,6 @@ iam_pos_t iam_it_store(const struct iam_iterator *it) result = 0; return *(iam_pos_t *)iam_it_ikey_get(it, (void *)&result); } -EXPORT_SYMBOL(iam_it_store); /* * Restore iterator from cookie. @@ -2520,7 +2501,6 @@ int iam_it_load(struct iam_iterator *it, iam_pos_t pos) assert_corr(iam_it_container(it)->ic_descr->id_ikey_size <= sizeof pos); return iam_it_iget(it, (struct iam_ikey *)&pos); } -EXPORT_SYMBOL(iam_it_load); /***********************************************************************/ /* invariants */ @@ -2531,7 +2511,7 @@ static inline int ptr_inside(void *base, size_t size, void *ptr) return (base <= ptr) && (ptr < base + size); } -int iam_frame_invariant(struct iam_frame *f) +static int iam_frame_invariant(struct iam_frame *f) { return (f->bh != NULL && @@ -2540,7 +2520,8 @@ int iam_frame_invariant(struct iam_frame *f) ptr_inside(f->bh->b_data, f->bh->b_size, f->at) && f->entries <= f->at); } -int iam_leaf_invariant(struct iam_leaf *l) + +static int iam_leaf_invariant(struct iam_leaf *l) { return l->il_bh != NULL && @@ -2550,7 +2531,7 @@ int iam_leaf_invariant(struct iam_leaf *l) l->il_entries <= l->il_at; } -int iam_path_invariant(struct iam_path *p) +static int iam_path_invariant(struct iam_path *p) { int i; @@ -2605,7 +2586,6 @@ int iam_lookup(struct iam_container *c, const struct iam_key *k, iam_it_fini(&it); return result; } -EXPORT_SYMBOL(iam_lookup); /* * Insert new record @r with key @k into container @c (within context of @@ -2634,7 +2614,6 @@ int iam_insert(handle_t *h, struct iam_container *c, const struct iam_key *k, iam_it_fini(&it); return result; } -EXPORT_SYMBOL(iam_insert); /* * Update record with the key @k in container @c (within context of @@ -2665,7 +2644,6 @@ int iam_update(handle_t *h, struct iam_container *c, const struct iam_key *k, iam_it_fini(&it); return result; } -EXPORT_SYMBOL(iam_update); /* * Delete existing record with key @k. @@ -2690,7 +2668,6 @@ int iam_delete(handle_t *h, struct iam_container *c, const struct iam_key *k, iam_it_fini(&it); return result; } -EXPORT_SYMBOL(iam_delete); int iam_root_limit(int rootgap, int blocksize, int size) {