LXR linux/include/linux/zpool.h

   1/*
   2 * zpool memory storage api
   3 *
   4 * Copyright (C) 2014 Dan Streetman
   5 *
   6 * This is a common frontend for the zbud and zsmalloc memory
   7 * storage pool implementations.  Typically, this is used to
   8 * store compressed memory.
   9 */
  10
  11#ifndef _ZPOOL_H_
  12#define _ZPOOL_H_
  13
  14struct zpool;
  15
  16struct zpool_ops {
  17        int (*evict)(struct zpool *pool, unsigned long handle);
  18};
  19
  20/*
  21 * Control how a handle is mapped.  It will be ignored if the
  22 * implementation does not support it.  Its use is optional.
  23 * Note that this does not refer to memory protection, it
  24 * refers to how the memory will be copied in/out if copying
  25 * is necessary during mapping; read-write is the safest as
  26 * it copies the existing memory in on map, and copies the
  27 * changed memory back out on unmap.  Write-only does not copy
  28 * in the memory and should only be used for initialization.
  29 * If in doubt, use ZPOOL_MM_DEFAULT which is read-write.
  30 */
  31enum zpool_mapmode {
  32        ZPOOL_MM_RW, /* normal read-write mapping */
  33        ZPOOL_MM_RO, /* read-only (no copy-out at unmap time) */
  34        ZPOOL_MM_WO, /* write-only (no copy-in at map time) */
  35
  36        ZPOOL_MM_DEFAULT = ZPOOL_MM_RW
  37};
  38
  39struct zpool *zpool_create_pool(char *type, char *name,
  40                        gfp_t gfp, struct zpool_ops *ops);
  41
  42char *zpool_get_type(struct zpool *pool);
  43
  44void zpool_destroy_pool(struct zpool *pool);
  45
  46int zpool_malloc(struct zpool *pool, size_t size, gfp_t gfp,
  47                        unsigned long *handle);
  48
  49void zpool_free(struct zpool *pool, unsigned long handle);
  50
  51int zpool_shrink(struct zpool *pool, unsigned int pages,
  52                        unsigned int *reclaimed);
  53
  54void *zpool_map_handle(struct zpool *pool, unsigned long handle,
  55                        enum zpool_mapmode mm);
  56
  57void zpool_unmap_handle(struct zpool *pool, unsigned long handle);
  58
  59u64 zpool_get_total_size(struct zpool *pool);
  60
  61
  62/**
  63 * struct zpool_driver - driver implementation for zpool
  64 * @type:       name of the driver.
  65 * @list:       entry in the list of zpool drivers.
  66 * @create:     create a new pool.
  67 * @destroy:    destroy a pool.
  68 * @malloc:     allocate mem from a pool.
  69 * @free:       free mem from a pool.
  70 * @shrink:     shrink the pool.
  71 * @map:        map a handle.
  72 * @unmap:      unmap a handle.
  73 * @total_size: get total size of a pool.
  74 *
  75 * This is created by a zpool implementation and registered
  76 * with zpool.
  77 */
  78struct zpool_driver {
  79        char *type;
  80        struct module *owner;
  81        atomic_t refcount;
  82        struct list_head list;
  83
  84        void *(*create)(char *name, gfp_t gfp, struct zpool_ops *ops);
  85        void (*destroy)(void *pool);
  86
  87        int (*malloc)(void *pool, size_t size, gfp_t gfp,
  88                                unsigned long *handle);
  89        void (*free)(void *pool, unsigned long handle);
  90
  91        int (*shrink)(void *pool, unsigned int pages,
  92                                unsigned int *reclaimed);
  93
  94        void *(*map)(void *pool, unsigned long handle,
  95                                enum zpool_mapmode mm);
  96        void (*unmap)(void *pool, unsigned long handle);
  97
  98        u64 (*total_size)(void *pool);
  99};
 100
 101void zpool_register_driver(struct zpool_driver *driver);
 102
 103int zpool_unregister_driver(struct zpool_driver *driver);
 104
 105int zpool_evict(void *pool, unsigned long handle);
 106
 107#endif
 108