}
return pg;
}
+#define cfs_alloc_pages(mask, order) alloc_pages((mask), (order))
-#define alloc_page(mask) alloc_pages((mask), 0)
+#define alloc_page(mask) alloc_pages((mask), 0)
+#define cfs_alloc_page(mask) alloc_page(mask)
static inline void __free_pages(cfs_page_t *pg, int what)
{
#endif
free(pg);
}
+#define __cfs_free_pages(pg, order) __free_pages((pg), (order))
#define __free_page(page) __free_pages((page), 0)
#define free_page(page) __free_page(page)
+#define __cfs_free_page(page) __cfs_free_pages((page), 0)
static inline cfs_page_t* __grab_cache_page(unsigned long index)
{
int rc;
ENTRY;
- page = alloc_page(0);
+ page = cfs_alloc_page(0);
if (!page) {
CERROR("alloc page failed\n");
RETURN(ERR_PTR(-ENOMEM));
{
struct ll_file_data *fd;
- OBD_SLAB_ALLOC(fd, ll_file_data_slab, GFP_KERNEL, sizeof *fd);
+ OBD_SLAB_ALLOC_PTR(fd, ll_file_data_slab);
return fd;
}
static void ll_file_data_put(struct ll_file_data *fd)
{
if (fd != NULL)
- OBD_SLAB_FREE(fd, ll_file_data_slab, sizeof *fd);
+ OBD_SLAB_FREE_PTR(fd, ll_file_data_slab);
}
void ll_pack_inode2opdata(struct inode *inode, struct md_op_data *op_data,
LPROCFS_ENTRY_AND_CHECK(dp);
- OBD_ALLOC_GFP(dummy_llap, sizeof(*dummy_llap), GFP_KERNEL);
+ OBD_ALLOC_PTR_WAIT(dummy_llap);
if (dummy_llap == NULL)
GOTO(out, rc);
dummy_llap->llap_page = NULL;
if (sbi->ll_async_page_count >= sbi->ll_async_page_max)
llap_shrink_cache(sbi, 0);
- OBD_SLAB_ALLOC(llap, ll_async_page_slab, GFP_KERNEL,
+ OBD_SLAB_ALLOC(llap, ll_async_page_slab, CFS_ALLOC_STD,
ll_async_page_slab_size);
if (llap == NULL)
RETURN(ERR_PTR(-ENOMEM));
page_count = (user_addr + size + CFS_PAGE_SIZE - 1) >> CFS_PAGE_SHIFT;
page_count -= user_addr >> CFS_PAGE_SHIFT;
- OBD_ALLOC_GFP(*pages, page_count * sizeof(**pages), GFP_KERNEL);
+ OBD_ALLOC_WAIT(*pages, page_count * sizeof(**pages));
if (*pages) {
down_read(¤t->mm->mmap_sem);
result = get_user_pages(current, current->mm, user_addr,
{
struct ll_inode_info *lli;
ll_stats_ops_tally(ll_s2sbi(sb), LPROC_LL_ALLOC_INODE, 1);
- OBD_SLAB_ALLOC(lli, ll_inode_cachep, GFP_KERNEL, sizeof *lli);
+ OBD_SLAB_ALLOC_PTR(lli, ll_inode_cachep);
if (lli == NULL)
return NULL;
static void ll_destroy_inode(struct inode *inode)
{
struct ll_inode_info *ptr = ll_i2info(inode);
- OBD_SLAB_FREE(ptr, ll_inode_cachep, sizeof(*ptr));
+ OBD_SLAB_FREE_PTR(ptr, ll_inode_cachep);
}
int ll_init_inodecache(void)
return NULL;;
for (i = 0; i < stripe_count; i++) {
- OBD_SLAB_ALLOC(loi, lov_oinfo_slab, GFP_NOFS, sizeof(*loi));
+ OBD_SLAB_ALLOC(loi, lov_oinfo_slab, CFS_ALLOC_IO, sizeof(*loi));
if (loi == NULL)
goto err;
lsm->lsm_oinfo[i] = loi;
{
struct fsfilt_cb_data *fcb;
- OBD_SLAB_ALLOC(fcb, fcb_cache, GFP_NOFS, sizeof *fcb);
+ OBD_SLAB_ALLOC(fcb, fcb_cache, CFS_ALLOC_IO, sizeof *fcb);
if (fcb == NULL)
RETURN(-ENOMEM);
for (i = 0, tmpcount = count; i < npages; i++, tmpcount -= tmpsize) {
tmpsize = tmpcount > CFS_PAGE_SIZE ? CFS_PAGE_SIZE : tmpcount;
- pages[i] = alloc_pages(GFP_KERNEL, 0);
+ pages[i] = cfs_alloc_page(CFS_ALLOC_STD);
if (pages[i] == NULL)
GOTO(cleanup_buf, rc = -ENOMEM);
cleanup_buf:
for (i = 0; i < npages; i++)
if (pages[i])
- __free_pages(pages[i], 0);
+ __cfs_free_page(pages[i]);
ptlrpc_free_bulk(desc);
out_free:
{
struct obd_device *obd;
- OBD_SLAB_ALLOC(obd, obd_device_cachep, GFP_KERNEL, sizeof(*obd));
+ OBD_SLAB_ALLOC_PTR(obd, obd_device_cachep);
if (obd != NULL) {
obd->obd_magic = OBD_DEVICE_MAGIC;
}
LASSERT(obd != NULL);
LASSERTF(obd->obd_magic == OBD_DEVICE_MAGIC, "obd %p obd_magic %08x != %08x\n",
obd, obd->obd_magic, OBD_DEVICE_MAGIC);
- OBD_SLAB_FREE(obd, obd_device_cachep, sizeof(*obd));
+ OBD_SLAB_FREE_PTR(obd, obd_device_cachep);
}
EXPORT_SYMBOL(obd_device_free);
struct filter_export_data *fed = &exp->exp_filter_data;
struct filter_mod_data *found = NULL, *fmd_new = NULL;
- OBD_SLAB_ALLOC(fmd_new, ll_fmd_cachep, GFP_NOFS, sizeof(*fmd_new));
+ OBD_SLAB_ALLOC(fmd_new, ll_fmd_cachep, CFS_ALLOC_IO, sizeof(*fmd_new));
spin_lock(&fed->fed_lock);
found = filter_fmd_find_nolock(&exp->exp_obd->u.filter,fed,objid,group);
if (tls != NULL) {
for (i = 0; i < OST_THREAD_POOL_SIZE; ++ i) {
if (tls->page[i] != NULL)
- __free_page(tls->page[i]);
+ __cfs_free_page(tls->page[i]);
}
OBD_FREE_PTR(tls);
thread->t_data = NULL;
* populate pool
*/
for (i = 0; i < OST_THREAD_POOL_SIZE; ++ i) {
- tls->page[i] = alloc_page(OST_THREAD_POOL_GFP);
+ tls->page[i] = cfs_alloc_page(OST_THREAD_POOL_GFP);
if (tls->page[i] == NULL) {
ost_thread_done(thread);
result = -ENOMEM;
* tunables for per-thread page pool (bug 5137)
*/
#define OST_THREAD_POOL_SIZE PTLRPC_MAX_BRW_PAGES /* pool size in pages */
-#define OST_THREAD_POOL_GFP GFP_HIGHUSER /* GFP mask for pool pages */
+#define OST_THREAD_POOL_GFP CFS_ALLOC_HIGHUSER /* GFP mask for pool pages */
struct page;
struct niobuf_local;
struct lustre_qunit *qunit = NULL;
ENTRY;
- OBD_SLAB_ALLOC(qunit, qunit_cachep, GFP_NOFS, sizeof(*qunit));
+ OBD_SLAB_ALLOC(qunit, qunit_cachep, CFS_ALLOC_IO, sizeof(*qunit));
if (qunit == NULL)
RETURN(NULL);
struct lustre_dquot *dquot = NULL;
ENTRY;
- OBD_SLAB_ALLOC(dquot, lustre_dquot_cachep, GFP_NOFS, sizeof(*dquot));
+ OBD_SLAB_ALLOC(dquot, lustre_dquot_cachep, CFS_ALLOC_IO, sizeof(*dquot));
if (dquot == NULL)
RETURN(NULL);