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