[mirror_ubuntu-bionic-kernel.git] / fs / orangefs / orangefs-cache.c

/*
 * (C) 2001 Clemson University and The University of Chicago
 *
 * See COPYING in top-level directory.
 */

#include "protocol.h"
#include "orangefs-kernel.h"

/* tags assigned to kernel upcall operations */
static __u64 next_tag_value;
static DEFINE_SPINLOCK(next_tag_value_lock);

/* the orangefs memory caches */

/* a cache for orangefs upcall/downcall operations */
static struct kmem_cache *op_cache;

/* a cache for device (/dev/pvfs2-req) communication */
static struct kmem_cache *dev_req_cache;

/* a cache for orangefs_kiocb objects (i.e orangefs iocb structures ) */
static struct kmem_cache *orangefs_kiocb_cache;

int op_cache_initialize(void)
{
	op_cache = kmem_cache_create("orangefs_op_cache",
				     sizeof(struct orangefs_kernel_op_s),
				     0,
				     ORANGEFS_CACHE_CREATE_FLAGS,
				     NULL);

	if (!op_cache) {
		gossip_err("Cannot create orangefs_op_cache\n");
		return -ENOMEM;
	}

	/* initialize our atomic tag counter */
	spin_lock(&next_tag_value_lock);
	next_tag_value = 100;
	spin_unlock(&next_tag_value_lock);
	return 0;
}

int op_cache_finalize(void)
{
	kmem_cache_destroy(op_cache);
	return 0;
}

char *get_opname_string(struct orangefs_kernel_op_s *new_op)
{
	if (new_op) {
		__s32 type = new_op->upcall.type;

		if (type == ORANGEFS_VFS_OP_FILE_IO)
			return "OP_FILE_IO";
		else if (type == ORANGEFS_VFS_OP_LOOKUP)
			return "OP_LOOKUP";
		else if (type == ORANGEFS_VFS_OP_CREATE)
			return "OP_CREATE";
		else if (type == ORANGEFS_VFS_OP_GETATTR)
			return "OP_GETATTR";
		else if (type == ORANGEFS_VFS_OP_REMOVE)
			return "OP_REMOVE";
		else if (type == ORANGEFS_VFS_OP_MKDIR)
			return "OP_MKDIR";
		else if (type == ORANGEFS_VFS_OP_READDIR)
			return "OP_READDIR";
		else if (type == ORANGEFS_VFS_OP_READDIRPLUS)
			return "OP_READDIRPLUS";
		else if (type == ORANGEFS_VFS_OP_SETATTR)
			return "OP_SETATTR";
		else if (type == ORANGEFS_VFS_OP_SYMLINK)
			return "OP_SYMLINK";
		else if (type == ORANGEFS_VFS_OP_RENAME)
			return "OP_RENAME";
		else if (type == ORANGEFS_VFS_OP_STATFS)
			return "OP_STATFS";
		else if (type == ORANGEFS_VFS_OP_TRUNCATE)
			return "OP_TRUNCATE";
		else if (type == ORANGEFS_VFS_OP_MMAP_RA_FLUSH)
			return "OP_MMAP_RA_FLUSH";
		else if (type == ORANGEFS_VFS_OP_FS_MOUNT)
			return "OP_FS_MOUNT";
		else if (type == ORANGEFS_VFS_OP_FS_UMOUNT)
			return "OP_FS_UMOUNT";
		else if (type == ORANGEFS_VFS_OP_GETXATTR)
			return "OP_GETXATTR";
		else if (type == ORANGEFS_VFS_OP_SETXATTR)
			return "OP_SETXATTR";
		else if (type == ORANGEFS_VFS_OP_LISTXATTR)
			return "OP_LISTXATTR";
		else if (type == ORANGEFS_VFS_OP_REMOVEXATTR)
			return "OP_REMOVEXATTR";
		else if (type == ORANGEFS_VFS_OP_PARAM)
			return "OP_PARAM";
		else if (type == ORANGEFS_VFS_OP_PERF_COUNT)
			return "OP_PERF_COUNT";
		else if (type == ORANGEFS_VFS_OP_CANCEL)
			return "OP_CANCEL";
		else if (type == ORANGEFS_VFS_OP_FSYNC)
			return "OP_FSYNC";
		else if (type == ORANGEFS_VFS_OP_FSKEY)
			return "OP_FSKEY";
	}
	return "OP_UNKNOWN?";
}

