include/linux/zpool.h

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