2 * zsmalloc memory allocator
4 * Copyright (C) 2011 Nitin Gupta
5 * Copyright (C) 2012, 2013 Minchan Kim
7 * This code is released using a dual license strategy: BSD/GPL
8 * You can choose the license that better fits your requirements.
10 * Released under the terms of 3-clause BSD License
11 * Released under the terms of GNU General Public License Version 2.0
15 * Following is how we use various fields and flags of underlying
16 * struct page(s) to form a zspage.
18 * Usage of struct page fields:
19 * page->private: points to zspage
20 * page->index: links together all component pages of a zspage
21 * For the huge page, this is always 0, so we use this field
23 * page->page_type: first object offset in a subpage of zspage
25 * Usage of struct page flags:
26 * PG_private: identifies the first component page
27 * PG_owner_priv_1: identifies the huge component page
31 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
40 #include <linux/module.h>
41 #include <linux/kernel.h>
42 #include <linux/sched.h>
43 #include <linux/bitops.h>
44 #include <linux/errno.h>
45 #include <linux/highmem.h>
46 #include <linux/string.h>
47 #include <linux/slab.h>
48 #include <linux/pgtable.h>
49 #include <asm/tlbflush.h>
50 #include <linux/cpumask.h>
51 #include <linux/cpu.h>
52 #include <linux/vmalloc.h>
53 #include <linux/preempt.h>
54 #include <linux/spinlock.h>
55 #include <linux/shrinker.h>
56 #include <linux/types.h>
57 #include <linux/debugfs.h>
58 #include <linux/zsmalloc.h>
59 #include <linux/zpool.h>
60 #include <linux/migrate.h>
61 #include <linux/wait.h>
62 #include <linux/pagemap.h>
64 #include <linux/local_lock.h>
66 #define ZSPAGE_MAGIC 0x58
69 * This must be power of 2 and greater than or equal to sizeof(link_free).
70 * These two conditions ensure that any 'struct link_free' itself doesn't
71 * span more than 1 page which avoids complex case of mapping 2 pages simply
72 * to restore link_free pointer values.
77 * A single 'zspage' is composed of up to 2^N discontiguous 0-order (single)
78 * pages. ZS_MAX_ZSPAGE_ORDER defines upper limit on N.
80 #define ZS_MAX_ZSPAGE_ORDER 2
81 #define ZS_MAX_PAGES_PER_ZSPAGE (_AC(1, UL) << ZS_MAX_ZSPAGE_ORDER)
83 #define ZS_HANDLE_SIZE (sizeof(unsigned long))
86 * Object location (<PFN>, <obj_idx>) is encoded as
87 * a single (unsigned long) handle value.
89 * Note that object index <obj_idx> starts from 0.
91 * This is made more complicated by various memory models and PAE.
94 #ifndef MAX_POSSIBLE_PHYSMEM_BITS
95 #ifdef MAX_PHYSMEM_BITS
96 #define MAX_POSSIBLE_PHYSMEM_BITS MAX_PHYSMEM_BITS
99 * If this definition of MAX_PHYSMEM_BITS is used, OBJ_INDEX_BITS will just
102 #define MAX_POSSIBLE_PHYSMEM_BITS BITS_PER_LONG
106 #define _PFN_BITS (MAX_POSSIBLE_PHYSMEM_BITS - PAGE_SHIFT)
109 * Head in allocated object should have OBJ_ALLOCATED_TAG
110 * to identify the object was allocated or not.
111 * It's okay to add the status bit in the least bit because
112 * header keeps handle which is 4byte-aligned address so we
113 * have room for two bit at least.
115 #define OBJ_ALLOCATED_TAG 1
116 #define OBJ_TAG_BITS 1
117 #define OBJ_INDEX_BITS (BITS_PER_LONG - _PFN_BITS - OBJ_TAG_BITS)
118 #define OBJ_INDEX_MASK ((_AC(1, UL) << OBJ_INDEX_BITS) - 1)
121 #define FULLNESS_BITS 2
123 #define ISOLATED_BITS 3
124 #define MAGIC_VAL_BITS 8
126 #define MAX(a, b) ((a) >= (b) ? (a) : (b))
127 /* ZS_MIN_ALLOC_SIZE must be multiple of ZS_ALIGN */
128 #define ZS_MIN_ALLOC_SIZE \
129 MAX(32, (ZS_MAX_PAGES_PER_ZSPAGE << PAGE_SHIFT >> OBJ_INDEX_BITS))
130 /* each chunk includes extra space to keep handle */
131 #define ZS_MAX_ALLOC_SIZE PAGE_SIZE
134 * On systems with 4K page size, this gives 255 size classes! There is a
136 * - Large number of size classes is potentially wasteful as free page are
137 * spread across these classes
138 * - Small number of size classes causes large internal fragmentation
139 * - Probably its better to use specific size classes (empirically
140 * determined). NOTE: all those class sizes must be set as multiple of
141 * ZS_ALIGN to make sure link_free itself never has to span 2 pages.
143 * ZS_MIN_ALLOC_SIZE and ZS_SIZE_CLASS_DELTA must be multiple of ZS_ALIGN
146 #define ZS_SIZE_CLASS_DELTA (PAGE_SIZE >> CLASS_BITS)
147 #define ZS_SIZE_CLASSES (DIV_ROUND_UP(ZS_MAX_ALLOC_SIZE - ZS_MIN_ALLOC_SIZE, \
148 ZS_SIZE_CLASS_DELTA) + 1)
150 enum fullness_group {
158 enum class_stat_type {
168 struct zs_size_stat {
169 unsigned long objs[NR_ZS_STAT_TYPE];
172 #ifdef CONFIG_ZSMALLOC_STAT
173 static struct dentry *zs_stat_root;
177 * We assign a page to ZS_ALMOST_EMPTY fullness group when:
179 * n = number of allocated objects
180 * N = total number of objects zspage can store
181 * f = fullness_threshold_frac
183 * Similarly, we assign zspage to:
184 * ZS_ALMOST_FULL when n > N / f
185 * ZS_EMPTY when n == 0
186 * ZS_FULL when n == N
188 * (see: fix_fullness_group())
190 static const int fullness_threshold_frac = 4;
191 static size_t huge_class_size;
194 struct list_head fullness_list[NR_ZS_FULLNESS];
196 * Size of objects stored in this class. Must be multiple
201 /* Number of PAGE_SIZE sized pages to combine to form a 'zspage' */
202 int pages_per_zspage;
205 struct zs_size_stat stats;
209 * Placed within free objects to form a singly linked list.
210 * For every zspage, zspage->freeobj gives head of this list.
212 * This must be power of 2 and less than or equal to ZS_ALIGN
218 * It's valid for non-allocated object
222 * Handle of allocated object.
224 unsigned long handle;
231 struct size_class *size_class[ZS_SIZE_CLASSES];
232 struct kmem_cache *handle_cachep;
233 struct kmem_cache *zspage_cachep;
235 atomic_long_t pages_allocated;
237 struct zs_pool_stats stats;
239 /* Compact classes */
240 struct shrinker shrinker;
243 /* List tracking the zspages in LRU order by most recently added object */
244 struct list_head lru;
247 #ifdef CONFIG_ZSMALLOC_STAT
248 struct dentry *stat_dentry;
250 #ifdef CONFIG_COMPACTION
251 struct work_struct free_work;
258 unsigned int huge:HUGE_BITS;
259 unsigned int fullness:FULLNESS_BITS;
260 unsigned int class:CLASS_BITS + 1;
261 unsigned int isolated:ISOLATED_BITS;
262 unsigned int magic:MAGIC_VAL_BITS;
265 unsigned int freeobj;
266 struct page *first_page;
267 struct list_head list; /* fullness list */
270 /* links the zspage to the lru list in the pool */
271 struct list_head lru;
274 struct zs_pool *pool;
275 #ifdef CONFIG_COMPACTION
280 struct mapping_area {
282 char *vm_buf; /* copy buffer for objects that span pages */
283 char *vm_addr; /* address of kmap_atomic()'ed pages */
284 enum zs_mapmode vm_mm; /* mapping mode */
287 /* huge object: pages_per_zspage == 1 && maxobj_per_zspage == 1 */
288 static void SetZsHugePage(struct zspage *zspage)
293 static bool ZsHugePage(struct zspage *zspage)
298 #ifdef CONFIG_COMPACTION
299 static void migrate_lock_init(struct zspage *zspage);
300 static void migrate_read_lock(struct zspage *zspage);
301 static void migrate_read_unlock(struct zspage *zspage);
302 static void migrate_write_lock(struct zspage *zspage);
303 static void migrate_write_lock_nested(struct zspage *zspage);
304 static void migrate_write_unlock(struct zspage *zspage);
305 static void kick_deferred_free(struct zs_pool *pool);
306 static void init_deferred_free(struct zs_pool *pool);
307 static void SetZsPageMovable(struct zs_pool *pool, struct zspage *zspage);
309 static void migrate_lock_init(struct zspage *zspage) {}
310 static void migrate_read_lock(struct zspage *zspage) {}
311 static void migrate_read_unlock(struct zspage *zspage) {}
312 static void migrate_write_lock(struct zspage *zspage) {}
313 static void migrate_write_lock_nested(struct zspage *zspage) {}
314 static void migrate_write_unlock(struct zspage *zspage) {}
315 static void kick_deferred_free(struct zs_pool *pool) {}
316 static void init_deferred_free(struct zs_pool *pool) {}
317 static void SetZsPageMovable(struct zs_pool *pool, struct zspage *zspage) {}
320 static int create_cache(struct zs_pool *pool)
322 pool->handle_cachep = kmem_cache_create("zs_handle", ZS_HANDLE_SIZE,
324 if (!pool->handle_cachep)
327 pool->zspage_cachep = kmem_cache_create("zspage", sizeof(struct zspage),
329 if (!pool->zspage_cachep) {
330 kmem_cache_destroy(pool->handle_cachep);
331 pool->handle_cachep = NULL;
338 static void destroy_cache(struct zs_pool *pool)
340 kmem_cache_destroy(pool->handle_cachep);
341 kmem_cache_destroy(pool->zspage_cachep);
344 static unsigned long cache_alloc_handle(struct zs_pool *pool, gfp_t gfp)
346 return (unsigned long)kmem_cache_alloc(pool->handle_cachep,
347 gfp & ~(__GFP_HIGHMEM|__GFP_MOVABLE));
350 static void cache_free_handle(struct zs_pool *pool, unsigned long handle)
352 kmem_cache_free(pool->handle_cachep, (void *)handle);
355 static struct zspage *cache_alloc_zspage(struct zs_pool *pool, gfp_t flags)
357 return kmem_cache_zalloc(pool->zspage_cachep,
358 flags & ~(__GFP_HIGHMEM|__GFP_MOVABLE));
361 static void cache_free_zspage(struct zs_pool *pool, struct zspage *zspage)
363 kmem_cache_free(pool->zspage_cachep, zspage);
366 /* pool->lock(which owns the handle) synchronizes races */
367 static void record_obj(unsigned long handle, unsigned long obj)
369 *(unsigned long *)handle = obj;
376 static void *zs_zpool_create(const char *name, gfp_t gfp,
377 const struct zpool_ops *zpool_ops,
381 * Ignore global gfp flags: zs_malloc() may be invoked from
382 * different contexts and its caller must provide a valid
385 return zs_create_pool(name);
388 static void zs_zpool_destroy(void *pool)
390 zs_destroy_pool(pool);
393 static int zs_zpool_malloc(void *pool, size_t size, gfp_t gfp,
394 unsigned long *handle)
396 *handle = zs_malloc(pool, size, gfp);
398 if (IS_ERR_VALUE(*handle))
399 return PTR_ERR((void *)*handle);
402 static void zs_zpool_free(void *pool, unsigned long handle)
404 zs_free(pool, handle);
407 static void *zs_zpool_map(void *pool, unsigned long handle,
408 enum zpool_mapmode mm)
410 enum zs_mapmode zs_mm;
425 return zs_map_object(pool, handle, zs_mm);
427 static void zs_zpool_unmap(void *pool, unsigned long handle)
429 zs_unmap_object(pool, handle);
432 static u64 zs_zpool_total_size(void *pool)
434 return zs_get_total_pages(pool) << PAGE_SHIFT;
437 static struct zpool_driver zs_zpool_driver = {
439 .owner = THIS_MODULE,
440 .create = zs_zpool_create,
441 .destroy = zs_zpool_destroy,
442 .malloc_support_movable = true,
443 .malloc = zs_zpool_malloc,
444 .free = zs_zpool_free,
446 .unmap = zs_zpool_unmap,
447 .total_size = zs_zpool_total_size,
450 MODULE_ALIAS("zpool-zsmalloc");
451 #endif /* CONFIG_ZPOOL */
453 /* per-cpu VM mapping areas for zspage accesses that cross page boundaries */
454 static DEFINE_PER_CPU(struct mapping_area, zs_map_area) = {
455 .lock = INIT_LOCAL_LOCK(lock),
458 static __maybe_unused int is_first_page(struct page *page)
460 return PagePrivate(page);
463 /* Protected by pool->lock */
464 static inline int get_zspage_inuse(struct zspage *zspage)
466 return zspage->inuse;
470 static inline void mod_zspage_inuse(struct zspage *zspage, int val)
472 zspage->inuse += val;
475 static inline struct page *get_first_page(struct zspage *zspage)
477 struct page *first_page = zspage->first_page;
479 VM_BUG_ON_PAGE(!is_first_page(first_page), first_page);
483 static inline unsigned int get_first_obj_offset(struct page *page)
485 return page->page_type;
488 static inline void set_first_obj_offset(struct page *page, unsigned int offset)
490 page->page_type = offset;
493 static inline unsigned int get_freeobj(struct zspage *zspage)
495 return zspage->freeobj;
498 static inline void set_freeobj(struct zspage *zspage, unsigned int obj)
500 zspage->freeobj = obj;
503 static void get_zspage_mapping(struct zspage *zspage,
504 unsigned int *class_idx,
505 enum fullness_group *fullness)
507 BUG_ON(zspage->magic != ZSPAGE_MAGIC);
509 *fullness = zspage->fullness;
510 *class_idx = zspage->class;
513 static struct size_class *zspage_class(struct zs_pool *pool,
514 struct zspage *zspage)
516 return pool->size_class[zspage->class];
519 static void set_zspage_mapping(struct zspage *zspage,
520 unsigned int class_idx,
521 enum fullness_group fullness)
523 zspage->class = class_idx;
524 zspage->fullness = fullness;
528 * zsmalloc divides the pool into various size classes where each
529 * class maintains a list of zspages where each zspage is divided
530 * into equal sized chunks. Each allocation falls into one of these
531 * classes depending on its size. This function returns index of the
532 * size class which has chunk size big enough to hold the given size.
534 static int get_size_class_index(int size)
538 if (likely(size > ZS_MIN_ALLOC_SIZE))
539 idx = DIV_ROUND_UP(size - ZS_MIN_ALLOC_SIZE,
540 ZS_SIZE_CLASS_DELTA);
542 return min_t(int, ZS_SIZE_CLASSES - 1, idx);
545 /* type can be of enum type class_stat_type or fullness_group */
546 static inline void class_stat_inc(struct size_class *class,
547 int type, unsigned long cnt)
549 class->stats.objs[type] += cnt;
552 /* type can be of enum type class_stat_type or fullness_group */
553 static inline void class_stat_dec(struct size_class *class,
554 int type, unsigned long cnt)
556 class->stats.objs[type] -= cnt;
559 /* type can be of enum type class_stat_type or fullness_group */
560 static inline unsigned long zs_stat_get(struct size_class *class,
563 return class->stats.objs[type];
566 #ifdef CONFIG_ZSMALLOC_STAT
568 static void __init zs_stat_init(void)
570 if (!debugfs_initialized()) {
571 pr_warn("debugfs not available, stat dir not created\n");
575 zs_stat_root = debugfs_create_dir("zsmalloc", NULL);
578 static void __exit zs_stat_exit(void)
580 debugfs_remove_recursive(zs_stat_root);
583 static unsigned long zs_can_compact(struct size_class *class);
585 static int zs_stats_size_show(struct seq_file *s, void *v)
588 struct zs_pool *pool = s->private;
589 struct size_class *class;
591 unsigned long class_almost_full, class_almost_empty;
592 unsigned long obj_allocated, obj_used, pages_used, freeable;
593 unsigned long total_class_almost_full = 0, total_class_almost_empty = 0;
594 unsigned long total_objs = 0, total_used_objs = 0, total_pages = 0;
595 unsigned long total_freeable = 0;
597 seq_printf(s, " %5s %5s %11s %12s %13s %10s %10s %16s %8s\n",
598 "class", "size", "almost_full", "almost_empty",
599 "obj_allocated", "obj_used", "pages_used",
600 "pages_per_zspage", "freeable");
602 for (i = 0; i < ZS_SIZE_CLASSES; i++) {
603 class = pool->size_class[i];
605 if (class->index != i)
608 spin_lock(&pool->lock);
609 class_almost_full = zs_stat_get(class, CLASS_ALMOST_FULL);
610 class_almost_empty = zs_stat_get(class, CLASS_ALMOST_EMPTY);
611 obj_allocated = zs_stat_get(class, OBJ_ALLOCATED);
612 obj_used = zs_stat_get(class, OBJ_USED);
613 freeable = zs_can_compact(class);
614 spin_unlock(&pool->lock);
616 objs_per_zspage = class->objs_per_zspage;
617 pages_used = obj_allocated / objs_per_zspage *
618 class->pages_per_zspage;
620 seq_printf(s, " %5u %5u %11lu %12lu %13lu"
621 " %10lu %10lu %16d %8lu\n",
622 i, class->size, class_almost_full, class_almost_empty,
623 obj_allocated, obj_used, pages_used,
624 class->pages_per_zspage, freeable);
626 total_class_almost_full += class_almost_full;
627 total_class_almost_empty += class_almost_empty;
628 total_objs += obj_allocated;
629 total_used_objs += obj_used;
630 total_pages += pages_used;
631 total_freeable += freeable;
635 seq_printf(s, " %5s %5s %11lu %12lu %13lu %10lu %10lu %16s %8lu\n",
636 "Total", "", total_class_almost_full,
637 total_class_almost_empty, total_objs,
638 total_used_objs, total_pages, "", total_freeable);
642 DEFINE_SHOW_ATTRIBUTE(zs_stats_size);
644 static void zs_pool_stat_create(struct zs_pool *pool, const char *name)
647 pr_warn("no root stat dir, not creating <%s> stat dir\n", name);
651 pool->stat_dentry = debugfs_create_dir(name, zs_stat_root);
653 debugfs_create_file("classes", S_IFREG | 0444, pool->stat_dentry, pool,
654 &zs_stats_size_fops);
657 static void zs_pool_stat_destroy(struct zs_pool *pool)
659 debugfs_remove_recursive(pool->stat_dentry);
662 #else /* CONFIG_ZSMALLOC_STAT */
663 static void __init zs_stat_init(void)
667 static void __exit zs_stat_exit(void)
671 static inline void zs_pool_stat_create(struct zs_pool *pool, const char *name)
675 static inline void zs_pool_stat_destroy(struct zs_pool *pool)
682 * For each size class, zspages are divided into different groups
683 * depending on how "full" they are. This was done so that we could
684 * easily find empty or nearly empty zspages when we try to shrink
685 * the pool (not yet implemented). This function returns fullness
686 * status of the given page.
688 static enum fullness_group get_fullness_group(struct size_class *class,
689 struct zspage *zspage)
691 int inuse, objs_per_zspage;
692 enum fullness_group fg;
694 inuse = get_zspage_inuse(zspage);
695 objs_per_zspage = class->objs_per_zspage;
699 else if (inuse == objs_per_zspage)
701 else if (inuse <= 3 * objs_per_zspage / fullness_threshold_frac)
702 fg = ZS_ALMOST_EMPTY;
710 * Each size class maintains various freelists and zspages are assigned
711 * to one of these freelists based on the number of live objects they
712 * have. This functions inserts the given zspage into the freelist
713 * identified by <class, fullness_group>.
715 static void insert_zspage(struct size_class *class,
716 struct zspage *zspage,
717 enum fullness_group fullness)
721 class_stat_inc(class, fullness, 1);
722 head = list_first_entry_or_null(&class->fullness_list[fullness],
723 struct zspage, list);
725 * We want to see more ZS_FULL pages and less almost empty/full.
726 * Put pages with higher ->inuse first.
728 if (head && get_zspage_inuse(zspage) < get_zspage_inuse(head))
729 list_add(&zspage->list, &head->list);
731 list_add(&zspage->list, &class->fullness_list[fullness]);
735 * This function removes the given zspage from the freelist identified
736 * by <class, fullness_group>.
738 static void remove_zspage(struct size_class *class,
739 struct zspage *zspage,
740 enum fullness_group fullness)
742 VM_BUG_ON(list_empty(&class->fullness_list[fullness]));
744 list_del_init(&zspage->list);
745 class_stat_dec(class, fullness, 1);
749 * Each size class maintains zspages in different fullness groups depending
750 * on the number of live objects they contain. When allocating or freeing
751 * objects, the fullness status of the page can change, say, from ALMOST_FULL
752 * to ALMOST_EMPTY when freeing an object. This function checks if such
753 * a status change has occurred for the given page and accordingly moves the
754 * page from the freelist of the old fullness group to that of the new
757 static enum fullness_group fix_fullness_group(struct size_class *class,
758 struct zspage *zspage)
761 enum fullness_group currfg, newfg;
763 get_zspage_mapping(zspage, &class_idx, &currfg);
764 newfg = get_fullness_group(class, zspage);
768 remove_zspage(class, zspage, currfg);
769 insert_zspage(class, zspage, newfg);
770 set_zspage_mapping(zspage, class_idx, newfg);
776 * We have to decide on how many pages to link together
777 * to form a zspage for each size class. This is important
778 * to reduce wastage due to unusable space left at end of
779 * each zspage which is given as:
780 * wastage = Zp % class_size
781 * usage = Zp - wastage
782 * where Zp = zspage size = k * PAGE_SIZE where k = 1, 2, ...
784 * For example, for size class of 3/8 * PAGE_SIZE, we should
785 * link together 3 PAGE_SIZE sized pages to form a zspage
786 * since then we can perfectly fit in 8 such objects.
788 static int get_pages_per_zspage(int class_size)
790 int i, max_usedpc = 0;
791 /* zspage order which gives maximum used size per KB */
792 int max_usedpc_order = 1;
794 for (i = 1; i <= ZS_MAX_PAGES_PER_ZSPAGE; i++) {
798 zspage_size = i * PAGE_SIZE;
799 waste = zspage_size % class_size;
800 usedpc = (zspage_size - waste) * 100 / zspage_size;
802 if (usedpc > max_usedpc) {
804 max_usedpc_order = i;
808 return max_usedpc_order;
811 static struct zspage *get_zspage(struct page *page)
813 struct zspage *zspage = (struct zspage *)page_private(page);
815 BUG_ON(zspage->magic != ZSPAGE_MAGIC);
819 static struct page *get_next_page(struct page *page)
821 struct zspage *zspage = get_zspage(page);
823 if (unlikely(ZsHugePage(zspage)))
826 return (struct page *)page->index;
830 * obj_to_location - get (<page>, <obj_idx>) from encoded object value
831 * @obj: the encoded object value
832 * @page: page object resides in zspage
833 * @obj_idx: object index
835 static void obj_to_location(unsigned long obj, struct page **page,
836 unsigned int *obj_idx)
838 obj >>= OBJ_TAG_BITS;
839 *page = pfn_to_page(obj >> OBJ_INDEX_BITS);
840 *obj_idx = (obj & OBJ_INDEX_MASK);
843 static void obj_to_page(unsigned long obj, struct page **page)
845 obj >>= OBJ_TAG_BITS;
846 *page = pfn_to_page(obj >> OBJ_INDEX_BITS);
850 * location_to_obj - get obj value encoded from (<page>, <obj_idx>)
851 * @page: page object resides in zspage
852 * @obj_idx: object index
854 static unsigned long location_to_obj(struct page *page, unsigned int obj_idx)
858 obj = page_to_pfn(page) << OBJ_INDEX_BITS;
859 obj |= obj_idx & OBJ_INDEX_MASK;
860 obj <<= OBJ_TAG_BITS;
865 static unsigned long handle_to_obj(unsigned long handle)
867 return *(unsigned long *)handle;
870 static bool obj_allocated(struct page *page, void *obj, unsigned long *phandle)
872 unsigned long handle;
873 struct zspage *zspage = get_zspage(page);
875 if (unlikely(ZsHugePage(zspage))) {
876 VM_BUG_ON_PAGE(!is_first_page(page), page);
877 handle = page->index;
879 handle = *(unsigned long *)obj;
881 if (!(handle & OBJ_ALLOCATED_TAG))
884 *phandle = handle & ~OBJ_ALLOCATED_TAG;
888 static void reset_page(struct page *page)
890 __ClearPageMovable(page);
891 ClearPagePrivate(page);
892 set_page_private(page, 0);
893 page_mapcount_reset(page);
897 static int trylock_zspage(struct zspage *zspage)
899 struct page *cursor, *fail;
901 for (cursor = get_first_page(zspage); cursor != NULL; cursor =
902 get_next_page(cursor)) {
903 if (!trylock_page(cursor)) {
911 for (cursor = get_first_page(zspage); cursor != fail; cursor =
912 get_next_page(cursor))
918 static void __free_zspage(struct zs_pool *pool, struct size_class *class,
919 struct zspage *zspage)
921 struct page *page, *next;
922 enum fullness_group fg;
923 unsigned int class_idx;
925 get_zspage_mapping(zspage, &class_idx, &fg);
927 assert_spin_locked(&pool->lock);
929 VM_BUG_ON(get_zspage_inuse(zspage));
930 VM_BUG_ON(fg != ZS_EMPTY);
932 next = page = get_first_page(zspage);
934 VM_BUG_ON_PAGE(!PageLocked(page), page);
935 next = get_next_page(page);
938 dec_zone_page_state(page, NR_ZSPAGES);
941 } while (page != NULL);
943 cache_free_zspage(pool, zspage);
945 class_stat_dec(class, OBJ_ALLOCATED, class->objs_per_zspage);
946 atomic_long_sub(class->pages_per_zspage,
947 &pool->pages_allocated);
950 static void free_zspage(struct zs_pool *pool, struct size_class *class,
951 struct zspage *zspage)
953 VM_BUG_ON(get_zspage_inuse(zspage));
954 VM_BUG_ON(list_empty(&zspage->list));
957 * Since zs_free couldn't be sleepable, this function cannot call
958 * lock_page. The page locks trylock_zspage got will be released
961 if (!trylock_zspage(zspage)) {
962 kick_deferred_free(pool);
966 remove_zspage(class, zspage, ZS_EMPTY);
968 list_del(&zspage->lru);
970 __free_zspage(pool, class, zspage);
973 /* Initialize a newly allocated zspage */
974 static void init_zspage(struct size_class *class, struct zspage *zspage)
976 unsigned int freeobj = 1;
977 unsigned long off = 0;
978 struct page *page = get_first_page(zspage);
981 struct page *next_page;
982 struct link_free *link;
985 set_first_obj_offset(page, off);
987 vaddr = kmap_atomic(page);
988 link = (struct link_free *)vaddr + off / sizeof(*link);
990 while ((off += class->size) < PAGE_SIZE) {
991 link->next = freeobj++ << OBJ_TAG_BITS;
992 link += class->size / sizeof(*link);
996 * We now come to the last (full or partial) object on this
997 * page, which must point to the first object on the next
1000 next_page = get_next_page(page);
1002 link->next = freeobj++ << OBJ_TAG_BITS;
1005 * Reset OBJ_TAG_BITS bit to last link to tell
1006 * whether it's allocated object or not.
1008 link->next = -1UL << OBJ_TAG_BITS;
1010 kunmap_atomic(vaddr);
1016 INIT_LIST_HEAD(&zspage->lru);
1019 set_freeobj(zspage, 0);
1022 static void create_page_chain(struct size_class *class, struct zspage *zspage,
1023 struct page *pages[])
1027 struct page *prev_page = NULL;
1028 int nr_pages = class->pages_per_zspage;
1031 * Allocate individual pages and link them together as:
1032 * 1. all pages are linked together using page->index
1033 * 2. each sub-page point to zspage using page->private
1035 * we set PG_private to identify the first page (i.e. no other sub-page
1036 * has this flag set).
1038 for (i = 0; i < nr_pages; i++) {
1040 set_page_private(page, (unsigned long)zspage);
1043 zspage->first_page = page;
1044 SetPagePrivate(page);
1045 if (unlikely(class->objs_per_zspage == 1 &&
1046 class->pages_per_zspage == 1))
1047 SetZsHugePage(zspage);
1049 prev_page->index = (unsigned long)page;
1056 * Allocate a zspage for the given size class
1058 static struct zspage *alloc_zspage(struct zs_pool *pool,
1059 struct size_class *class,
1063 struct page *pages[ZS_MAX_PAGES_PER_ZSPAGE];
1064 struct zspage *zspage = cache_alloc_zspage(pool, gfp);
1069 zspage->magic = ZSPAGE_MAGIC;
1070 migrate_lock_init(zspage);
1072 for (i = 0; i < class->pages_per_zspage; i++) {
1075 page = alloc_page(gfp);
1078 dec_zone_page_state(pages[i], NR_ZSPAGES);
1079 __free_page(pages[i]);
1081 cache_free_zspage(pool, zspage);
1085 inc_zone_page_state(page, NR_ZSPAGES);
1089 create_page_chain(class, zspage, pages);
1090 init_zspage(class, zspage);
1091 zspage->pool = pool;
1096 static struct zspage *find_get_zspage(struct size_class *class)
1099 struct zspage *zspage;
1101 for (i = ZS_ALMOST_FULL; i >= ZS_EMPTY; i--) {
1102 zspage = list_first_entry_or_null(&class->fullness_list[i],
1103 struct zspage, list);
1111 static inline int __zs_cpu_up(struct mapping_area *area)
1114 * Make sure we don't leak memory if a cpu UP notification
1115 * and zs_init() race and both call zs_cpu_up() on the same cpu
1119 area->vm_buf = kmalloc(ZS_MAX_ALLOC_SIZE, GFP_KERNEL);
1125 static inline void __zs_cpu_down(struct mapping_area *area)
1127 kfree(area->vm_buf);
1128 area->vm_buf = NULL;
1131 static void *__zs_map_object(struct mapping_area *area,
1132 struct page *pages[2], int off, int size)
1136 char *buf = area->vm_buf;
1138 /* disable page faults to match kmap_atomic() return conditions */
1139 pagefault_disable();
1141 /* no read fastpath */
1142 if (area->vm_mm == ZS_MM_WO)
1145 sizes[0] = PAGE_SIZE - off;
1146 sizes[1] = size - sizes[0];
1148 /* copy object to per-cpu buffer */
1149 addr = kmap_atomic(pages[0]);
1150 memcpy(buf, addr + off, sizes[0]);
1151 kunmap_atomic(addr);
1152 addr = kmap_atomic(pages[1]);
1153 memcpy(buf + sizes[0], addr, sizes[1]);
1154 kunmap_atomic(addr);
1156 return area->vm_buf;
1159 static void __zs_unmap_object(struct mapping_area *area,
1160 struct page *pages[2], int off, int size)
1166 /* no write fastpath */
1167 if (area->vm_mm == ZS_MM_RO)
1171 buf = buf + ZS_HANDLE_SIZE;
1172 size -= ZS_HANDLE_SIZE;
1173 off += ZS_HANDLE_SIZE;
1175 sizes[0] = PAGE_SIZE - off;
1176 sizes[1] = size - sizes[0];
1178 /* copy per-cpu buffer to object */
1179 addr = kmap_atomic(pages[0]);
1180 memcpy(addr + off, buf, sizes[0]);
1181 kunmap_atomic(addr);
1182 addr = kmap_atomic(pages[1]);
1183 memcpy(addr, buf + sizes[0], sizes[1]);
1184 kunmap_atomic(addr);
1187 /* enable page faults to match kunmap_atomic() return conditions */
1191 static int zs_cpu_prepare(unsigned int cpu)
1193 struct mapping_area *area;
1195 area = &per_cpu(zs_map_area, cpu);
1196 return __zs_cpu_up(area);
1199 static int zs_cpu_dead(unsigned int cpu)
1201 struct mapping_area *area;
1203 area = &per_cpu(zs_map_area, cpu);
1204 __zs_cpu_down(area);
1208 static bool can_merge(struct size_class *prev, int pages_per_zspage,
1209 int objs_per_zspage)
1211 if (prev->pages_per_zspage == pages_per_zspage &&
1212 prev->objs_per_zspage == objs_per_zspage)
1218 static bool zspage_full(struct size_class *class, struct zspage *zspage)
1220 return get_zspage_inuse(zspage) == class->objs_per_zspage;
1224 * zs_lookup_class_index() - Returns index of the zsmalloc &size_class
1225 * that hold objects of the provided size.
1226 * @pool: zsmalloc pool to use
1227 * @size: object size
1229 * Context: Any context.
1231 * Return: the index of the zsmalloc &size_class that hold objects of the
1234 unsigned int zs_lookup_class_index(struct zs_pool *pool, unsigned int size)
1236 struct size_class *class;
1238 class = pool->size_class[get_size_class_index(size)];
1240 return class->index;
1242 EXPORT_SYMBOL_GPL(zs_lookup_class_index);
1244 unsigned long zs_get_total_pages(struct zs_pool *pool)
1246 return atomic_long_read(&pool->pages_allocated);
1248 EXPORT_SYMBOL_GPL(zs_get_total_pages);
1251 * zs_map_object - get address of allocated object from handle.
1252 * @pool: pool from which the object was allocated
1253 * @handle: handle returned from zs_malloc
1254 * @mm: mapping mode to use
1256 * Before using an object allocated from zs_malloc, it must be mapped using
1257 * this function. When done with the object, it must be unmapped using
1260 * Only one object can be mapped per cpu at a time. There is no protection
1261 * against nested mappings.
1263 * This function returns with preemption and page faults disabled.
1265 void *zs_map_object(struct zs_pool *pool, unsigned long handle,
1268 struct zspage *zspage;
1270 unsigned long obj, off;
1271 unsigned int obj_idx;
1273 struct size_class *class;
1274 struct mapping_area *area;
1275 struct page *pages[2];
1279 * Because we use per-cpu mapping areas shared among the
1280 * pools/users, we can't allow mapping in interrupt context
1281 * because it can corrupt another users mappings.
1283 BUG_ON(in_interrupt());
1285 /* It guarantees it can get zspage from handle safely */
1286 spin_lock(&pool->lock);
1287 obj = handle_to_obj(handle);
1288 obj_to_location(obj, &page, &obj_idx);
1289 zspage = get_zspage(page);
1293 * Move the zspage to front of pool's LRU.
1295 * Note that this is swap-specific, so by definition there are no ongoing
1296 * accesses to the memory while the page is swapped out that would make
1297 * it "hot". A new entry is hot, then ages to the tail until it gets either
1298 * written back or swaps back in.
1300 * Furthermore, map is also called during writeback. We must not put an
1301 * isolated page on the LRU mid-reclaim.
1303 * As a result, only update the LRU when the page is mapped for write
1304 * when it's first instantiated.
1306 * This is a deviation from the other backends, which perform this update
1307 * in the allocation function (zbud_alloc, z3fold_alloc).
1309 if (mm == ZS_MM_WO) {
1310 if (!list_empty(&zspage->lru))
1311 list_del(&zspage->lru);
1312 list_add(&zspage->lru, &pool->lru);
1317 * migration cannot move any zpages in this zspage. Here, pool->lock
1318 * is too heavy since callers would take some time until they calls
1319 * zs_unmap_object API so delegate the locking from class to zspage
1320 * which is smaller granularity.
1322 migrate_read_lock(zspage);
1323 spin_unlock(&pool->lock);
1325 class = zspage_class(pool, zspage);
1326 off = (class->size * obj_idx) & ~PAGE_MASK;
1328 local_lock(&zs_map_area.lock);
1329 area = this_cpu_ptr(&zs_map_area);
1331 if (off + class->size <= PAGE_SIZE) {
1332 /* this object is contained entirely within a page */
1333 area->vm_addr = kmap_atomic(page);
1334 ret = area->vm_addr + off;
1338 /* this object spans two pages */
1340 pages[1] = get_next_page(page);
1343 ret = __zs_map_object(area, pages, off, class->size);
1345 if (likely(!ZsHugePage(zspage)))
1346 ret += ZS_HANDLE_SIZE;
1350 EXPORT_SYMBOL_GPL(zs_map_object);
1352 void zs_unmap_object(struct zs_pool *pool, unsigned long handle)
1354 struct zspage *zspage;
1356 unsigned long obj, off;
1357 unsigned int obj_idx;
1359 struct size_class *class;
1360 struct mapping_area *area;
1362 obj = handle_to_obj(handle);
1363 obj_to_location(obj, &page, &obj_idx);
1364 zspage = get_zspage(page);
1365 class = zspage_class(pool, zspage);
1366 off = (class->size * obj_idx) & ~PAGE_MASK;
1368 area = this_cpu_ptr(&zs_map_area);
1369 if (off + class->size <= PAGE_SIZE)
1370 kunmap_atomic(area->vm_addr);
1372 struct page *pages[2];
1375 pages[1] = get_next_page(page);
1378 __zs_unmap_object(area, pages, off, class->size);
1380 local_unlock(&zs_map_area.lock);
1382 migrate_read_unlock(zspage);
1384 EXPORT_SYMBOL_GPL(zs_unmap_object);
1387 * zs_huge_class_size() - Returns the size (in bytes) of the first huge
1388 * zsmalloc &size_class.
1389 * @pool: zsmalloc pool to use
1391 * The function returns the size of the first huge class - any object of equal
1392 * or bigger size will be stored in zspage consisting of a single physical
1395 * Context: Any context.
1397 * Return: the size (in bytes) of the first huge zsmalloc &size_class.
1399 size_t zs_huge_class_size(struct zs_pool *pool)
1401 return huge_class_size;
1403 EXPORT_SYMBOL_GPL(zs_huge_class_size);
1405 static unsigned long obj_malloc(struct zs_pool *pool,
1406 struct zspage *zspage, unsigned long handle)
1408 int i, nr_page, offset;
1410 struct link_free *link;
1411 struct size_class *class;
1413 struct page *m_page;
1414 unsigned long m_offset;
1417 class = pool->size_class[zspage->class];
1418 handle |= OBJ_ALLOCATED_TAG;
1419 obj = get_freeobj(zspage);
1421 offset = obj * class->size;
1422 nr_page = offset >> PAGE_SHIFT;
1423 m_offset = offset & ~PAGE_MASK;
1424 m_page = get_first_page(zspage);
1426 for (i = 0; i < nr_page; i++)
1427 m_page = get_next_page(m_page);
1429 vaddr = kmap_atomic(m_page);
1430 link = (struct link_free *)vaddr + m_offset / sizeof(*link);
1431 set_freeobj(zspage, link->next >> OBJ_TAG_BITS);
1432 if (likely(!ZsHugePage(zspage)))
1433 /* record handle in the header of allocated chunk */
1434 link->handle = handle;
1436 /* record handle to page->index */
1437 zspage->first_page->index = handle;
1439 kunmap_atomic(vaddr);
1440 mod_zspage_inuse(zspage, 1);
1442 obj = location_to_obj(m_page, obj);
1449 * zs_malloc - Allocate block of given size from pool.
1450 * @pool: pool to allocate from
1451 * @size: size of block to allocate
1452 * @gfp: gfp flags when allocating object
1454 * On success, handle to the allocated object is returned,
1455 * otherwise an ERR_PTR().
1456 * Allocation requests with size > ZS_MAX_ALLOC_SIZE will fail.
1458 unsigned long zs_malloc(struct zs_pool *pool, size_t size, gfp_t gfp)
1460 unsigned long handle, obj;
1461 struct size_class *class;
1462 enum fullness_group newfg;
1463 struct zspage *zspage;
1465 if (unlikely(!size || size > ZS_MAX_ALLOC_SIZE))
1466 return (unsigned long)ERR_PTR(-EINVAL);
1468 handle = cache_alloc_handle(pool, gfp);
1470 return (unsigned long)ERR_PTR(-ENOMEM);
1472 /* extra space in chunk to keep the handle */
1473 size += ZS_HANDLE_SIZE;
1474 class = pool->size_class[get_size_class_index(size)];
1476 /* pool->lock effectively protects the zpage migration */
1477 spin_lock(&pool->lock);
1478 zspage = find_get_zspage(class);
1479 if (likely(zspage)) {
1480 obj = obj_malloc(pool, zspage, handle);
1481 /* Now move the zspage to another fullness group, if required */
1482 fix_fullness_group(class, zspage);
1483 record_obj(handle, obj);
1484 class_stat_inc(class, OBJ_USED, 1);
1485 spin_unlock(&pool->lock);
1490 spin_unlock(&pool->lock);
1492 zspage = alloc_zspage(pool, class, gfp);
1494 cache_free_handle(pool, handle);
1495 return (unsigned long)ERR_PTR(-ENOMEM);
1498 spin_lock(&pool->lock);
1499 obj = obj_malloc(pool, zspage, handle);
1500 newfg = get_fullness_group(class, zspage);
1501 insert_zspage(class, zspage, newfg);
1502 set_zspage_mapping(zspage, class->index, newfg);
1503 record_obj(handle, obj);
1504 atomic_long_add(class->pages_per_zspage,
1505 &pool->pages_allocated);
1506 class_stat_inc(class, OBJ_ALLOCATED, class->objs_per_zspage);
1507 class_stat_inc(class, OBJ_USED, 1);
1509 /* We completely set up zspage so mark them as movable */
1510 SetZsPageMovable(pool, zspage);
1511 spin_unlock(&pool->lock);
1515 EXPORT_SYMBOL_GPL(zs_malloc);
1517 static void obj_free(int class_size, unsigned long obj)
1519 struct link_free *link;
1520 struct zspage *zspage;
1521 struct page *f_page;
1522 unsigned long f_offset;
1523 unsigned int f_objidx;
1526 obj_to_location(obj, &f_page, &f_objidx);
1527 f_offset = (class_size * f_objidx) & ~PAGE_MASK;
1528 zspage = get_zspage(f_page);
1530 vaddr = kmap_atomic(f_page);
1532 /* Insert this object in containing zspage's freelist */
1533 link = (struct link_free *)(vaddr + f_offset);
1534 if (likely(!ZsHugePage(zspage)))
1535 link->next = get_freeobj(zspage) << OBJ_TAG_BITS;
1538 kunmap_atomic(vaddr);
1539 set_freeobj(zspage, f_objidx);
1540 mod_zspage_inuse(zspage, -1);
1543 void zs_free(struct zs_pool *pool, unsigned long handle)
1545 struct zspage *zspage;
1546 struct page *f_page;
1548 struct size_class *class;
1549 enum fullness_group fullness;
1551 if (IS_ERR_OR_NULL((void *)handle))
1555 * The pool->lock protects the race with zpage's migration
1556 * so it's safe to get the page from handle.
1558 spin_lock(&pool->lock);
1559 obj = handle_to_obj(handle);
1560 obj_to_page(obj, &f_page);
1561 zspage = get_zspage(f_page);
1562 class = zspage_class(pool, zspage);
1564 obj_free(class->size, obj);
1565 class_stat_dec(class, OBJ_USED, 1);
1566 fullness = fix_fullness_group(class, zspage);
1567 if (fullness != ZS_EMPTY)
1570 free_zspage(pool, class, zspage);
1572 spin_unlock(&pool->lock);
1573 cache_free_handle(pool, handle);
1575 EXPORT_SYMBOL_GPL(zs_free);
1577 static void zs_object_copy(struct size_class *class, unsigned long dst,
1580 struct page *s_page, *d_page;
1581 unsigned int s_objidx, d_objidx;
1582 unsigned long s_off, d_off;
1583 void *s_addr, *d_addr;
1584 int s_size, d_size, size;
1587 s_size = d_size = class->size;
1589 obj_to_location(src, &s_page, &s_objidx);
1590 obj_to_location(dst, &d_page, &d_objidx);
1592 s_off = (class->size * s_objidx) & ~PAGE_MASK;
1593 d_off = (class->size * d_objidx) & ~PAGE_MASK;
1595 if (s_off + class->size > PAGE_SIZE)
1596 s_size = PAGE_SIZE - s_off;
1598 if (d_off + class->size > PAGE_SIZE)
1599 d_size = PAGE_SIZE - d_off;
1601 s_addr = kmap_atomic(s_page);
1602 d_addr = kmap_atomic(d_page);
1605 size = min(s_size, d_size);
1606 memcpy(d_addr + d_off, s_addr + s_off, size);
1609 if (written == class->size)
1618 * Calling kunmap_atomic(d_addr) is necessary. kunmap_atomic()
1619 * calls must occurs in reverse order of calls to kmap_atomic().
1620 * So, to call kunmap_atomic(s_addr) we should first call
1621 * kunmap_atomic(d_addr). For more details see
1622 * Documentation/mm/highmem.rst.
1624 if (s_off >= PAGE_SIZE) {
1625 kunmap_atomic(d_addr);
1626 kunmap_atomic(s_addr);
1627 s_page = get_next_page(s_page);
1628 s_addr = kmap_atomic(s_page);
1629 d_addr = kmap_atomic(d_page);
1630 s_size = class->size - written;
1634 if (d_off >= PAGE_SIZE) {
1635 kunmap_atomic(d_addr);
1636 d_page = get_next_page(d_page);
1637 d_addr = kmap_atomic(d_page);
1638 d_size = class->size - written;
1643 kunmap_atomic(d_addr);
1644 kunmap_atomic(s_addr);
1648 * Find alloced object in zspage from index object and
1651 static unsigned long find_alloced_obj(struct size_class *class,
1652 struct page *page, int *obj_idx)
1654 unsigned int offset;
1655 int index = *obj_idx;
1656 unsigned long handle = 0;
1657 void *addr = kmap_atomic(page);
1659 offset = get_first_obj_offset(page);
1660 offset += class->size * index;
1662 while (offset < PAGE_SIZE) {
1663 if (obj_allocated(page, addr + offset, &handle))
1666 offset += class->size;
1670 kunmap_atomic(addr);
1677 struct zs_compact_control {
1678 /* Source spage for migration which could be a subpage of zspage */
1679 struct page *s_page;
1680 /* Destination page for migration which should be a first page
1682 struct page *d_page;
1683 /* Starting object index within @s_page which used for live object
1684 * in the subpage. */
1688 static int migrate_zspage(struct zs_pool *pool, struct size_class *class,
1689 struct zs_compact_control *cc)
1691 unsigned long used_obj, free_obj;
1692 unsigned long handle;
1693 struct page *s_page = cc->s_page;
1694 struct page *d_page = cc->d_page;
1695 int obj_idx = cc->obj_idx;
1699 handle = find_alloced_obj(class, s_page, &obj_idx);
1701 s_page = get_next_page(s_page);
1708 /* Stop if there is no more space */
1709 if (zspage_full(class, get_zspage(d_page))) {
1714 used_obj = handle_to_obj(handle);
1715 free_obj = obj_malloc(pool, get_zspage(d_page), handle);
1716 zs_object_copy(class, free_obj, used_obj);
1718 record_obj(handle, free_obj);
1719 obj_free(class->size, used_obj);
1722 /* Remember last position in this iteration */
1723 cc->s_page = s_page;
1724 cc->obj_idx = obj_idx;
1729 static struct zspage *isolate_zspage(struct size_class *class, bool source)
1732 struct zspage *zspage;
1733 enum fullness_group fg[2] = {ZS_ALMOST_EMPTY, ZS_ALMOST_FULL};
1736 fg[0] = ZS_ALMOST_FULL;
1737 fg[1] = ZS_ALMOST_EMPTY;
1740 for (i = 0; i < 2; i++) {
1741 zspage = list_first_entry_or_null(&class->fullness_list[fg[i]],
1742 struct zspage, list);
1744 remove_zspage(class, zspage, fg[i]);
1753 * putback_zspage - add @zspage into right class's fullness list
1754 * @class: destination class
1755 * @zspage: target page
1757 * Return @zspage's fullness_group
1759 static enum fullness_group putback_zspage(struct size_class *class,
1760 struct zspage *zspage)
1762 enum fullness_group fullness;
1764 fullness = get_fullness_group(class, zspage);
1765 insert_zspage(class, zspage, fullness);
1766 set_zspage_mapping(zspage, class->index, fullness);
1771 #ifdef CONFIG_COMPACTION
1773 * To prevent zspage destroy during migration, zspage freeing should
1774 * hold locks of all pages in the zspage.
1776 static void lock_zspage(struct zspage *zspage)
1778 struct page *curr_page, *page;
1781 * Pages we haven't locked yet can be migrated off the list while we're
1782 * trying to lock them, so we need to be careful and only attempt to
1783 * lock each page under migrate_read_lock(). Otherwise, the page we lock
1784 * may no longer belong to the zspage. This means that we may wait for
1785 * the wrong page to unlock, so we must take a reference to the page
1786 * prior to waiting for it to unlock outside migrate_read_lock().
1789 migrate_read_lock(zspage);
1790 page = get_first_page(zspage);
1791 if (trylock_page(page))
1794 migrate_read_unlock(zspage);
1795 wait_on_page_locked(page);
1800 while ((page = get_next_page(curr_page))) {
1801 if (trylock_page(page)) {
1805 migrate_read_unlock(zspage);
1806 wait_on_page_locked(page);
1808 migrate_read_lock(zspage);
1811 migrate_read_unlock(zspage);
1814 static void migrate_lock_init(struct zspage *zspage)
1816 rwlock_init(&zspage->lock);
1819 static void migrate_read_lock(struct zspage *zspage) __acquires(&zspage->lock)
1821 read_lock(&zspage->lock);
1824 static void migrate_read_unlock(struct zspage *zspage) __releases(&zspage->lock)
1826 read_unlock(&zspage->lock);
1829 static void migrate_write_lock(struct zspage *zspage)
1831 write_lock(&zspage->lock);
1834 static void migrate_write_lock_nested(struct zspage *zspage)
1836 write_lock_nested(&zspage->lock, SINGLE_DEPTH_NESTING);
1839 static void migrate_write_unlock(struct zspage *zspage)
1841 write_unlock(&zspage->lock);
1844 /* Number of isolated subpage for *page migration* in this zspage */
1845 static void inc_zspage_isolation(struct zspage *zspage)
1850 static void dec_zspage_isolation(struct zspage *zspage)
1852 VM_BUG_ON(zspage->isolated == 0);
1856 static const struct movable_operations zsmalloc_mops;
1858 static void replace_sub_page(struct size_class *class, struct zspage *zspage,
1859 struct page *newpage, struct page *oldpage)
1862 struct page *pages[ZS_MAX_PAGES_PER_ZSPAGE] = {NULL, };
1865 page = get_first_page(zspage);
1867 if (page == oldpage)
1868 pages[idx] = newpage;
1872 } while ((page = get_next_page(page)) != NULL);
1874 create_page_chain(class, zspage, pages);
1875 set_first_obj_offset(newpage, get_first_obj_offset(oldpage));
1876 if (unlikely(ZsHugePage(zspage)))
1877 newpage->index = oldpage->index;
1878 __SetPageMovable(newpage, &zsmalloc_mops);
1881 static bool zs_page_isolate(struct page *page, isolate_mode_t mode)
1883 struct zspage *zspage;
1886 * Page is locked so zspage couldn't be destroyed. For detail, look at
1887 * lock_zspage in free_zspage.
1889 VM_BUG_ON_PAGE(!PageMovable(page), page);
1890 VM_BUG_ON_PAGE(PageIsolated(page), page);
1892 zspage = get_zspage(page);
1893 migrate_write_lock(zspage);
1894 inc_zspage_isolation(zspage);
1895 migrate_write_unlock(zspage);
1900 static int zs_page_migrate(struct page *newpage, struct page *page,
1901 enum migrate_mode mode)
1903 struct zs_pool *pool;
1904 struct size_class *class;
1905 struct zspage *zspage;
1907 void *s_addr, *d_addr, *addr;
1908 unsigned int offset;
1909 unsigned long handle;
1910 unsigned long old_obj, new_obj;
1911 unsigned int obj_idx;
1914 * We cannot support the _NO_COPY case here, because copy needs to
1915 * happen under the zs lock, which does not work with
1916 * MIGRATE_SYNC_NO_COPY workflow.
1918 if (mode == MIGRATE_SYNC_NO_COPY)
1921 VM_BUG_ON_PAGE(!PageMovable(page), page);
1922 VM_BUG_ON_PAGE(!PageIsolated(page), page);
1924 /* The page is locked, so this pointer must remain valid */
1925 zspage = get_zspage(page);
1926 pool = zspage->pool;
1929 * The pool's lock protects the race between zpage migration
1932 spin_lock(&pool->lock);
1933 class = zspage_class(pool, zspage);
1935 /* the migrate_write_lock protects zpage access via zs_map_object */
1936 migrate_write_lock(zspage);
1938 offset = get_first_obj_offset(page);
1939 s_addr = kmap_atomic(page);
1942 * Here, any user cannot access all objects in the zspage so let's move.
1944 d_addr = kmap_atomic(newpage);
1945 memcpy(d_addr, s_addr, PAGE_SIZE);
1946 kunmap_atomic(d_addr);
1948 for (addr = s_addr + offset; addr < s_addr + PAGE_SIZE;
1949 addr += class->size) {
1950 if (obj_allocated(page, addr, &handle)) {
1952 old_obj = handle_to_obj(handle);
1953 obj_to_location(old_obj, &dummy, &obj_idx);
1954 new_obj = (unsigned long)location_to_obj(newpage,
1956 record_obj(handle, new_obj);
1959 kunmap_atomic(s_addr);
1961 replace_sub_page(class, zspage, newpage, page);
1963 * Since we complete the data copy and set up new zspage structure,
1964 * it's okay to release the pool's lock.
1966 spin_unlock(&pool->lock);
1967 dec_zspage_isolation(zspage);
1968 migrate_write_unlock(zspage);
1971 if (page_zone(newpage) != page_zone(page)) {
1972 dec_zone_page_state(page, NR_ZSPAGES);
1973 inc_zone_page_state(newpage, NR_ZSPAGES);
1979 return MIGRATEPAGE_SUCCESS;
1982 static void zs_page_putback(struct page *page)
1984 struct zspage *zspage;
1986 VM_BUG_ON_PAGE(!PageMovable(page), page);
1987 VM_BUG_ON_PAGE(!PageIsolated(page), page);
1989 zspage = get_zspage(page);
1990 migrate_write_lock(zspage);
1991 dec_zspage_isolation(zspage);
1992 migrate_write_unlock(zspage);
1995 static const struct movable_operations zsmalloc_mops = {
1996 .isolate_page = zs_page_isolate,
1997 .migrate_page = zs_page_migrate,
1998 .putback_page = zs_page_putback,
2002 * Caller should hold page_lock of all pages in the zspage
2003 * In here, we cannot use zspage meta data.
2005 static void async_free_zspage(struct work_struct *work)
2008 struct size_class *class;
2009 unsigned int class_idx;
2010 enum fullness_group fullness;
2011 struct zspage *zspage, *tmp;
2012 LIST_HEAD(free_pages);
2013 struct zs_pool *pool = container_of(work, struct zs_pool,
2016 for (i = 0; i < ZS_SIZE_CLASSES; i++) {
2017 class = pool->size_class[i];
2018 if (class->index != i)
2021 spin_lock(&pool->lock);
2022 list_splice_init(&class->fullness_list[ZS_EMPTY], &free_pages);
2023 spin_unlock(&pool->lock);
2026 list_for_each_entry_safe(zspage, tmp, &free_pages, list) {
2027 list_del(&zspage->list);
2028 lock_zspage(zspage);
2030 get_zspage_mapping(zspage, &class_idx, &fullness);
2031 VM_BUG_ON(fullness != ZS_EMPTY);
2032 class = pool->size_class[class_idx];
2033 spin_lock(&pool->lock);
2035 list_del(&zspage->lru);
2037 __free_zspage(pool, class, zspage);
2038 spin_unlock(&pool->lock);
2042 static void kick_deferred_free(struct zs_pool *pool)
2044 schedule_work(&pool->free_work);
2047 static void zs_flush_migration(struct zs_pool *pool)
2049 flush_work(&pool->free_work);
2052 static void init_deferred_free(struct zs_pool *pool)
2054 INIT_WORK(&pool->free_work, async_free_zspage);
2057 static void SetZsPageMovable(struct zs_pool *pool, struct zspage *zspage)
2059 struct page *page = get_first_page(zspage);
2062 WARN_ON(!trylock_page(page));
2063 __SetPageMovable(page, &zsmalloc_mops);
2065 } while ((page = get_next_page(page)) != NULL);
2068 static inline void zs_flush_migration(struct zs_pool *pool) { }
2073 * Based on the number of unused allocated objects calculate
2074 * and return the number of pages that we can free.
2076 static unsigned long zs_can_compact(struct size_class *class)
2078 unsigned long obj_wasted;
2079 unsigned long obj_allocated = zs_stat_get(class, OBJ_ALLOCATED);
2080 unsigned long obj_used = zs_stat_get(class, OBJ_USED);
2082 if (obj_allocated <= obj_used)
2085 obj_wasted = obj_allocated - obj_used;
2086 obj_wasted /= class->objs_per_zspage;
2088 return obj_wasted * class->pages_per_zspage;
2091 static unsigned long __zs_compact(struct zs_pool *pool,
2092 struct size_class *class)
2094 struct zs_compact_control cc;
2095 struct zspage *src_zspage;
2096 struct zspage *dst_zspage = NULL;
2097 unsigned long pages_freed = 0;
2100 * protect the race between zpage migration and zs_free
2101 * as well as zpage allocation/free
2103 spin_lock(&pool->lock);
2104 while ((src_zspage = isolate_zspage(class, true))) {
2105 /* protect someone accessing the zspage(i.e., zs_map_object) */
2106 migrate_write_lock(src_zspage);
2108 if (!zs_can_compact(class))
2112 cc.s_page = get_first_page(src_zspage);
2114 while ((dst_zspage = isolate_zspage(class, false))) {
2115 migrate_write_lock_nested(dst_zspage);
2117 cc.d_page = get_first_page(dst_zspage);
2119 * If there is no more space in dst_page, resched
2120 * and see if anyone had allocated another zspage.
2122 if (!migrate_zspage(pool, class, &cc))
2125 putback_zspage(class, dst_zspage);
2126 migrate_write_unlock(dst_zspage);
2128 if (spin_is_contended(&pool->lock))
2132 /* Stop if we couldn't find slot */
2133 if (dst_zspage == NULL)
2136 putback_zspage(class, dst_zspage);
2137 migrate_write_unlock(dst_zspage);
2139 if (putback_zspage(class, src_zspage) == ZS_EMPTY) {
2140 migrate_write_unlock(src_zspage);
2141 free_zspage(pool, class, src_zspage);
2142 pages_freed += class->pages_per_zspage;
2144 migrate_write_unlock(src_zspage);
2145 spin_unlock(&pool->lock);
2147 spin_lock(&pool->lock);
2151 putback_zspage(class, src_zspage);
2152 migrate_write_unlock(src_zspage);
2155 spin_unlock(&pool->lock);
2160 unsigned long zs_compact(struct zs_pool *pool)
2163 struct size_class *class;
2164 unsigned long pages_freed = 0;
2166 for (i = ZS_SIZE_CLASSES - 1; i >= 0; i--) {
2167 class = pool->size_class[i];
2168 if (class->index != i)
2170 pages_freed += __zs_compact(pool, class);
2172 atomic_long_add(pages_freed, &pool->stats.pages_compacted);
2176 EXPORT_SYMBOL_GPL(zs_compact);
2178 void zs_pool_stats(struct zs_pool *pool, struct zs_pool_stats *stats)
2180 memcpy(stats, &pool->stats, sizeof(struct zs_pool_stats));
2182 EXPORT_SYMBOL_GPL(zs_pool_stats);
2184 static unsigned long zs_shrinker_scan(struct shrinker *shrinker,
2185 struct shrink_control *sc)
2187 unsigned long pages_freed;
2188 struct zs_pool *pool = container_of(shrinker, struct zs_pool,
2192 * Compact classes and calculate compaction delta.
2193 * Can run concurrently with a manually triggered
2194 * (by user) compaction.
2196 pages_freed = zs_compact(pool);
2198 return pages_freed ? pages_freed : SHRINK_STOP;
2201 static unsigned long zs_shrinker_count(struct shrinker *shrinker,
2202 struct shrink_control *sc)
2205 struct size_class *class;
2206 unsigned long pages_to_free = 0;
2207 struct zs_pool *pool = container_of(shrinker, struct zs_pool,
2210 for (i = ZS_SIZE_CLASSES - 1; i >= 0; i--) {
2211 class = pool->size_class[i];
2212 if (class->index != i)
2215 pages_to_free += zs_can_compact(class);
2218 return pages_to_free;
2221 static void zs_unregister_shrinker(struct zs_pool *pool)
2223 unregister_shrinker(&pool->shrinker);
2226 static int zs_register_shrinker(struct zs_pool *pool)
2228 pool->shrinker.scan_objects = zs_shrinker_scan;
2229 pool->shrinker.count_objects = zs_shrinker_count;
2230 pool->shrinker.batch = 0;
2231 pool->shrinker.seeks = DEFAULT_SEEKS;
2233 return register_shrinker(&pool->shrinker, "mm-zspool:%s",
2238 * zs_create_pool - Creates an allocation pool to work from.
2239 * @name: pool name to be created
2241 * This function must be called before anything when using
2242 * the zsmalloc allocator.
2244 * On success, a pointer to the newly created pool is returned,
2247 struct zs_pool *zs_create_pool(const char *name)
2250 struct zs_pool *pool;
2251 struct size_class *prev_class = NULL;
2253 pool = kzalloc(sizeof(*pool), GFP_KERNEL);
2257 init_deferred_free(pool);
2258 spin_lock_init(&pool->lock);
2260 pool->name = kstrdup(name, GFP_KERNEL);
2264 if (create_cache(pool))
2268 * Iterate reversely, because, size of size_class that we want to use
2269 * for merging should be larger or equal to current size.
2271 for (i = ZS_SIZE_CLASSES - 1; i >= 0; i--) {
2273 int pages_per_zspage;
2274 int objs_per_zspage;
2275 struct size_class *class;
2278 size = ZS_MIN_ALLOC_SIZE + i * ZS_SIZE_CLASS_DELTA;
2279 if (size > ZS_MAX_ALLOC_SIZE)
2280 size = ZS_MAX_ALLOC_SIZE;
2281 pages_per_zspage = get_pages_per_zspage(size);
2282 objs_per_zspage = pages_per_zspage * PAGE_SIZE / size;
2285 * We iterate from biggest down to smallest classes,
2286 * so huge_class_size holds the size of the first huge
2287 * class. Any object bigger than or equal to that will
2288 * endup in the huge class.
2290 if (pages_per_zspage != 1 && objs_per_zspage != 1 &&
2292 huge_class_size = size;
2294 * The object uses ZS_HANDLE_SIZE bytes to store the
2295 * handle. We need to subtract it, because zs_malloc()
2296 * unconditionally adds handle size before it performs
2297 * size class search - so object may be smaller than
2298 * huge class size, yet it still can end up in the huge
2299 * class because it grows by ZS_HANDLE_SIZE extra bytes
2300 * right before class lookup.
2302 huge_class_size -= (ZS_HANDLE_SIZE - 1);
2306 * size_class is used for normal zsmalloc operation such
2307 * as alloc/free for that size. Although it is natural that we
2308 * have one size_class for each size, there is a chance that we
2309 * can get more memory utilization if we use one size_class for
2310 * many different sizes whose size_class have same
2311 * characteristics. So, we makes size_class point to
2312 * previous size_class if possible.
2315 if (can_merge(prev_class, pages_per_zspage, objs_per_zspage)) {
2316 pool->size_class[i] = prev_class;
2321 class = kzalloc(sizeof(struct size_class), GFP_KERNEL);
2327 class->pages_per_zspage = pages_per_zspage;
2328 class->objs_per_zspage = objs_per_zspage;
2329 pool->size_class[i] = class;
2330 for (fullness = ZS_EMPTY; fullness < NR_ZS_FULLNESS;
2332 INIT_LIST_HEAD(&class->fullness_list[fullness]);
2337 /* debug only, don't abort if it fails */
2338 zs_pool_stat_create(pool, name);
2341 * Not critical since shrinker is only used to trigger internal
2342 * defragmentation of the pool which is pretty optional thing. If
2343 * registration fails we still can use the pool normally and user can
2344 * trigger compaction manually. Thus, ignore return code.
2346 zs_register_shrinker(pool);
2349 INIT_LIST_HEAD(&pool->lru);
2355 zs_destroy_pool(pool);
2358 EXPORT_SYMBOL_GPL(zs_create_pool);
2360 void zs_destroy_pool(struct zs_pool *pool)
2364 zs_unregister_shrinker(pool);
2365 zs_flush_migration(pool);
2366 zs_pool_stat_destroy(pool);
2368 for (i = 0; i < ZS_SIZE_CLASSES; i++) {
2370 struct size_class *class = pool->size_class[i];
2375 if (class->index != i)
2378 for (fg = ZS_EMPTY; fg < NR_ZS_FULLNESS; fg++) {
2379 if (!list_empty(&class->fullness_list[fg])) {
2380 pr_info("Freeing non-empty class with size %db, fullness group %d\n",
2387 destroy_cache(pool);
2391 EXPORT_SYMBOL_GPL(zs_destroy_pool);
2393 static int __init zs_init(void)
2397 ret = cpuhp_setup_state(CPUHP_MM_ZS_PREPARE, "mm/zsmalloc:prepare",
2398 zs_cpu_prepare, zs_cpu_dead);
2403 zpool_register_driver(&zs_zpool_driver);
2414 static void __exit zs_exit(void)
2417 zpool_unregister_driver(&zs_zpool_driver);
2419 cpuhp_remove_state(CPUHP_MM_ZS_PREPARE);
2424 module_init(zs_init);
2425 module_exit(zs_exit);
2427 MODULE_LICENSE("Dual BSD/GPL");
2428 MODULE_AUTHOR("Nitin Gupta <ngupta@vflare.org>");