libxfs/kmem.c

// SPDX-License-Identifier: GPL-2.0


#include "libxfs_priv.h"

static bool leaked;

void kmem_start_leak_check(void)
{
	leaked = false;
}

bool kmem_found_leaks(void)
{
	return leaked;
}

/*
 * Simple memory interface
 */
struct kmem_cache *
kmem_cache_create(const char *name, unsigned int size, unsigned int align,
		  unsigned int slab_flags, void (*ctor)(void *))
{
	struct kmem_cache	*ptr = malloc(sizeof(struct kmem_cache));

	if (ptr == NULL) {
		fprintf(stderr, _("%s: zone init failed (%s, %d bytes): %s\n"),
			progname, name, (int)sizeof(struct kmem_cache),
			strerror(errno));
		exit(1);
	}
	ptr->zone_unitsize = size;
	ptr->zone_name = name;
	ptr->allocated = 0;
	ptr->align = align;
	ptr->ctor = ctor;

	return ptr;
}

void
kmem_cache_destroy(struct kmem_cache *zone)
{
	if (getenv("LIBXFS_LEAK_CHECK") && zone->allocated) {
		leaked = true;
		fprintf(stderr, "zone %s freed with %d items allocated\n",
				zone->zone_name, zone->allocated);
	}
	free(zone);
}

void *
kmem_cache_alloc(struct kmem_cache *zone, gfp_t flags)
{
	void	*ptr = NULL;

	if (zone->align) {
		int ret;

		ret = posix_memalign(&ptr, zone->align, zone->zone_unitsize);
		if (ret)
			errno = ret;
	} else {
		ptr = malloc(zone->zone_unitsize);
	}

	if (ptr == NULL) {
		fprintf(stderr, _("%s: zone alloc failed (%s, %d bytes): %s\n"),
			progname, zone->zone_name, zone->zone_unitsize,
			strerror(errno));
		exit(1);
	}

	if (zone->ctor)
		zone->ctor(ptr);
	zone->allocated++;
	return ptr;
}

void *
kmem_cache_zalloc(struct kmem_cache *zone, gfp_t flags)
{
	void	*ptr = kmem_cache_alloc(zone, flags);

	memset(ptr, 0, zone->zone_unitsize);
	return ptr;
}

void *
kmem_alloc(size_t size, int flags)
{
	void	*ptr = malloc(size);

	if (ptr == NULL) {
		fprintf(stderr, _("%s: malloc failed (%d bytes): %s\n"),
			progname, (int)size, strerror(errno));
		exit(1);
	}
	return ptr;
}

void *
kvmalloc(size_t size, gfp_t flags)
{
	if (flags & __GFP_ZERO)
		return kmem_zalloc(size, 0);
	return kmem_alloc(size, 0);
}

void *
kmem_zalloc(size_t size, int flags)
{
	void	*ptr = kmem_alloc(size, flags);

	memset(ptr, 0, size);
	return ptr;
}

void *
krealloc(void *ptr, size_t new_size, int flags)
{
	ptr = realloc(ptr, new_size);
	if (ptr == NULL) {
		fprintf(stderr, _("%s: realloc failed (%d bytes): %s\n"),
			progname, (int)new_size, strerror(errno));
		exit(1);
	}
	return ptr;
}