Quelle  zpool.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * zpool memory storage api
 *
 * Copyright (C) 2014 Dan Streetman
 *
 * This is a common frontend for memory storage pool implementations.
 * Typically, this is used to store compressed memory.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/list.h>
#include <linux/types.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/module.h>
#include <linux/zpool.h>

struct zpool {
 struct zpool_driver *driver;
 void *pool;
};

static LIST_HEAD(drivers_head);
static DEFINE_SPINLOCK(drivers_lock);

/**
 * zpool_register_driver() - register a zpool implementation.
 * @driver: driver to register
 */
void zpool_register_driver(struct zpool_driver *driver)
{
 spin_lock(&drivers_lock);
 atomic_set(&driver->refcount, 0);
 list_add(&driver->list, &drivers_head);
 spin_unlock(&drivers_lock);
}
EXPORT_SYMBOL(zpool_register_driver);

/**
 * zpool_unregister_driver() - unregister a zpool implementation.
 * @driver: driver to unregister.
 *
 * Module usage counting is used to prevent using a driver
 * while/after unloading, so if this is called from module
 * exit function, this should never fail; if called from
 * other than the module exit function, and this returns
 * failure, the driver is in use and must remain available.
 */
int zpool_unregister_driver(struct zpool_driver *driver)
{
 int ret = 0, refcount;

 spin_lock(&drivers_lock);
 refcount = atomic_read(&driver->refcount);
 WARN_ON(refcount < 0);
 if (refcount > 0)
  ret = -EBUSY;
 else
  list_del(&driver->list);
 spin_unlock(&drivers_lock);

 return ret;
}
EXPORT_SYMBOL(zpool_unregister_driver);

/* this assumes @type is null-terminated. */
static struct zpool_driver *zpool_get_driver(const char *type)
{
 struct zpool_driver *driver;

 spin_lock(&drivers_lock);
 list_for_each_entry(driver, &drivers_head, list) {
  if (!strcmp(driver->type, type)) {
   bool got = try_module_get(driver->owner);

   if (got)
    atomic_inc(&driver->refcount);
   spin_unlock(&drivers_lock);
   return got ? driver : NULL;
  }
 }

 spin_unlock(&drivers_lock);
 return NULL;
}

static void zpool_put_driver(struct zpool_driver *driver)
{
 atomic_dec(&driver->refcount);
 module_put(driver->owner);
}

/**
 * zpool_has_pool() - Check if the pool driver is available
 * @type: The type of the zpool to check (e.g. zsmalloc)
 *
 * This checks if the @type pool driver is available.  This will try to load
 * the requested module, if needed, but there is no guarantee the module will
 * still be loaded and available immediately after calling.  If this returns
 * true, the caller should assume the pool is available, but must be prepared
 * to handle the @zpool_create_pool() returning failure.  However if this
 * returns false, the caller should assume the requested pool type is not
 * available; either the requested pool type module does not exist, or could
 * not be loaded, and calling @zpool_create_pool() with the pool type will
 * fail.
 *
 * The @type string must be null-terminated.
 *
 * Returns: true if @type pool is available, false if not
 */
bool zpool_has_pool(char *type)
{
 struct zpool_driver *driver = zpool_get_driver(type);

 if (!driver) {
  request_module("zpool-%s", type);
  driver = zpool_get_driver(type);
 }

 if (!driver)
  return false;

 zpool_put_driver(driver);
 return true;
}
EXPORT_SYMBOL(zpool_has_pool);

/**
 * zpool_create_pool() - Create a new zpool
 * @type: The type of the zpool to create (e.g. zsmalloc)
 * @name: The name of the zpool (e.g. zram0, zswap)
 * @gfp: The GFP flags to use when allocating the pool.
 *
 * This creates a new zpool of the specified type.  The gfp flags will be
 * used when allocating memory, if the implementation supports it.  If the
 * ops param is NULL, then the created zpool will not be evictable.
 *
 * Implementations must guarantee this to be thread-safe.
 *
 * The @type and @name strings must be null-terminated.
 *
 * Returns: New zpool on success, NULL on failure.
 */
struct zpool *zpool_create_pool(const char *type, const char *name, gfp_t gfp)
{
 struct zpool_driver *driver;
 struct zpool *zpool;

 pr_debug("creating pool type %s\n", type);

 driver = zpool_get_driver(type);

 if (!driver) {
  request_module("zpool-%s", type);
  driver = zpool_get_driver(type);
 }

 if (!driver) {
  pr_err("no driver for type %s\n", type);
  return NULL;
 }

 zpool = kmalloc(sizeof(*zpool), gfp);
 if (!zpool) {
  pr_err("couldn't create zpool - out of memory\n");
  zpool_put_driver(driver);
  return NULL;
 }

 zpool->driver = driver;
 zpool->pool = driver->create(name, gfp);