struct orangefs_kernel_op_s *op_alloc(__s32 type)
{
	struct orangefs_kernel_op_s *new_op = NULL;

	new_op = kmem_cache_zalloc(op_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
	if (new_op) {
		INIT_LIST_HEAD(&new_op->list);
		spin_lock_init(&new_op->lock);
		init_waitqueue_head(&new_op->waitq);

		atomic_set(&new_op->ref_count, 1);

		init_completion(&new_op->done);

		new_op->upcall.type = ORANGEFS_VFS_OP_INVALID;
		new_op->downcall.type = ORANGEFS_VFS_OP_INVALID;
		new_op->downcall.status = -1;

		new_op->op_state = OP_VFS_STATE_UNKNOWN;
		new_op->tag = 0;

		/* initialize the op specific tag and upcall credentials */
		spin_lock(&next_tag_value_lock);
		new_op->tag = next_tag_value++;
		if (next_tag_value == 0)
			next_tag_value = 100;
		spin_unlock(&next_tag_value_lock);
		new_op->upcall.type = type;
		new_op->attempts = 0;
		gossip_debug(GOSSIP_CACHE_DEBUG,
			     "Alloced OP (%p: %llu %s)\n",
			     new_op,
			     llu(new_op->tag),
			     get_opname_string(new_op));

		new_op->upcall.uid = from_kuid(current_user_ns(),
					       current_fsuid());

		new_op->upcall.gid = from_kgid(current_user_ns(),
					       current_fsgid());
	} else {
		gossip_err("op_alloc: kmem_cache_alloc failed!\n");
	}
	return new_op;
}

void __op_release(struct orangefs_kernel_op_s *orangefs_op)
{
	if (orangefs_op) {
		gossip_debug(GOSSIP_CACHE_DEBUG,
			     "Releasing OP (%p: %llu)\n",
			     orangefs_op,
			     llu(orangefs_op->tag));
		kmem_cache_free(op_cache, orangefs_op);
	} else {
		gossip_err("NULL pointer in op_release\n");
	}
}

int dev_req_cache_initialize(void)
{
	dev_req_cache = kmem_cache_create("orangefs_devreqcache",
					  MAX_DEV_REQ_DOWNSIZE,
					  0,
					  ORANGEFS_CACHE_CREATE_FLAGS,
					  NULL);

	if (!dev_req_cache) {
		gossip_err("Cannot create orangefs_dev_req_cache\n");
		return -ENOMEM;
	}
	return 0;
}

int dev_req_cache_finalize(void)
{
	kmem_cache_destroy(dev_req_cache);
	return 0;
}

void *dev_req_alloc(void)
{
	void *buffer;

	buffer = kmem_cache_alloc(dev_req_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
	if (buffer == NULL)
		gossip_err("Failed to allocate from dev_req_cache\n");
	else
		memset(buffer, 0, sizeof(MAX_DEV_REQ_DOWNSIZE));
	return buffer;
}

void dev_req_release(void *buffer)
{
	if (buffer)
		kmem_cache_free(dev_req_cache, buffer);
	else
		gossip_err("NULL pointer passed to dev_req_release\n");
}

int kiocb_cache_initialize(void)
{
	orangefs_kiocb_cache = kmem_cache_create("orangefs_kiocbcache",
					      sizeof(struct orangefs_kiocb_s),
					      0,
					      ORANGEFS_CACHE_CREATE_FLAGS,
					      NULL);

	if (!orangefs_kiocb_cache) {
		gossip_err("Cannot create orangefs_kiocb_cache!\n");
		return -ENOMEM;
	}
	return 0;
}

int kiocb_cache_finalize(void)
{
	kmem_cache_destroy(orangefs_kiocb_cache);
	return 0;
}

struct orangefs_kiocb_s *kiocb_alloc(void)
{
	struct orangefs_kiocb_s *x = NULL;

	x = kmem_cache_alloc(orangefs_kiocb_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
	if (x == NULL)
		gossip_err("kiocb_alloc: kmem_cache_alloc failed!\n");
	else
		memset(x, 0, sizeof(struct orangefs_kiocb_s));
	return x;
}

void kiocb_release(struct orangefs_kiocb_s *x)
{
	if (x)
		kmem_cache_free(orangefs_kiocb_cache, x);
	else
		gossip_err("kiocb_release: kmem_cache_free NULL pointer!\n");
}
Commit	Line	Data
274dcf55 MM	1	/*
	2	* (C) 2001 Clemson University and The University of Chicago
	3	*
	4	* See COPYING in top-level directory.
	5	*/
	6
	7	#include "protocol.h"
575e9461	8	#include "orangefs-kernel.h"
274dcf55 MM	9
	10	/* tags assigned to kernel upcall operations */
	11	static __u64 next_tag_value;
	12	static DEFINE_SPINLOCK(next_tag_value_lock);
	13
8bb8aefd	14	/* the orangefs memory caches */
274dcf55	15
8bb8aefd	16	/* a cache for orangefs upcall/downcall operations */
274dcf55 MM	17	static struct kmem_cache *op_cache;
	18
	19	/* a cache for device (/dev/pvfs2-req) communication */
	20	static struct kmem_cache *dev_req_cache;
	21
8bb8aefd YL	22	/* a cache for orangefs_kiocb objects (i.e orangefs iocb structures ) */
8bb8aefd YL	23	static struct kmem_cache *orangefs_kiocb_cache;
274dcf55 MM	24
	25	int op_cache_initialize(void)
	26	{
8bb8aefd YL	27	op_cache = kmem_cache_create("orangefs_op_cache",
8bb8aefd YL	28	sizeof(struct orangefs_kernel_op_s),
274dcf55	29	0,
8bb8aefd	30	ORANGEFS_CACHE_CREATE_FLAGS,
274dcf55 MM	31	NULL);
	32
	33	if (!op_cache) {
8bb8aefd	34	gossip_err("Cannot create orangefs_op_cache\n");
274dcf55 MM	35	return -ENOMEM;
	36	}
	37
	38	/* initialize our atomic tag counter */
	39	spin_lock(&next_tag_value_lock);
	40	next_tag_value = 100;
	41	spin_unlock(&next_tag_value_lock);
	42	return 0;
	43	}
	44
	45	int op_cache_finalize(void)
	46	{
	47	kmem_cache_destroy(op_cache);
	48	return 0;
	49	}
	50
8bb8aefd	51	char get_opname_string(struct orangefs_kernel_op_s new_op)
274dcf55 MM	52	{
	53	if (new_op) {
	54	__s32 type = new_op->upcall.type;
	55
8bb8aefd	56	if (type == ORANGEFS_VFS_OP_FILE_IO)
274dcf55	57	return "OP_FILE_IO";
8bb8aefd	58	else if (type == ORANGEFS_VFS_OP_LOOKUP)
274dcf55	59	return "OP_LOOKUP";
8bb8aefd	60	else if (type == ORANGEFS_VFS_OP_CREATE)
274dcf55	61	return "OP_CREATE";
8bb8aefd	62	else if (type == ORANGEFS_VFS_OP_GETATTR)
274dcf55	63	return "OP_GETATTR";
8bb8aefd	64	else if (type == ORANGEFS_VFS_OP_REMOVE)
274dcf55	65	return "OP_REMOVE";
8bb8aefd	66	else if (type == ORANGEFS_VFS_OP_MKDIR)
274dcf55	67	return "OP_MKDIR";
8bb8aefd	68	else if (type == ORANGEFS_VFS_OP_READDIR)
274dcf55	69	return "OP_READDIR";
8bb8aefd	70	else if (type == ORANGEFS_VFS_OP_READDIRPLUS)
274dcf55	71	return "OP_READDIRPLUS";
8bb8aefd	72	else if (type == ORANGEFS_VFS_OP_SETATTR)
274dcf55	73	return "OP_SETATTR";
8bb8aefd	74	else if (type == ORANGEFS_VFS_OP_SYMLINK)
274dcf55	75	return "OP_SYMLINK";
8bb8aefd	76	else if (type == ORANGEFS_VFS_OP_RENAME)
274dcf55	77	return "OP_RENAME";
8bb8aefd	78	else if (type == ORANGEFS_VFS_OP_STATFS)
274dcf55	79	return "OP_STATFS";
8bb8aefd	80	else if (type == ORANGEFS_VFS_OP_TRUNCATE)
274dcf55	81	return "OP_TRUNCATE";
8bb8aefd	82	else if (type == ORANGEFS_VFS_OP_MMAP_RA_FLUSH)
274dcf55	83	return "OP_MMAP_RA_FLUSH";
8bb8aefd	84	else if (type == ORANGEFS_VFS_OP_FS_MOUNT)
274dcf55	85	return "OP_FS_MOUNT";
8bb8aefd	86	else if (type == ORANGEFS_VFS_OP_FS_UMOUNT)
274dcf55	87	return "OP_FS_UMOUNT";
8bb8aefd	88	else if (type == ORANGEFS_VFS_OP_GETXATTR)
274dcf55	89	return "OP_GETXATTR";
8bb8aefd	90	else if (type == ORANGEFS_VFS_OP_SETXATTR)
274dcf55	91	return "OP_SETXATTR";
8bb8aefd	92	else if (type == ORANGEFS_VFS_OP_LISTXATTR)
274dcf55	93	return "OP_LISTXATTR";
8bb8aefd	94	else if (type == ORANGEFS_VFS_OP_REMOVEXATTR)
274dcf55	95	return "OP_REMOVEXATTR";
8bb8aefd	96	else if (type == ORANGEFS_VFS_OP_PARAM)
274dcf55	97	return "OP_PARAM";
8bb8aefd	98	else if (type == ORANGEFS_VFS_OP_PERF_COUNT)
274dcf55	99	return "OP_PERF_COUNT";
8bb8aefd	100	else if (type == ORANGEFS_VFS_OP_CANCEL)
274dcf55	101	return "OP_CANCEL";
8bb8aefd	102	else if (type == ORANGEFS_VFS_OP_FSYNC)
274dcf55	103	return "OP_FSYNC";
8bb8aefd	104	else if (type == ORANGEFS_VFS_OP_FSKEY)
274dcf55	105	return "OP_FSKEY";
274dcf55 MM	106	}
	107	return "OP_UNKNOWN?";
	108	}
	109
8bb8aefd	110	struct orangefs_kernel_op_s *op_alloc(__s32 type)
274dcf55	111	{
8bb8aefd	112	struct orangefs_kernel_op_s *new_op = NULL;
274dcf55	113
115b93a8	114	new_op = kmem_cache_zalloc(op_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
274dcf55	115	if (new_op) {
274dcf55 MM	116	INIT_LIST_HEAD(&new_op->list);
	117	spin_lock_init(&new_op->lock);
	118	init_waitqueue_head(&new_op->waitq);
	119
ed42fe05	120	atomic_set(&new_op->ref_count, 1);
274dcf55	121
115b93a8 AV	122	init_completion(&new_op->done);
	123
	124	new_op->upcall.type = ORANGEFS_VFS_OP_INVALID;
	125	new_op->downcall.type = ORANGEFS_VFS_OP_INVALID;
	126	new_op->downcall.status = -1;
	127
	128	new_op->op_state = OP_VFS_STATE_UNKNOWN;
	129	new_op->tag = 0;
274dcf55 MM	130
	131	/* initialize the op specific tag and upcall credentials */
	132	spin_lock(&next_tag_value_lock);
	133	new_op->tag = next_tag_value++;
	134	if (next_tag_value == 0)
	135	next_tag_value = 100;
	136	spin_unlock(&next_tag_value_lock);
	137	new_op->upcall.type = type;
	138	new_op->attempts = 0;
	139	gossip_debug(GOSSIP_CACHE_DEBUG,
	140	"Alloced OP (%p: %llu %s)\n",
	141	new_op,
	142	llu(new_op->tag),
	143	get_opname_string(new_op));
	144
	145	new_op->upcall.uid = from_kuid(current_user_ns(),
	146	current_fsuid());
	147
	148	new_op->upcall.gid = from_kgid(current_user_ns(),
	149	current_fsgid());
274dcf55 MM	150	} else {
	151	gossip_err("op_alloc: kmem_cache_alloc failed!\n");
	152	}
	153	return new_op;
	154	}
	155
ed42fe05	156	void __op_release(struct orangefs_kernel_op_s *orangefs_op)
274dcf55	157	{
8bb8aefd	158	if (orangefs_op) {
274dcf55 MM	159	gossip_debug(GOSSIP_CACHE_DEBUG,
274dcf55 MM	160	"Releasing OP (%p: %llu)\n",
8bb8aefd YL	161	orangefs_op,
8bb8aefd YL	162	llu(orangefs_op->tag));
8bb8aefd	163	kmem_cache_free(op_cache, orangefs_op);
274dcf55 MM	164	} else {
	165	gossip_err("NULL pointer in op_release\n");
	166	}
	167	}
	168
	169	int dev_req_cache_initialize(void)
	170	{
8bb8aefd	171	dev_req_cache = kmem_cache_create("orangefs_devreqcache",
a762ae6d	172	MAX_DEV_REQ_DOWNSIZE,
274dcf55	173	0,
8bb8aefd	174	ORANGEFS_CACHE_CREATE_FLAGS,
274dcf55 MM	175	NULL);
	176
	177	if (!dev_req_cache) {
8bb8aefd	178	gossip_err("Cannot create orangefs_dev_req_cache\n");
274dcf55 MM	179	return -ENOMEM;
	180	}
	181	return 0;
	182	}
	183
	184	int dev_req_cache_finalize(void)
	185	{
	186	kmem_cache_destroy(dev_req_cache);
	187	return 0;
	188	}
	189
	190	void *dev_req_alloc(void)
	191	{
	192	void *buffer;
	193
8bb8aefd	194	buffer = kmem_cache_alloc(dev_req_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
274dcf55 MM	195	if (buffer == NULL)
	196	gossip_err("Failed to allocate from dev_req_cache\n");
	197	else
a762ae6d	198	memset(buffer, 0, sizeof(MAX_DEV_REQ_DOWNSIZE));
274dcf55 MM	199	return buffer;
	200	}
	201
	202	void dev_req_release(void *buffer)
	203	{
	204	if (buffer)
	205	kmem_cache_free(dev_req_cache, buffer);
	206	else
	207	gossip_err("NULL pointer passed to dev_req_release\n");
	208	}
	209
	210	int kiocb_cache_initialize(void)
	211	{
8bb8aefd YL	212	orangefs_kiocb_cache = kmem_cache_create("orangefs_kiocbcache",
8bb8aefd YL	213	sizeof(struct orangefs_kiocb_s),
274dcf55	214	0,
8bb8aefd	215	ORANGEFS_CACHE_CREATE_FLAGS,
274dcf55 MM	216	NULL);
274dcf55 MM	217
8bb8aefd YL	218	if (!orangefs_kiocb_cache) {
8bb8aefd YL	219	gossip_err("Cannot create orangefs_kiocb_cache!\n");
274dcf55 MM	220	return -ENOMEM;
	221	}
	222	return 0;
	223	}
	224
	225	int kiocb_cache_finalize(void)
	226	{
8bb8aefd	227	kmem_cache_destroy(orangefs_kiocb_cache);
274dcf55 MM	228	return 0;
	229	}
	230
8bb8aefd	231	struct orangefs_kiocb_s *kiocb_alloc(void)
274dcf55	232	{
8bb8aefd	233	struct orangefs_kiocb_s *x = NULL;
274dcf55	234
8bb8aefd	235	x = kmem_cache_alloc(orangefs_kiocb_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
274dcf55 MM	236	if (x == NULL)
	237	gossip_err("kiocb_alloc: kmem_cache_alloc failed!\n");
	238	else
8bb8aefd	239	memset(x, 0, sizeof(struct orangefs_kiocb_s));
274dcf55 MM	240	return x;
	241	}
	242
8bb8aefd	243	void kiocb_release(struct orangefs_kiocb_s *x)
274dcf55 MM	244	{
274dcf55 MM	245	if (x)
8bb8aefd	246	kmem_cache_free(orangefs_kiocb_cache, x);
274dcf55 MM	247	else
	248	gossip_err("kiocb_release: kmem_cache_free NULL pointer!\n");
	249	}