xref: /linux/include/linux/zpool.h (revision 36ec807b627b4c0a0a382f0ae48eac7187d14b2b)
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
104