Hi!
This patch changes kmem_zone_init() callers to use kmem_cache_alloc() so
we can kill the wrapper.
Signed-off-by: Pekka Enberg <penberg@xxxxxxxxxxxxxx>
---
linux-2.6/kmem.h | 6 ----
linux-2.6/xfs_buf.c | 3 +-
linux-2.6/xfs_super.c | 3 +-
quota/xfs_qm.c | 10 ++++----
support/ktrace.c | 10 ++++----
xfs_acl.h | 2 -
xfs_vfsops.c | 61 +++++++++++++++++++++++++++++++-------------------
7 files changed, 55 insertions(+), 40 deletions(-)
diff --git a/fs/xfs/linux-2.6/kmem.h b/fs/xfs/linux-2.6/kmem.h
index c64a29c..20ab643 100644
--- a/fs/xfs/linux-2.6/kmem.h
+++ b/fs/xfs/linux-2.6/kmem.h
@@ -92,12 +92,6 @@ static __inline gfp_t kmem_flags_convert
return lflags;
}
-static __inline kmem_zone_t *
-kmem_zone_init(int size, char *zone_name)
-{
- return kmem_cache_create(zone_name, size, 0, 0, NULL, NULL);
-}
-
static __inline void
kmem_zone_free(kmem_zone_t *zone, void *ptr)
{
diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
index bfb4f29..1f04ef1 100644
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -1811,7 +1811,8 @@ xfs_buf_init(void)
xfs_buf_trace_buf = ktrace_alloc(XFS_BUF_TRACE_SIZE, KM_SLEEP);
#endif
- xfs_buf_zone = kmem_zone_init(sizeof(xfs_buf_t), "xfs_buf");
+ xfs_buf_zone = kmem_cache_create("xfs_buf", sizeof(xfs_buf_t), 0, 0,
+ NULL, NULL);
if (!xfs_buf_zone)
goto out_free_trace_buf;
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index f22e426..f464b0d 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -374,7 +374,8 @@ linvfs_init_zones(void)
if (!xfs_vnode_zone)
goto out;
- xfs_ioend_zone = kmem_zone_init(sizeof(xfs_ioend_t), "xfs_ioend");
+ xfs_ioend_zone = kmem_cache_create("xfs_ioend", sizeof(xfs_ioend_t),
+ 0, 0, NULL, NULL);
if (!xfs_ioend_zone)
goto out_destroy_vnode_zone;
diff --git a/fs/xfs/quota/xfs_qm.c b/fs/xfs/quota/xfs_qm.c
index 7c0e39d..8dcf9b9 100644
--- a/fs/xfs/quota/xfs_qm.c
+++ b/fs/xfs/quota/xfs_qm.c
@@ -148,8 +148,9 @@ xfs_Gqm_init(void)
* dquot zone. we register our own low-memory callback.
*/
if (!qm_dqzone) {
- xqm->qm_dqzone = kmem_zone_init(sizeof(xfs_dquot_t),
- "xfs_dquots");
+ xqm->qm_dqzone = kmem_cache_create("xfs_dquots",
+ sizeof(xfs_dquot_t),
+ 0, 0, NULL, NULL);
qm_dqzone = xqm->qm_dqzone;
} else
xqm->qm_dqzone = qm_dqzone;
@@ -160,8 +161,9 @@ xfs_Gqm_init(void)
* The t_dqinfo portion of transactions.
*/
if (!qm_dqtrxzone) {
- xqm->qm_dqtrxzone = kmem_zone_init(sizeof(xfs_dquot_acct_t),
- "xfs_dqtrx");
+ xqm->qm_dqtrxzone = kmem_cache_create("xfs_dqtrx",
+ sizeof(xfs_dquot_acct_t),
+ 0, 0, NULL, NULL);
qm_dqtrxzone = xqm->qm_dqtrxzone;
} else
xqm->qm_dqtrxzone = qm_dqtrxzone;
diff --git a/fs/xfs/support/ktrace.c b/fs/xfs/support/ktrace.c
index 841aa4c..33fbe74 100644
--- a/fs/xfs/support/ktrace.c
+++ b/fs/xfs/support/ktrace.c
@@ -26,13 +26,13 @@ ktrace_init(int zentries)
{
ktrace_zentries = zentries;
- ktrace_hdr_zone = kmem_zone_init(sizeof(ktrace_t),
- "ktrace_hdr");
+ ktrace_hdr_zone = kmem_cache_create("ktrace_hdr", sizeof(ktrace_t),
+ 0, 0, NULL, NULL);
ASSERT(ktrace_hdr_zone);
- ktrace_ent_zone = kmem_zone_init(ktrace_zentries
- * sizeof(ktrace_entry_t),
- "ktrace_ent");
+ ktrace_ent_zone = kmem_cache_create("ktrace_ent",
+ ktrace_zentries * sizeof(ktrace_entry_t),
+ 0, 0, NULL, NULL);
ASSERT(ktrace_ent_zone);
}
diff --git a/fs/xfs/xfs_acl.h b/fs/xfs/xfs_acl.h
index f9315bc..af83064 100644
--- a/fs/xfs/xfs_acl.h
+++ b/fs/xfs/xfs_acl.h
@@ -55,7 +55,7 @@ struct xfs_inode;
extern struct kmem_zone *xfs_acl_zone;
#define xfs_acl_zone_init(zone, name) \
- (zone) = kmem_zone_init(sizeof(xfs_acl_t), name)
+ (zone) = kmem_cache_create(name, sizeof(xfs_acl_t), 0, 0, NULL,
NULL)
#define xfs_acl_zone_destroy(zone) kmem_cache_destroy(zone)
extern int xfs_acl_inherit(struct vnode *, struct vattr *, xfs_acl_t *);
diff --git a/fs/xfs/xfs_vfsops.c b/fs/xfs/xfs_vfsops.c
index b6ad370..52f9073 100644
--- a/fs/xfs/xfs_vfsops.c
+++ b/fs/xfs/xfs_vfsops.c
@@ -65,6 +65,9 @@ xfs_init(void)
extern kmem_zone_t *xfs_trans_zone;
extern kmem_zone_t *xfs_buf_item_zone;
extern kmem_zone_t *xfs_dabuf_zone;
+ unsigned long buf_item_zone_size;
+ unsigned long edf_zone_size;
+ unsigned long efi_zone_size;
#ifdef XFS_DABUF_DEBUG
extern lock_t xfs_dabuf_global_lock;
spinlock_init(&xfs_dabuf_global_lock, "xfsda");
@@ -73,36 +76,50 @@ xfs_init(void)
/*
* Initialize all of the zone allocators we use.
*/
- xfs_bmap_free_item_zone = kmem_zone_init(sizeof(xfs_bmap_free_item_t),
- "xfs_bmap_free_item");
- xfs_btree_cur_zone = kmem_zone_init(sizeof(xfs_btree_cur_t),
- "xfs_btree_cur");
- xfs_inode_zone = kmem_zone_init(sizeof(xfs_inode_t), "xfs_inode");
- xfs_trans_zone = kmem_zone_init(sizeof(xfs_trans_t), "xfs_trans");
+ xfs_bmap_free_item_zone =
+ kmem_cache_create("xfs_bmap_free_item",
+ sizeof(xfs_bmap_free_item_t),
+ 0, 0, NULL, NULL);
+ xfs_btree_cur_zone =
+ kmem_cache_create("xfs_btree_cur", sizeof(xfs_btree_cur_t),
+ 0, 0, NULL, NULL);
+ xfs_inode_zone = kmem_cache_create("xfs_inode", sizeof(xfs_inode_t),
+ 0, 0, NULL, NULL);
+ xfs_trans_zone = kmem_cache_create("xfs_trans", sizeof(xfs_trans_t),
+ 0, 0, NULL, NULL);
xfs_da_state_zone =
- kmem_zone_init(sizeof(xfs_da_state_t), "xfs_da_state");
- xfs_dabuf_zone = kmem_zone_init(sizeof(xfs_dabuf_t), "xfs_dabuf");
+ kmem_cache_create("xfs_da_state", sizeof(xfs_da_state_t),
+ 0, 0, NULL, NULL);
+ xfs_dabuf_zone = kmem_cache_create("xfs_dabuf", sizeof(xfs_dabuf_t),
+ 0, 0, NULL, NULL);
/*
* The size of the zone allocated buf log item is the maximum
* size possible under XFS. This wastes a little bit of memory,
* but it is much faster.
*/
+ buf_item_zone_size = (sizeof(xfs_buf_log_item_t) +
+ (((XFS_MAX_BLOCKSIZE / XFS_BLI_CHUNK) /
+ NBWORD) * sizeof(int)));
+ edf_zone_size = (sizeof(xfs_efd_log_item_t) +
+ ((XFS_EFD_MAX_FAST_EXTENTS-1) * sizeof(xfs_extent_t)));
+ efi_zone_size = (sizeof(xfs_efi_log_item_t) +
+ ((XFS_EFI_MAX_FAST_EXTENTS-1) * sizeof(xfs_extent_t)));
+
xfs_buf_item_zone =
- kmem_zone_init((sizeof(xfs_buf_log_item_t) +
- (((XFS_MAX_BLOCKSIZE / XFS_BLI_CHUNK) /
- NBWORD) * sizeof(int))),
- "xfs_buf_item");
- xfs_efd_zone = kmem_zone_init((sizeof(xfs_efd_log_item_t) +
- ((XFS_EFD_MAX_FAST_EXTENTS - 1) *
sizeof(xfs_extent_t))),
- "xfs_efd_item");
- xfs_efi_zone = kmem_zone_init((sizeof(xfs_efi_log_item_t) +
- ((XFS_EFI_MAX_FAST_EXTENTS - 1) *
sizeof(xfs_extent_t))),
- "xfs_efi_item");
- xfs_ifork_zone = kmem_zone_init(sizeof(xfs_ifork_t), "xfs_ifork");
- xfs_ili_zone = kmem_zone_init(sizeof(xfs_inode_log_item_t), "xfs_ili");
- xfs_chashlist_zone = kmem_zone_init(sizeof(xfs_chashlist_t),
- "xfs_chashlist");
+ kmem_cache_create("xfs_buf_item", buf_item_zone_size,
+ 0, 0, NULL, NULL);
+ xfs_efd_zone = kmem_cache_create("xfs_efd_item", edf_zone_size,
+ 0, 0, NULL, NULL);
+ xfs_efi_zone = kmem_cache_create("xfs_efi_item", efi_zone_size,
+ 0, 0, NULL, NULL);
+ xfs_ifork_zone = kmem_cache_create("xfs_ifork", sizeof(xfs_ifork_t),
+ 0, 0, NULL, NULL);
+ xfs_ili_zone = kmem_cache_create("xfs_ili",
sizeof(xfs_inode_log_item_t),
+ 0, 0, NULL, NULL);
+ xfs_chashlist_zone =
+ kmem_cache_create("xfs_chashlist", sizeof(xfs_chashlist_t),
+ 0, 0, NULL, NULL);
xfs_acl_zone_init(xfs_acl_zone, "xfs_acl");
/*
|