 if (!zpool->pool) {
  pr_err("couldn't create %s pool\n", type);
  zpool_put_driver(driver);
  kfree(zpool);
  return NULL;
 }

 pr_debug("created pool type %s\n", type);

 return zpool;
}

/**
 * zpool_destroy_pool() - Destroy a zpool
 * @zpool: The zpool to destroy.
 *
 * Implementations must guarantee this to be thread-safe,
 * however only when destroying different pools.  The same
 * pool should only be destroyed once, and should not be used
 * after it is destroyed.
 *
 * This destroys an existing zpool.  The zpool should not be in use.
 */
void zpool_destroy_pool(struct zpool *zpool)
{
 pr_debug("destroying pool type %s\n", zpool->driver->type);

 zpool->driver->destroy(zpool->pool);
 zpool_put_driver(zpool->driver);
 kfree(zpool);
}

/**
 * zpool_get_type() - Get the type of the zpool
 * @zpool: The zpool to check
 *
 * This returns the type of the pool.
 *
 * Implementations must guarantee this to be thread-safe.
 *
 * Returns: The type of zpool.
 */
const char *zpool_get_type(struct zpool *zpool)
{
 return zpool->driver->type;
}

/**
 * zpool_malloc() - Allocate memory
 * @zpool: The zpool to allocate from.
 * @size: The amount of memory to allocate.
 * @gfp: The GFP flags to use when allocating memory.
 * @handle: Pointer to the handle to set
 * @nid: The preferred node id.
 *
 * This allocates the requested amount of memory from the pool.
 * The gfp flags will be used when allocating memory, if the
 * implementation supports it.  The provided @handle will be
 * set to the allocated object handle. The allocation will
 * prefer the NUMA node specified by @nid.
 *
 * Implementations must guarantee this to be thread-safe.
 *
 * Returns: 0 on success, negative value on error.
 */
int zpool_malloc(struct zpool *zpool, size_t size, gfp_t gfp,
   unsigned long *handle, const int nid)
{
 return zpool->driver->malloc(zpool->pool, size, gfp, handle, nid);
}

/**
 * zpool_free() - Free previously allocated memory
 * @zpool: The zpool that allocated the memory.
 * @handle: The handle to the memory to free.
 *
 * This frees previously allocated memory.  This does not guarantee
 * that the pool will actually free memory, only that the memory
 * in the pool will become available for use by the pool.
 *
 * Implementations must guarantee this to be thread-safe,
 * however only when freeing different handles.  The same
 * handle should only be freed once, and should not be used
 * after freeing.
 */
void zpool_free(struct zpool *zpool, unsigned long handle)
{
 zpool->driver->free(zpool->pool, handle);
}

/**
 * zpool_obj_read_begin() - Start reading from a previously allocated handle.
 * @zpool: The zpool that the handle was allocated from
 * @handle: The handle to read from
 * @local_copy: A local buffer to use if needed.
 *
 * This starts a read operation of a previously allocated handle. The passed
 * @local_copy buffer may be used if needed by copying the memory into.
 * zpool_obj_read_end() MUST be called after the read is completed to undo any
 * actions taken (e.g. release locks).
 *
 * Returns: A pointer to the handle memory to be read, if @local_copy is used,
 * the returned pointer is @local_copy.
 */
void *zpool_obj_read_begin(struct zpool *zpool, unsigned long handle,
      void *local_copy)
{
 return zpool->driver->obj_read_begin(zpool->pool, handle, local_copy);
}

/**
 * zpool_obj_read_end() - Finish reading from a previously allocated handle.
 * @zpool: The zpool that the handle was allocated from
 * @handle: The handle to read from
 * @handle_mem: The pointer returned by zpool_obj_read_begin()
 *
 * Finishes a read operation previously started by zpool_obj_read_begin().
 */
void zpool_obj_read_end(struct zpool *zpool, unsigned long handle,
   void *handle_mem)
{
 zpool->driver->obj_read_end(zpool->pool, handle, handle_mem);
}

/**
 * zpool_obj_write() - Write to a previously allocated handle.
 * @zpool: The zpool that the handle was allocated from
 * @handle: The handle to read from
 * @handle_mem: The memory to copy from into the handle.
 * @mem_len: The length of memory to be written.
 *
 */
void zpool_obj_write(struct zpool *zpool, unsigned long handle,
       void *handle_mem, size_t mem_len)
{
 zpool->driver->obj_write(zpool->pool, handle, handle_mem, mem_len);
}

/**
 * zpool_get_total_pages() - The total size of the pool
 * @zpool: The zpool to check
 *
 * This returns the total size in pages of the pool.
 *
 * Returns: Total size of the zpool in pages.
 */
u64 zpool_get_total_pages(struct zpool *zpool)
{
 return zpool->driver->total_pages(zpool->pool);
}

MODULE_AUTHOR("Dan Streetman <ddstreet@ieee.org>");
MODULE_DESCRIPTION("Common API for compressed memory storage");