linux-imx

/*

 * 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;

    const struct zpool_ops *ops;

    bool evictable;

​

    struct list_head list;

};

​

static LIST_HEAD(drivers_head);

static DEFINE_SPINLOCK(drivers_lock);

​

static LIST_HEAD(pools_head);

static DEFINE_SPINLOCK(pools_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);