Delete the cfs wrappers for linux list and hlist api.
Removal of these wrappers exposed last remaining
unconverted list operators.
Signed-off-by: James Simmons <uja.ornl@gmail.com>
Change-Id: If72e68e93663174c5c3540e2444cc50d37d04a48
Reviewed-on: http://review.whamcloud.com/11797
Tested-by: Jenkins
Reviewed-by: Bob Glossman <bob.glossman@intel.com>
Tested-by: Maloo <hpdd-maloo@intel.com>
Reviewed-by: John L. Hammond <john.hammond@intel.com>
Reviewed-by: Nathaniel Clark <nathaniel.l.clark@intel.com>
Reviewed-by: Oleg Drokin <oleg.drokin@intel.com>
################################################################################
# list operations
-s/\bcfs_list_t\b/struct list_head/g
-s/\b__cfs_list_add\b/__list_add/g
-/#[ \t]*define[ \t]*\b__list_add\b *(.*)[ \t]*\b__list_add\b *(.*)/d
-s/\bcfs_list_add\b/list_add/g
-/#[ \t]*define[ \t]*\blist_add\b *(.*)[ \t]*\blist_add\b *(.*)/d
-s/\bcfs_list_add_tail\b/list_add_tail/g
-/#[ \t]*define[ \t]*\blist_add_tail\b *(.*)[ \t]*\blist_add_tail\b *(.*)/d
-s/\b__cfs_list_del\b/__list_del/g
-/#[ \t]*define[ \t]*\b__list_del\b *(.*)[ \t]*\b__list_del\b *(.*)/d
-s/\bcfs_list_del\b/list_del/g
-/#[ \t]*define[ \t]*\blist_del\b *(.*)[ \t]*\blist_del\b *(.*)/d
-s/\bcfs_list_del_init\b/list_del_init/g
-/#[ \t]*define[ \t]*\blist_del_init\b *(.*)[ \t]*\blist_del_init\b *(.*)/d
-s/\bcfs_list_move\b/list_move/g
-/#[ \t]*define[ \t]*\blist_move\b *(.*)[ \t]*\blist_move\b *(.*)/d
-s/\bcfs_list_move_tail\b/list_move_tail/g
-/#[ \t]*define[ \t]*\blist_move_tail\b *(.*)[ \t]*\blist_move_tail\b *(.*)/d
-s/\bcfs_list_empty\b/list_empty/g
-/#[ \t]*define[ \t]*\blist_empty\b *(.*)[ \t]*\blist_empty\b *(.*)/d
-s/\bcfs_list_empty_careful\b/list_empty_careful/g
-/#[ \t]*define[ \t]*\blist_empty_careful\b *(.*)[ \t]*\blist_empty_careful\b *(.*)/d
-s/\b__cfs_list_splice\b/__list_splice/g
-/#[ \t]*define[ \t]*\b__list_splice\b *(.*)[ \t]*\b__list_splice\b *(.*)/d
-s/\bcfs_list_splice\b/list_splice/g
-/#[ \t]*define[ \t]*\blist_splice\b *(.*)[ \t]*\blist_splice\b *(.*)/d
-s/\bcfs_list_splice_init\b/list_splice_init/g
-/#[ \t]*define[ \t]*\blist_splice_init\b *(.*)[ \t]*\blist_splice_init\b *(.*)/d
-s/\bcfs_list_entry\b/list_entry/g
-/#[ \t]*define[ \t]*\blist_entry\b *(.*)[ \t]*\blist_entry\b *(.*)/d
-s/\bcfs_list_for_each\b/list_for_each/g
-/#[ \t]*define[ \t]*\blist_for_each\b *(.*)[ \t]*\blist_for_each\b *(.*)/d
-s/\bcfs_list_for_each_safe\b/list_for_each_safe/g
-/#[ \t]*define[ \t]*\blist_for_each_safe\b *(.*)[ \t]*\blist_for_each_safe\b *(.*)/d
-s/\bcfs_list_for_each_prev\b/list_for_each_prev/g
-/#[ \t]*define[ \t]*\blist_for_each_prev\b *(.*)[ \t]*\blist_for_each_prev\b *(.*)/d
-s/\bcfs_list_for_each_entry\b/list_for_each_entry/g
-/#[ \t]*define[ \t]*\blist_for_each_entry\b *(.*)[ \t]*\blist_for_each_entry\b *(.*)/d
-s/\bcfs_list_for_each_entry_reverse\b/list_for_each_entry_reverse/g
-/#[ \t]*define[ \t]*\blist_for_each_entry_reverse\b *(.*)[ \t]*\blist_for_each_entry_reverse\b *(.*)/d
-s/\bcfs_list_for_each_entry_safe_reverse\b/list_for_each_entry_safe_reverse/g
-/#[ \t]*define[ \t]*\blist_for_each_entry_safe_reverse\b *(.*)[ \t]*\blist_for_each_entry_safe_reverse\b *(.*)/d
-s/\bcfs_list_for_each_entry_safe\b/list_for_each_entry_safe/g
-/#[ \t]*define[ \t]*\blist_for_each_entry_safe\b *(.*)[ \t]*\blist_for_each_entry_safe\b *(.*)/d
-s/\bcfs_list_for_each_entry_safe_from\b/list_for_each_entry_safe_from/g
-/#[ \t]*define[ \t]*\blist_for_each_entry_safe_from\b *(.*)[ \t]*\blist_for_each_entry_safe_from\b *(.*)/d
-s/\bcfs_list_for_each_entry_continue\b/list_for_each_entry_continue/g
-/#[ \t]*define[ \t]*\blist_for_each_entry_continue\b *(.*)[ \t]*\blist_for_each_entry_continue\b *(.*)/d
-# LIST_HEAD defined in /usr/include/sys/queue.h
-s/\bCFS_LIST_HEAD_INIT\b/LIST_HEAD_INIT/g
-/#[ \t]*define[ \t]*\bLIST_HEAD_INIT\b *(.*)[ \t]*\bLIST_HEAD_INIT\b *(.*)/d
-s/\bCFS_LIST_HEAD\b/LIST_HEAD/g
-/#[ \t]*define[ \t]*\bLIST_HEAD\b *(.*)[ \t]*\bLIST_HEAD\b *(.*)/d
-s/\bCFS_INIT_LIST_HEAD\b/INIT_LIST_HEAD/g
-/#[ \t]*define[ \t]*\bINIT_LIST_HEAD\b *(.*)[ \t]*\bINIT_LIST_HEAD\b *(.*)/d
-s/\bcfs_hlist_head_t\b/struct hlist_head/g
-s/\bcfs_hlist_node_t\b/struct hlist_node/g
-s/\bcfs_hlist_unhashed\b/hlist_unhashed/g
-/#[ \t]*define[ \t]*\bhlist_unhashed\b *(.*)[ \t]*\bhlist_unhashed\b *(.*)/d
-s/\bcfs_hlist_empty\b/hlist_empty/g
-/#[ \t]*define[ \t]*\bhlist_empty\b *(.*)[ \t]*\bhlist_empty\b *(.*)/d
-s/\b__cfs_hlist_del\b/__hlist_del/g
-/#[ \t]*define[ \t]*\b__hlist_del\b *(.*)[ \t]*\b__hlist_del\b *(.*)/d
-s/\bcfs_hlist_del\b/hlist_del/g
-/#[ \t]*define[ \t]*\bhlist_del\b *(.*)[ \t]*\bhlist_del\b *(.*)/d
-s/\bcfs_hlist_del_init\b/hlist_del_init/g
-/#[ \t]*define[ \t]*\bhlist_del_init\b *(.*)[ \t]*\bhlist_del_init\b *(.*)/d
-s/\bcfs_hlist_add_head\b/hlist_add_head/g
-/#[ \t]*define[ \t]*\bhlist_add_head\b *(.*)[ \t]*\bhlist_add_head\b *(.*)/d
-s/\bcfs_hlist_add_before\b/hlist_add_before/g
-/#[ \t]*define[ \t]*\bhlist_add_before\b *(.*)[ \t]*\bhlist_add_before\b *(.*)/d
-s/\bcfs_hlist_add_after\b/hlist_add_after/g
-/#[ \t]*define[ \t]*\bhlist_add_after\b *(.*)[ \t]*\bhlist_add_after\b *(.*)/d
-s/\bcfs_hlist_entry\b/hlist_entry/g
-/#[ \t]*define[ \t]*\bhlist_entry\b *(.*)[ \t]*\bhlist_entry\b *(.*)/d
s/\bcfs_hlist_for_each\b/hlist_for_each/g
/#[ \t]*define[ \t]*\bhlist_for_each\b *(.*)[ \t]*\bhlist_for_each\b *(.*)/d
s/\bcfs_hlist_for_each_safe\b/hlist_for_each_safe/g
/#[ \t]*define[ \t]*\bhlist_for_each_entry_continue\b *(.*)[ \t]*\bhlist_for_each_entry_continue\b *(.*)/d
s/\bcfs_hlist_for_each_entry_from\b/hlist_for_each_entry_from/g
/#[ \t]*define[ \t]*\bhlist_for_each_entry_from\b *(.*)[ \t]*\bhlist_for_each_entry_from\b *(.*)/d
-s/\bCFS_HLIST_HEAD_INIT\b/HLIST_HEAD_INIT/g
-/#[ \t]*define[ \t]*\bHLIST_HEAD_INIT\b[ \t]*\bHLIST_HEAD_INIT\b/d
-s/\bCFS_HLIST_HEAD\b/HLIST_HEAD/g
-/#[ \t]*define[ \t]*\bHLIST_HEAD\b *(.*)[ \t]*\bHLIST_HEAD\b *(.*)/d
-s/\bCFS_INIT_HLIST_HEAD\b/INIT_HLIST_HEAD/g
-/#[ \t]*define[ \t]*\bINIT_HLIST_HEAD\b *(.*)[ \t]*\bINIT_HLIST_HEAD\b *(.*)/d
-s/\bCFS_INIT_HLIST_NODE\b/INIT_HLIST_NODE/g
-/#[ \t]*define[ \t]*\bINIT_HLIST_NODE\b *(.*)[ \t]*\bINIT_HLIST_NODE\b *(.*)/d
-s/\bcfs_list_for_each_entry_safe_from\b/list_for_each_entry_safe_from/g
-/cfs_list_for_each_entry_typed/{;N;s/\(cfs_list_for_each_entry_typed\)\([^,]*,\)[ ,\t,\n]*\([^,]*,\)[ ,\t,\n]*\([^,]*,\)[ ,\t,\n]*/list_for_each_entry\2 \3 /}
-/cfs_list_for_each_entry_safe_typed/{;N;s/\(cfs_list_for_each_entry_safe_typed\)\([^,]*,\)[ ,\t,\n]*\([^,]*,\)[ ,\t,\n]*\([^,]*,\)[ ,\t,\n]*\([^,]*,\)[ ,\t,\n]*/list_for_each_entry_safe\2 \3 \4 /}
/* @} */
-#endif /* __KERNEL__ */
-
-#ifndef list_for_each_prev
/**
* Iterate over a list in reverse order
* \param pos the &struct list_head to use as a loop counter.
for (pos = (head)->prev, prefetch(pos->prev); pos != (head); \
pos = pos->prev, prefetch(pos->prev))
-#endif /* list_for_each_prev */
-
-#ifndef list_for_each_entry
/**
* Iterate over a list of given type
* \param pos the type * to use as a loop counter.
&pos->member != (head); \
pos = list_entry(pos->member.next, typeof(*pos), member), \
prefetch(pos->member.next))
-#endif /* list_for_each_entry */
-#ifndef list_for_each_entry_reverse
/**
* Iterate backwards over a list of given type.
* \param pos the type * to use as a loop counter.
for (pos = list_entry((head)->prev, typeof(*pos), member); \
prefetch(pos->member.prev), &pos->member != (head); \
pos = list_entry(pos->member.prev, typeof(*pos), member))
-#endif /* list_for_each_entry_reverse */
-#ifndef list_for_each_entry_safe
/**
* Iterate over a list of given type safe against removal of list entry
* \param pos the type * to use as a loop counter.
&pos->member != (head); \
pos = n, n = list_entry(n->member.next, typeof(*n), member))
-#endif /* list_for_each_entry_safe */
-
-/* Temporary until everything is moved over to linux api */
-typedef struct list_head cfs_list_t;
-
-#define __cfs_list_add(new, prev, next) __list_add(new, prev, next)
-#define cfs_list_add(new, head) list_add(new, head)
-
-#define cfs_list_add_tail(new, head) list_add_tail(new, head)
-
-#define __cfs_list_del(prev, next) __list_del(prev, next)
-#define cfs_list_del(entry) list_del(entry)
-#define cfs_list_del_init(entry) list_del_init(entry)
-
-#define cfs_list_move(list, head) list_move(list, head)
-#define cfs_list_move_tail(list, head) list_move_tail(list, head)
-
-#define cfs_list_empty(head) list_empty(head)
-#define cfs_list_empty_careful(head) list_empty_careful(head)
-
-#define __cfs_list_splice(list, head) __list_splice(list, head)
-#define cfs_list_splice(list, head) list_splice(list, head)
-#define cfs_list_splice_tail(list, head) list_splice_tail(list, head)
-
-#define cfs_list_splice_init(list, head) list_splice_init(list, head)
-
-#define cfs_list_entry(ptr, type, member) list_entry(ptr, type, member)
-#define cfs_list_for_each(pos, head) list_for_each(pos, head)
-#define cfs_list_for_each_safe(pos, n, head) list_for_each_safe(pos, n, head)
-
-#define cfs_list_for_each_prev(pos, head) list_for_each_prev(pos, head)
-#define cfs_list_for_each_entry(pos, head, member) \
- list_for_each_entry(pos, head, member)
-#define cfs_list_for_each_entry_reverse(pos, head, member) \
- list_for_each_entry_reverse(pos, head, member)
-#define cfs_list_for_each_entry_safe_reverse(pos, n, head, member) \
- list_for_each_entry_safe_reverse(pos, n, head, member)
-#define cfs_list_for_each_entry_safe(pos, n, head, member) \
- list_for_each_entry_safe(pos, n, head, member)
-#ifdef list_for_each_entry_safe_from
-#define cfs_list_for_each_entry_safe_from(pos, n, head, member) \
- list_for_each_entry_safe_from(pos, n, head, member)
-#endif /* list_for_each_entry_safe_from */
-#define cfs_list_for_each_entry_continue(pos, head, member) \
- list_for_each_entry_continue(pos, head, member)
-
-#define CFS_LIST_HEAD_INIT(n) LIST_HEAD_INIT(n)
-#define CFS_INIT_LIST_HEAD(p) INIT_LIST_HEAD(p)
-
-typedef struct hlist_head cfs_hlist_head_t;
-typedef struct hlist_node cfs_hlist_node_t;
-
-#define cfs_hlist_unhashed(h) hlist_unhashed(h)
-
-#define cfs_hlist_empty(h) hlist_empty(h)
-
-#define __cfs_hlist_del(n) __hlist_del(n)
-#define cfs_hlist_del(n) hlist_del(n)
-#define cfs_hlist_del_init(n) hlist_del_init(n)
-
-#define cfs_hlist_add_head(n, next) hlist_add_head(n, next)
-#define cfs_hlist_add_before(n, next) hlist_add_before(n, next)
-#define cfs_hlist_add_after(n, next) hlist_add_after(n, next)
+#endif /* __KERNEL__ */
-#define cfs_hlist_entry(ptr, type, member) hlist_entry(ptr, type, member)
-#define cfs_hlist_for_each(pos, head) hlist_for_each(pos, head)
-#define cfs_hlist_for_each_safe(pos, n, head) \
- hlist_for_each_safe(pos, n, head)
#ifdef HAVE_HLIST_FOR_EACH_3ARG
#define cfs_hlist_for_each_entry(tpos, pos, head, member) \
hlist_for_each_entry(tpos, head, member)
hlist_for_each_entry_from(tpos, pos, member)
#endif
-#define cfs_list_for_each_entry_typed(pos, head, type, member) \
- for (pos = list_entry((head)->next, type, member), \
- prefetch(pos->member.next); \
- &pos->member != (head); \
- pos = list_entry(pos->member.next, type, member), \
- prefetch(pos->member.next))
-
-#define cfs_list_for_each_entry_safe_typed(pos, n, head, type, member) \
- for (pos = list_entry((head)->next, type, member), \
- n = list_entry(pos->member.next, type, member); \
- &pos->member != (head); \
- pos = n, n = list_entry(n->member.next, type, member))
-
-#define CFS_HLIST_HEAD_INIT HLIST_HEAD_INIT
-#define CFS_HLIST_HEAD(n) HLIST_HEAD(n)
-#define CFS_INIT_HLIST_HEAD(p) INIT_HLIST_HEAD(p)
-#define CFS_INIT_HLIST_NODE(p) INIT_HLIST_NODE(p)
-
-#define CFS_LIST_HEAD(name) \
- struct list_head name = LIST_HEAD_INIT(name)
-
#endif /* __LIBCFS_LUSTRE_LIST_H__ */
dcb = &ccb->suc_cb;
dcb->dcb_func = seq_update_cb;
- CFS_INIT_LIST_HEAD(&dcb->dcb_linkage);
+ INIT_LIST_HEAD(&dcb->dcb_linkage);
strlcpy(dcb->dcb_name, "seq_update_cb", sizeof(dcb->dcb_name));
rc = dt_trans_cb_add(th, dcb);
const struct cl_object_conf *cconf;
cconf = lu2cl_conf(conf);
- CFS_INIT_LIST_HEAD(&vob->cob_pending_list);
+ INIT_LIST_HEAD(&vob->cob_pending_list);
lu_object_add(obj, below);
result = ccc_object_init0(env, vob, cconf);
} else
mask);
}
-static void *nodemap_hs_key(cfs_hlist_node_t *hnode)
+static void *nodemap_hs_key(struct hlist_node *hnode)
{
struct lu_nodemap *nodemap;
- nodemap = cfs_hlist_entry(hnode, struct lu_nodemap, nm_hash);
+ nodemap = hlist_entry(hnode, struct lu_nodemap, nm_hash);
return nodemap->nm_name;
}
static int nodemap_hs_keycmp(const void *key,
- cfs_hlist_node_t *compared_hnode)
+ struct hlist_node *compared_hnode)
{
char *nodemap_name;
return !strcmp(key, nodemap_name);
}
-static void *nodemap_hs_hashobject(cfs_hlist_node_t *hnode)
+static void *nodemap_hs_hashobject(struct hlist_node *hnode)
{
- return cfs_hlist_entry(hnode, struct lu_nodemap, nm_hash);
+ return hlist_entry(hnode, struct lu_nodemap, nm_hash);
}
-static void nodemap_hs_get(cfs_hash_t *hs, cfs_hlist_node_t *hnode)
+static void nodemap_hs_get(cfs_hash_t *hs, struct hlist_node *hnode)
{
struct lu_nodemap *nodemap;
- nodemap = cfs_hlist_entry(hnode, struct lu_nodemap, nm_hash);
+ nodemap = hlist_entry(hnode, struct lu_nodemap, nm_hash);
nodemap_getref(nodemap);
}
static void nodemap_hs_put_locked(cfs_hash_t *hs,
- cfs_hlist_node_t *hnode)
+ struct hlist_node *hnode)
{
struct lu_nodemap *nodemap;
- nodemap = cfs_hlist_entry(hnode, struct lu_nodemap, nm_hash);
+ nodemap = hlist_entry(hnode, struct lu_nodemap, nm_hash);
nodemap_putref(nodemap);
}
* \param data not used here
*/
static int nodemap_cleanup_iter_cb(cfs_hash_t *hs, cfs_hash_bd_t *bd,
- cfs_hlist_node_t *hnode, void *data)
+ struct hlist_node *hnode, void *data)
{
struct lu_nodemap *nodemap;
- nodemap = cfs_hlist_entry(hnode, struct lu_nodemap, nm_hash);
+ nodemap = hlist_entry(hnode, struct lu_nodemap, nm_hash);
nodemap_putref(nodemap);
return 0;
tgt->lut_lsd.lsd_start_epoch = start_epoch;
spin_unlock(&tgt->lut_translock);
- CFS_INIT_LIST_HEAD(&client_list);
+ INIT_LIST_HEAD(&client_list);
/**
* The recovery is not yet finished and final queue can still be updated
* with resend requests. Move final list to separate one for processing
dcb = &ccb->llcc_cb;
dcb->dcb_func = tgt_cb_last_committed;
- CFS_INIT_LIST_HEAD(&dcb->dcb_linkage);
+ INIT_LIST_HEAD(&dcb->dcb_linkage);
strlcpy(dcb->dcb_name, "tgt_cb_last_committed", sizeof(dcb->dcb_name));
rc = dt_trans_cb_add(th, dcb);
dcb = &ccb->lncc_cb;
dcb->dcb_func = tgt_cb_new_client;
- CFS_INIT_LIST_HEAD(&dcb->dcb_linkage);
+ INIT_LIST_HEAD(&dcb->dcb_linkage);
strlcpy(dcb->dcb_name, "tgt_cb_new_client", sizeof(dcb->dcb_name));
rc = dt_trans_cb_add(th, dcb);
lut->lut_txn_cb.dtc_txn_commit = NULL;
lut->lut_txn_cb.dtc_cookie = lut;
lut->lut_txn_cb.dtc_tag = LCT_DT_THREAD | LCT_MD_THREAD;
- CFS_INIT_LIST_HEAD(&lut->lut_txn_cb.dtc_linkage);
+ INIT_LIST_HEAD(&lut->lut_txn_cb.dtc_linkage);
dt_txn_callback_add(lut->lut_bottom, &lut->lut_txn_cb);
int hit, valid;
} *it_array;
static int it_count;
-static CFS_LIST_HEAD(header);
+static struct list_head header = LIST_HEAD_INIT(header);
static unsigned long max_count = ULONG_MAX & ALIGN_MASK;
static int have_wide_lock = 0;
return 1;
}
- CFS_INIT_LIST_HEAD(&grp_info_list);
+ INIT_LIST_HEAD(&grp_info_list);
rc = traverse_lost_found(src_dir, mount_path);
if (rc) {
fprintf(stderr, "error: traversing lost+found looking for "