~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/mm/zpool.c

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-only
  2 /*
  3  * zpool memory storage api
  4  *
  5  * Copyright (C) 2014 Dan Streetman
  6  *
  7  * This is a common frontend for memory storage pool implementations.
  8  * Typically, this is used to store compressed memory.
  9  */
 10 
 11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 12 
 13 #include <linux/list.h>
 14 #include <linux/types.h>
 15 #include <linux/mm.h>
 16 #include <linux/slab.h>
 17 #include <linux/spinlock.h>
 18 #include <linux/module.h>
 19 #include <linux/zpool.h>
 20 
 21 struct zpool {
 22         struct zpool_driver *driver;
 23         void *pool;
 24         const struct zpool_ops *ops;
 25         bool evictable;
 26 
 27         struct list_head list;
 28 };
 29 
 30 static LIST_HEAD(drivers_head);
 31 static DEFINE_SPINLOCK(drivers_lock);
 32 
 33 static LIST_HEAD(pools_head);
 34 static DEFINE_SPINLOCK(pools_lock);
 35 
 36 /**
 37  * zpool_register_driver() - register a zpool implementation.
 38  * @driver:     driver to register
 39  */
 40 void zpool_register_driver(struct zpool_driver *driver)
 41 {
 42         spin_lock(&drivers_lock);
 43         atomic_set(&driver->refcount, 0);
 44         list_add(&driver->list, &drivers_head);
 45         spin_unlock(&drivers_lock);
 46 }
 47 EXPORT_SYMBOL(zpool_register_driver);
 48 
 49 /**
 50  * zpool_unregister_driver() - unregister a zpool implementation.
 51  * @driver:     driver to unregister.
 52  *
 53  * Module usage counting is used to prevent using a driver
 54  * while/after unloading, so if this is called from module
 55  * exit function, this should never fail; if called from
 56  * other than the module exit function, and this returns
 57  * failure, the driver is in use and must remain available.
 58  */
 59 int zpool_unregister_driver(struct zpool_driver *driver)
 60 {
 61         int ret = 0, refcount;
 62 
 63         spin_lock(&drivers_lock);
 64         refcount = atomic_read(&driver->refcount);
 65         WARN_ON(refcount < 0);
 66         if (refcount > 0)
 67                 ret = -EBUSY;
 68         else
 69                 list_del(&driver->list);
 70         spin_unlock(&drivers_lock);
 71 
 72         return ret;
 73 }
 74 EXPORT_SYMBOL(zpool_unregister_driver);
 75 
 76 /* this assumes @type is null-terminated. */
 77 static struct zpool_driver *zpool_get_driver(const char *type)
 78 {
 79         struct zpool_driver *driver;
 80 
 81         spin_lock(&drivers_lock);
 82         list_for_each_entry(driver, &drivers_head, list) {
 83                 if (!strcmp(driver->type, type)) {
 84                         bool got = try_module_get(driver->owner);
 85 
 86                         if (got)
 87                                 atomic_inc(&driver->refcount);
 88                         spin_unlock(&drivers_lock);
 89                         return got ? driver : NULL;
 90                 }
 91         }
 92 
 93         spin_unlock(&drivers_lock);
 94         return NULL;
 95 }
 96 
 97 static void zpool_put_driver(struct zpool_driver *driver)
 98 {
 99         atomic_dec(&driver->refcount);
100         module_put(driver->owner);
101 }
102 
103 /**
104  * zpool_has_pool() - Check if the pool driver is available
105  * @type:       The type of the zpool to check (e.g. zbud, zsmalloc)
106  *
107  * This checks if the @type pool driver is available.  This will try to load
108  * the requested module, if needed, but there is no guarantee the module will
109  * still be loaded and available immediately after calling.  If this returns
110  * true, the caller should assume the pool is available, but must be prepared
111  * to handle the @zpool_create_pool() returning failure.  However if this
112  * returns false, the caller should assume the requested pool type is not
113  * available; either the requested pool type module does not exist, or could
114  * not be loaded, and calling @zpool_create_pool() with the pool type will
115  * fail.
116  *
117  * The @type string must be null-terminated.
118  *
119  * Returns: true if @type pool is available, false if not
120  */
121 bool zpool_has_pool(char *type)
122 {
123         struct zpool_driver *driver = zpool_get_driver(type);
124 
125         if (!driver) {
126                 request_module("zpool-%s", type);
127                 driver = zpool_get_driver(type);
128         }
129 
130         if (!driver)
131                 return false;
132 
133         zpool_put_driver(driver);
134         return true;
135 }
136 EXPORT_SYMBOL(zpool_has_pool);
137 
138 /**
139  * zpool_create_pool() - Create a new zpool
140  * @type:       The type of the zpool to create (e.g. zbud, zsmalloc)
141  * @name:       The name of the zpool (e.g. zram0, zswap)
142  * @gfp:        The GFP flags to use when allocating the pool.
143  * @ops:        The optional ops callback.
144  *
145  * This creates a new zpool of the specified type.  The gfp flags will be
146  * used when allocating memory, if the implementation supports it.  If the
147  * ops param is NULL, then the created zpool will not be evictable.
148  *
149  * Implementations must guarantee this to be thread-safe.
150  *
151  * The @type and @name strings must be null-terminated.
152  *
153  * Returns: New zpool on success, NULL on failure.
154  */
155 struct zpool *zpool_create_pool(const char *type, const char *name, gfp_t gfp,
156                 const struct zpool_ops *ops)
157 {
158         struct zpool_driver *driver;
159         struct zpool *zpool;
160 
161         pr_debug("creating pool type %s\n", type);
162 
163         driver = zpool_get_driver(type);
164 
165         if (!driver) {
166                 request_module("zpool-%s", type);
167                 driver = zpool_get_driver(type);
168         }
169 
170         if (!driver) {
171                 pr_err("no driver for type %s\n", type);
172                 return NULL;
173         }
174 
175         zpool = kmalloc(sizeof(*zpool), gfp);
176         if (!zpool) {
177                 pr_err("couldn't create zpool - out of memory\n");
178                 zpool_put_driver(driver);
179                 return NULL;
180         }
181 
182         zpool->driver = driver;
183         zpool->pool = driver->create(name, gfp, ops, zpool);
184         zpool->ops = ops;
185         zpool->evictable = driver->shrink && ops && ops->evict;
186 
187         if (!zpool->pool) {
188                 pr_err("couldn't create %s pool\n", type);
189                 zpool_put_driver(driver);
190                 kfree(zpool);
191                 return NULL;
192         }
193 
194         pr_debug("created pool type %s\n", type);
195 
196         spin_lock(&pools_lock);
197         list_add(&zpool->list, &pools_head);
198         spin_unlock(&pools_lock);
199 
200         return zpool;
201 }
202 
203 /**
204  * zpool_destroy_pool() - Destroy a zpool
205  * @zpool:      The zpool to destroy.
206  *
207  * Implementations must guarantee this to be thread-safe,
208  * however only when destroying different pools.  The same
209  * pool should only be destroyed once, and should not be used
210  * after it is destroyed.
211  *
212  * This destroys an existing zpool.  The zpool should not be in use.
213  */
214 void zpool_destroy_pool(struct zpool *zpool)
215 {
216         pr_debug("destroying pool type %s\n", zpool->driver->type);
217 
218         spin_lock(&pools_lock);
219         list_del(&zpool->list);
220         spin_unlock(&pools_lock);
221         zpool->driver->destroy(zpool->pool);
222         zpool_put_driver(zpool->driver);
223         kfree(zpool);
224 }
225 
226 /**
227  * zpool_get_type() - Get the type of the zpool
228  * @zpool:      The zpool to check
229  *
230  * This returns the type of the pool.
231  *
232  * Implementations must guarantee this to be thread-safe.
233  *
234  * Returns: The type of zpool.
235  */
236 const char *zpool_get_type(struct zpool *zpool)
237 {
238         return zpool->driver->type;
239 }
240 
241 /**
242  * zpool_malloc() - Allocate memory
243  * @zpool:      The zpool to allocate from.
244  * @size:       The amount of memory to allocate.
245  * @gfp:        The GFP flags to use when allocating memory.
246  * @handle:     Pointer to the handle to set
247  *
248  * This allocates the requested amount of memory from the pool.
249  * The gfp flags will be used when allocating memory, if the
250  * implementation supports it.  The provided @handle will be
251  * set to the allocated object handle.
252  *
253  * Implementations must guarantee this to be thread-safe.
254  *
255  * Returns: 0 on success, negative value on error.
256  */
257 int zpool_malloc(struct zpool *zpool, size_t size, gfp_t gfp,
258                         unsigned long *handle)
259 {
260         return zpool->driver->malloc(zpool->pool, size, gfp, handle);
261 }
262 
263 /**
264  * zpool_free() - Free previously allocated memory
265  * @zpool:      The zpool that allocated the memory.
266  * @handle:     The handle to the memory to free.
267  *
268  * This frees previously allocated memory.  This does not guarantee
269  * that the pool will actually free memory, only that the memory
270  * in the pool will become available for use by the pool.
271  *
272  * Implementations must guarantee this to be thread-safe,
273  * however only when freeing different handles.  The same
274  * handle should only be freed once, and should not be used
275  * after freeing.
276  */
277 void zpool_free(struct zpool *zpool, unsigned long handle)
278 {
279         zpool->driver->free(zpool->pool, handle);
280 }
281 
282 /**
283  * zpool_shrink() - Shrink the pool size
284  * @zpool:      The zpool to shrink.
285  * @pages:      The number of pages to shrink the pool.
286  * @reclaimed:  The number of pages successfully evicted.
287  *
288  * This attempts to shrink the actual memory size of the pool
289  * by evicting currently used handle(s).  If the pool was
290  * created with no zpool_ops, or the evict call fails for any
291  * of the handles, this will fail.  If non-NULL, the @reclaimed
292  * parameter will be set to the number of pages reclaimed,
293  * which may be more than the number of pages requested.
294  *
295  * Implementations must guarantee this to be thread-safe.
296  *
297  * Returns: 0 on success, negative value on error/failure.
298  */
299 int zpool_shrink(struct zpool *zpool, unsigned int pages,
300                         unsigned int *reclaimed)
301 {
302         return zpool->driver->shrink ?
303                zpool->driver->shrink(zpool->pool, pages, reclaimed) : -EINVAL;
304 }
305 
306 /**
307  * zpool_map_handle() - Map a previously allocated handle into memory
308  * @zpool:      The zpool that the handle was allocated from
309  * @handle:     The handle to map
310  * @mapmode:    How the memory should be mapped
311  *
312  * This maps a previously allocated handle into memory.  The @mapmode
313  * param indicates to the implementation how the memory will be
314  * used, i.e. read-only, write-only, read-write.  If the
315  * implementation does not support it, the memory will be treated
316  * as read-write.
317  *
318  * This may hold locks, disable interrupts, and/or preemption,
319  * and the zpool_unmap_handle() must be called to undo those
320  * actions.  The code that uses the mapped handle should complete
321  * its operatons on the mapped handle memory quickly and unmap
322  * as soon as possible.  As the implementation may use per-cpu
323  * data, multiple handles should not be mapped concurrently on
324  * any cpu.
325  *
326  * Returns: A pointer to the handle's mapped memory area.
327  */
328 void *zpool_map_handle(struct zpool *zpool, unsigned long handle,
329                         enum zpool_mapmode mapmode)
330 {
331         return zpool->driver->map(zpool->pool, handle, mapmode);
332 }
333 
334 /**
335  * zpool_unmap_handle() - Unmap a previously mapped handle
336  * @zpool:      The zpool that the handle was allocated from
337  * @handle:     The handle to unmap
338  *
339  * This unmaps a previously mapped handle.  Any locks or other
340  * actions that the implementation took in zpool_map_handle()
341  * will be undone here.  The memory area returned from
342  * zpool_map_handle() should no longer be used after this.
343  */
344 void zpool_unmap_handle(struct zpool *zpool, unsigned long handle)
345 {
346         zpool->driver->unmap(zpool->pool, handle);
347 }
348 
349 /**
350  * zpool_get_total_size() - The total size of the pool
351  * @zpool:      The zpool to check
352  *
353  * This returns the total size in bytes of the pool.
354  *
355  * Returns: Total size of the zpool in bytes.
356  */
357 u64 zpool_get_total_size(struct zpool *zpool)
358 {
359         return zpool->driver->total_size(zpool->pool);
360 }
361 
362 /**
363  * zpool_evictable() - Test if zpool is potentially evictable
364  * @zpool:      The zpool to test
365  *
366  * Zpool is only potentially evictable when it's created with struct
367  * zpool_ops.evict and its driver implements struct zpool_driver.shrink.
368  *
369  * However, it doesn't necessarily mean driver will use zpool_ops.evict
370  * in its implementation of zpool_driver.shrink. It could do internal
371  * defragmentation instead.
372  *
373  * Returns: true if potentially evictable; false otherwise.
374  */
375 bool zpool_evictable(struct zpool *zpool)
376 {
377         return zpool->evictable;
378 }
379 
380 MODULE_LICENSE("GPL");
381 MODULE_AUTHOR("Dan Streetman <ddstreet@ieee.org>");
382 MODULE_DESCRIPTION("Common API for compressed memory storage");
383 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp