Commit f078d4ea authored by Dave Chinner's avatar Dave Chinner Committed by Chandan Babu R
Browse files

xfs: convert kmem_alloc() to kmalloc() 



kmem_alloc() is just a thin wrapper around kmalloc() these days.
Convert everything to use kmalloc() so we can get rid of the
wrapper.

Note: the transaction region allocation in xlog_add_to_transaction()
can be a high order allocation. Converting it to use
kmalloc(__GFP_NOFAIL) results in warnings in the page allocation
code being triggered because the mm subsystem does not want us to
use __GFP_NOFAIL with high order allocations like we've been doing
with the kmem_alloc() wrapper for a couple of decades. Hence this
specific case gets converted to xlog_kvmalloc() rather than
kmalloc() to avoid this issue.

Signed-off-by: default avatarDave Chinner <dchinner@redhat.com>
Reviewed-by: default avatar"Darrick J. Wong" <djwong@kernel.org>
Signed-off-by: default avatarChandan Babu R <chandanbabu@kernel.org>
parent 10634530

fs/xfs/Makefile

+1 −2
Original line number Diff line number Diff line
@@ -92,8 +92,7 @@ xfs-y += xfs_aops.o \ 
				   xfs_symlink.o \

				   xfs_sysfs.o \

				   xfs_trans.o \

				   xfs_xattr.o \

				   kmem.o

				   xfs_xattr.o



# low-level transaction/log code

xfs-y				+= xfs_log.o \

fs/xfs/kmem.c

deleted100644 → 0
+0 −30
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * Copyright (c) 2000-2005 Silicon Graphics, Inc.

 * All Rights Reserved.

 */

#include "xfs.h"

#include "xfs_message.h"

#include "xfs_trace.h"



void *

kmem_alloc(size_t size, xfs_km_flags_t flags)

{

	int	retries = 0;

	gfp_t	lflags = kmem_flags_convert(flags);

	void	*ptr;



	trace_kmem_alloc(size, flags, _RET_IP_);



	do {

		ptr = kmalloc(size, lflags);

		if (ptr || (flags & KM_MAYFAIL))

			return ptr;

		if (!(++retries % 100))

			xfs_err(NULL,

	"%s(%u) possible memory allocation deadlock size %u in %s (mode:0x%x)",

				current->comm, current->pid,

				(unsigned int)size, __func__, lflags);

		memalloc_retry_wait(lflags);

	} while (1);

}

fs/xfs/kmem.h

+0 −42
Original line number Diff line number Diff line
@@ -15,48 +15,6 @@ 
 * General memory allocation interfaces

 */



typedef unsigned __bitwise xfs_km_flags_t;

#define KM_NOFS		((__force xfs_km_flags_t)0x0004u)

#define KM_MAYFAIL	((__force xfs_km_flags_t)0x0008u)

#define KM_ZERO		((__force xfs_km_flags_t)0x0010u)

#define KM_NOLOCKDEP	((__force xfs_km_flags_t)0x0020u)



/*

 * We use a special process flag to avoid recursive callbacks into

 * the filesystem during transactions.  We will also issue our own

 * warnings, so we explicitly skip any generic ones (silly of us).

 */

static inline gfp_t

kmem_flags_convert(xfs_km_flags_t flags)

{

	gfp_t	lflags;



	BUG_ON(flags & ~(KM_NOFS | KM_MAYFAIL | KM_ZERO | KM_NOLOCKDEP));



	lflags = GFP_KERNEL | __GFP_NOWARN;

	if (flags & KM_NOFS)

		lflags &= ~__GFP_FS;



	/*

	 * Default page/slab allocator behavior is to retry for ever

	 * for small allocations. We can override this behavior by using

	 * __GFP_RETRY_MAYFAIL which will tell the allocator to retry as long

	 * as it is feasible but rather fail than retry forever for all

	 * request sizes.

	 */

	if (flags & KM_MAYFAIL)

		lflags |= __GFP_RETRY_MAYFAIL;



	if (flags & KM_ZERO)

		lflags |= __GFP_ZERO;



	if (flags & KM_NOLOCKDEP)

		lflags |= __GFP_NOLOCKDEP;



	return lflags;

}



extern void *kmem_alloc(size_t, xfs_km_flags_t);

static inline void  kmem_free(const void *ptr)

{

	kvfree(ptr);

fs/xfs/libxfs/xfs_attr_leaf.c

+3 −4
Original line number Diff line number Diff line
@@ -879,8 +879,7 @@ xfs_attr_shortform_to_leaf( 


	trace_xfs_attr_sf_to_leaf(args);



	tmpbuffer = kmem_alloc(size, 0);

	ASSERT(tmpbuffer != NULL);

	tmpbuffer = kmalloc(size, GFP_KERNEL | __GFP_NOFAIL);

	memcpy(tmpbuffer, ifp->if_data, size);

	sf = (struct xfs_attr_sf_hdr *)tmpbuffer;
@@ -1059,7 +1058,7 @@ xfs_attr3_leaf_to_shortform( 


	trace_xfs_attr_leaf_to_sf(args);



	tmpbuffer = kmem_alloc(args->geo->blksize, 0);

	tmpbuffer = kmalloc(args->geo->blksize, GFP_KERNEL | __GFP_NOFAIL);

	if (!tmpbuffer)

		return -ENOMEM;
@@ -1533,7 +1532,7 @@ xfs_attr3_leaf_compact( 


	trace_xfs_attr_leaf_compact(args);



	tmpbuffer = kmem_alloc(args->geo->blksize, 0);

	tmpbuffer = kmalloc(args->geo->blksize, GFP_KERNEL | __GFP_NOFAIL);

	memcpy(tmpbuffer, bp->b_addr, args->geo->blksize);

	memset(bp->b_addr, 0, args->geo->blksize);

	leaf_src = (xfs_attr_leafblock_t *)tmpbuffer;

fs/xfs/libxfs/xfs_btree_staging.c

+2 −2
Original line number Diff line number Diff line
@@ -139,7 +139,7 @@ xfs_btree_stage_afakeroot( 
	ASSERT(!(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE));

	ASSERT(cur->bc_tp == NULL);



	nops = kmem_alloc(sizeof(struct xfs_btree_ops), KM_NOFS);

	nops = kmalloc(sizeof(struct xfs_btree_ops), GFP_NOFS | __GFP_NOFAIL);

	memcpy(nops, cur->bc_ops, sizeof(struct xfs_btree_ops));

	nops->alloc_block = xfs_btree_fakeroot_alloc_block;

	nops->free_block = xfs_btree_fakeroot_free_block;
@@ -220,7 +220,7 @@ xfs_btree_stage_ifakeroot( 
	ASSERT(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE);

	ASSERT(cur->bc_tp == NULL);



	nops = kmem_alloc(sizeof(struct xfs_btree_ops), KM_NOFS);

	nops = kmalloc(sizeof(struct xfs_btree_ops), GFP_NOFS | __GFP_NOFAIL);

	memcpy(nops, cur->bc_ops, sizeof(struct xfs_btree_ops));

	nops->alloc_block = xfs_btree_fakeroot_alloc_block;

	nops->free_block = xfs_btree_fakeroot_free_block;