mm/z3fold.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * z3fold.c
   4  *
   5  * Author: Vitaly Wool <vitaly.wool@konsulko.com>
   6  * Copyright (C) 2016, Sony Mobile Communications Inc.
   7  *
   8  * This implementation is based on zbud written by Seth Jennings.
   9  *
  10  * z3fold is an special purpose allocator for storing compressed pages. It
  11  * can store up to three compressed pages per page which improves the
  12  * compression ratio of zbud while retaining its main concepts (e. g. always
  13  * storing an integral number of objects per page) and simplicity.
  14  * It still has simple and deterministic reclaim properties that make it
  15  * preferable to a higher density approach (with no requirement on integral
  16  * number of object per page) when reclaim is used.
  17  *
  18  * As in zbud, pages are divided into "chunks".  The size of the chunks is
  19  * fixed at compile time and is determined by NCHUNKS_ORDER below.
  20  *
  21  * z3fold doesn't export any API and is meant to be used via zpool API.
  22  */
  23
  24 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  25
  26 #include <linux/atomic.h>
  27 #include <linux/sched.h>
  28 #include <linux/cpumask.h>
  29 #include <linux/list.h>
  30 #include <linux/mm.h>
  31 #include <linux/module.h>
  32 #include <linux/page-flags.h>
  33 #include <linux/migrate.h>
  34 #include <linux/node.h>
  35 #include <linux/compaction.h>
  36 #include <linux/percpu.h>
  37 #include <linux/mount.h>
  38 #include <linux/pseudo_fs.h>
  39 #include <linux/fs.h>
  40 #include <linux/preempt.h>
  41 #include <linux/workqueue.h>
  42 #include <linux/slab.h>
  43 #include <linux/spinlock.h>
  44 #include <linux/wait.h>
  45 #include <linux/zpool.h>
  46 #include <linux/magic.h>
  47
  48 /*
  49  * NCHUNKS_ORDER determines the internal allocation granularity, effectively
  50  * adjusting internal fragmentation.  It also determines the number of
  51  * freelists maintained in each pool. NCHUNKS_ORDER of 6 means that the
  52  * allocation granularity will be in chunks of size PAGE_SIZE/64. Some chunks
  53  * in the beginning of an allocated page are occupied by z3fold header, so
  54  * NCHUNKS will be calculated to 63 (or 62 in case CONFIG_DEBUG_SPINLOCK=y),
  55  * which shows the max number of free chunks in z3fold page, also there will
  56  * be 63, or 62, respectively, freelists per pool.
  57  */
  58 #define NCHUNKS_ORDER   6
  59
  60 #define CHUNK_SHIFT     (PAGE_SHIFT - NCHUNKS_ORDER)
  61 #define CHUNK_SIZE      (1 << CHUNK_SHIFT)
  62 #define ZHDR_SIZE_ALIGNED round_up(sizeof(struct z3fold_header), CHUNK_SIZE)
  63 #define ZHDR_CHUNKS     (ZHDR_SIZE_ALIGNED >> CHUNK_SHIFT)
  64 #define TOTAL_CHUNKS    (PAGE_SIZE >> CHUNK_SHIFT)
  65 #define NCHUNKS         ((PAGE_SIZE - ZHDR_SIZE_ALIGNED) >> CHUNK_SHIFT)
  66
  67 #define BUDDY_MASK      (0x3)
  68 #define BUDDY_SHIFT     2
  69 #define SLOTS_ALIGN     (0x40)
  70
  71 /*****************
  72  * Structures
  73 *****************/
  74 struct z3fold_pool;
  75 struct z3fold_ops {
  76         int (*evict)(struct z3fold_pool *pool, unsigned long handle);
  77 };
  78
  79 enum buddy {
  80         HEADLESS = 0,
  81         FIRST,
  82         MIDDLE,
  83         LAST,
  84         BUDDIES_MAX = LAST
  85 };
  86
  87 struct z3fold_buddy_slots {
  88         /*
  89          * we are using BUDDY_MASK in handle_to_buddy etc. so there should
  90          * be enough slots to hold all possible variants
  91          */
  92         unsigned long slot[BUDDY_MASK + 1];
  93         unsigned long pool; /* back link + flags */
  94 };
  95 #define HANDLE_FLAG_MASK        (0x03)
  96
  97 /*
  98  * struct z3fold_header - z3fold page metadata occupying first chunks of each
  99  *                      z3fold page, except for HEADLESS pages
 100  * @buddy:              links the z3fold page into the relevant list in the
 101  *                      pool
 102  * @page_lock:          per-page lock
 103  * @refcount:           reference count for the z3fold page
 104  * @work:               work_struct for page layout optimization
 105  * @slots:              pointer to the structure holding buddy slots
 106  * @pool:               pointer to the containing pool
 107  * @cpu:                CPU which this page "belongs" to
 108  * @first_chunks:       the size of the first buddy in chunks, 0 if free
 109  * @middle_chunks:      the size of the middle buddy in chunks, 0 if free
 110  * @last_chunks:        the size of the last buddy in chunks, 0 if free
 111  * @first_num:          the starting number (for the first handle)
 112  * @mapped_count:       the number of objects currently mapped
 113  */
 114 struct z3fold_header {
 115         struct list_head buddy;
 116         spinlock_t page_lock;
 117         struct kref refcount;
 118         struct work_struct work;
 119         struct z3fold_buddy_slots *slots;
 120         struct z3fold_pool *pool;
 121         short cpu;
 122         unsigned short first_chunks;
 123         unsigned short middle_chunks;
 124         unsigned short last_chunks;
 125         unsigned short start_middle;
 126         unsigned short first_num:2;
 127         unsigned short mapped_count:2;
 128 };
 129
 130 /**
 131  * struct z3fold_pool - stores metadata for each z3fold pool
 132  * @name:       pool name
 133  * @lock:       protects pool unbuddied/lru lists
 134  * @stale_lock: protects pool stale page list
 135  * @unbuddied:  per-cpu array of lists tracking z3fold pages that contain 2-
 136  *              buddies; the list each z3fold page is added to depends on
 137  *              the size of its free region.
 138  * @lru:        list tracking the z3fold pages in LRU order by most recently
 139  *              added buddy.
 140  * @stale:      list of pages marked for freeing
 141  * @pages_nr:   number of z3fold pages in the pool.
 142  * @c_handle:   cache for z3fold_buddy_slots allocation
 143  * @ops:        pointer to a structure of user defined operations specified at
 144  *              pool creation time.
 145  * @compact_wq: workqueue for page layout background optimization
 146  * @release_wq: workqueue for safe page release
 147  * @work:       work_struct for safe page release
 148  * @inode:      inode for z3fold pseudo filesystem
 149  * @destroying: bool to stop migration once we start destruction
 150  * @isolated: int to count the number of pages currently in isolation
 151  *
 152  * This structure is allocated at pool creation time and maintains metadata
 153  * pertaining to a particular z3fold pool.
 154  */
 155 struct z3fold_pool {
 156         const char *name;
 157         spinlock_t lock;
 158         spinlock_t stale_lock;
 159         struct list_head *unbuddied;
 160         struct list_head lru;
 161         struct list_head stale;
 162         atomic64_t pages_nr;
 163         struct kmem_cache *c_handle;
 164         const struct z3fold_ops *ops;
 165         struct zpool *zpool;
 166         const struct zpool_ops *zpool_ops;
 167         struct workqueue_struct *compact_wq;
 168         struct workqueue_struct *release_wq;
 169         struct wait_queue_head isolate_wait;
 170         struct work_struct work;
 171         struct inode *inode;
 172         bool destroying;
 173         int isolated;
 174 };
 175
 176 /*
 177  * Internal z3fold page flags
 178  */
 179 enum z3fold_page_flags {
 180         PAGE_HEADLESS = 0,
 181         MIDDLE_CHUNK_MAPPED,
 182         NEEDS_COMPACTING,
 183         PAGE_STALE,
 184         PAGE_CLAIMED, /* by either reclaim or free */
 185 };
 186
 187 /*****************
 188  * Helpers
 189 *****************/
 190
 191 /* Converts an allocation size in bytes to size in z3fold chunks */
 192 static int size_to_chunks(size_t size)
 193 {
 194         return (size + CHUNK_SIZE - 1) >> CHUNK_SHIFT;
 195 }
 196
 197 #define for_each_unbuddied_list(_iter, _begin) \
 198         for ((_iter) = (_begin); (_iter) < NCHUNKS; (_iter)++)
 199
 200 static void compact_page_work(struct work_struct *w);
 201
 202 static inline struct z3fold_buddy_slots *alloc_slots(struct z3fold_pool *pool,
 203                                                         gfp_t gfp)
 204 {
 205         struct z3fold_buddy_slots *slots;
 206
 207         slots = kmem_cache_alloc(pool->c_handle,
 208                                  (gfp & ~(__GFP_HIGHMEM | __GFP_MOVABLE)));
 209
 210         if (slots) {
 211                 memset(slots->slot, 0, sizeof(slots->slot));
 212                 slots->pool = (unsigned long)pool;
 213         }
 214
 215         return slots;
 216 }
 217
 218 static inline struct z3fold_pool *slots_to_pool(struct z3fold_buddy_slots *s)
 219 {
 220         return (struct z3fold_pool *)(s->pool & ~HANDLE_FLAG_MASK);
 221 }
 222
 223 static inline struct z3fold_buddy_slots *handle_to_slots(unsigned long handle)
 224 {
 225         return (struct z3fold_buddy_slots *)(handle & ~(SLOTS_ALIGN - 1));
 226 }
 227
 228 static inline void free_handle(unsigned long handle)
 229 {
 230         struct z3fold_buddy_slots *slots;
 231         int i;
 232         bool is_free;
 233
 234         if (handle & (1 << PAGE_HEADLESS))
 235                 return;
 236
 237         WARN_ON(*(unsigned long *)handle == 0);
 238         *(unsigned long *)handle = 0;
 239         slots = handle_to_slots(handle);
 240         is_free = true;
 241         for (i = 0; i <= BUDDY_MASK; i++) {
 242                 if (slots->slot[i]) {
 243                         is_free = false;
 244                         break;
 245                 }
 246         }
 247
 248         if (is_free) {
 249                 struct z3fold_pool *pool = slots_to_pool(slots);
 250
 251                 kmem_cache_free(pool->c_handle, slots);
 252         }
 253 }
 254
 255 static int z3fold_init_fs_context(struct fs_context *fc)
 256 {
 257         return init_pseudo(fc, Z3FOLD_MAGIC) ? 0 : -ENOMEM;
 258 }
 259
 260 static struct file_system_type z3fold_fs = {
 261         .name           = "z3fold",
 262         .init_fs_context = z3fold_init_fs_context,
 263         .kill_sb        = kill_anon_super,
 264 };
 265
 266 static struct vfsmount *z3fold_mnt;
 267 static int z3fold_mount(void)
 268 {
 269         int ret = 0;
 270
 271         z3fold_mnt = kern_mount(&z3fold_fs);
 272         if (IS_ERR(z3fold_mnt))
 273                 ret = PTR_ERR(z3fold_mnt);
 274
 275         return ret;
 276 }
 277
 278 static void z3fold_unmount(void)
 279 {
 280         kern_unmount(z3fold_mnt);
 281 }
 282
 283 static const struct address_space_operations z3fold_aops;
 284 static int z3fold_register_migration(struct z3fold_pool *pool)
 285 {
 286         pool->inode = alloc_anon_inode(z3fold_mnt->mnt_sb);
 287         if (IS_ERR(pool->inode)) {
 288                 pool->inode = NULL;
 289                 return 1;
 290         }
 291
 292         pool->inode->i_mapping->private_data = pool;
 293         pool->inode->i_mapping->a_ops = &z3fold_aops;
 294         return 0;
 295 }
 296
 297 static void z3fold_unregister_migration(struct z3fold_pool *pool)
 298 {
 299         if (pool->inode)
 300                 iput(pool->inode);
 301  }
 302
 303 /* Initializes the z3fold header of a newly allocated z3fold page */
 304 static struct z3fold_header *init_z3fold_page(struct page *page,
 305                                         struct z3fold_pool *pool, gfp_t gfp)
 306 {
 307         struct z3fold_header *zhdr = page_address(page);
 308         struct z3fold_buddy_slots *slots = alloc_slots(pool, gfp);
 309
 310         if (!slots)
 311                 return NULL;
 312
 313         INIT_LIST_HEAD(&page->lru);
 314         clear_bit(PAGE_HEADLESS, &page->private);
 315         clear_bit(MIDDLE_CHUNK_MAPPED, &page->private);
 316         clear_bit(NEEDS_COMPACTING, &page->private);
 317         clear_bit(PAGE_STALE, &page->private);
 318         clear_bit(PAGE_CLAIMED, &page->private);
 319
 320         spin_lock_init(&zhdr->page_lock);
 321         kref_init(&zhdr->refcount);
 322         zhdr->first_chunks = 0;
 323         zhdr->middle_chunks = 0;
 324         zhdr->last_chunks = 0;
 325         zhdr->first_num = 0;
 326         zhdr->start_middle = 0;
 327         zhdr->cpu = -1;
 328         zhdr->slots = slots;
 329         zhdr->pool = pool;
 330         INIT_LIST_HEAD(&zhdr->buddy);
 331         INIT_WORK(&zhdr->work, compact_page_work);
 332         return zhdr;
 333 }
 334
 335 /* Resets the struct page fields and frees the page */
 336 static void free_z3fold_page(struct page *page, bool headless)
 337 {
 338         if (!headless) {
 339                 lock_page(page);
 340                 __ClearPageMovable(page);
 341                 unlock_page(page);
 342         }
 343         ClearPagePrivate(page);
 344         __free_page(page);
 345 }
 346
 347 /* Lock a z3fold page */
 348 static inline void z3fold_page_lock(struct z3fold_header *zhdr)
 349 {
 350         spin_lock(&zhdr->page_lock);
 351 }
 352
 353 /* Try to lock a z3fold page */
 354 static inline int z3fold_page_trylock(struct z3fold_header *zhdr)
 355 {
 356         return spin_trylock(&zhdr->page_lock);
 357 }
 358
 359 /* Unlock a z3fold page */
 360 static inline void z3fold_page_unlock(struct z3fold_header *zhdr)
 361 {
 362         spin_unlock(&zhdr->page_lock);
 363 }
 364
 365 /* Helper function to build the index */
 366 static inline int __idx(struct z3fold_header *zhdr, enum buddy bud)
 367 {
 368         return (bud + zhdr->first_num) & BUDDY_MASK;
 369 }
 370
 371 /*
 372  * Encodes the handle of a particular buddy within a z3fold page
 373  * Pool lock should be held as this function accesses first_num
 374  */
 375 static unsigned long encode_handle(struct z3fold_header *zhdr, enum buddy bud)
 376 {
 377         struct z3fold_buddy_slots *slots;
 378         unsigned long h = (unsigned long)zhdr;
 379         int idx = 0;
 380
 381         /*
 382          * For a headless page, its handle is its pointer with the extra
 383          * PAGE_HEADLESS bit set
 384          */
 385         if (bud == HEADLESS)
 386                 return h | (1 << PAGE_HEADLESS);
 387
 388         /* otherwise, return pointer to encoded handle */
 389         idx = __idx(zhdr, bud);
 390         h += idx;
 391         if (bud == LAST)
 392                 h |= (zhdr->last_chunks << BUDDY_SHIFT);
 393
 394         slots = zhdr->slots;
 395         slots->slot[idx] = h;
 396         return (unsigned long)&slots->slot[idx];
 397 }
 398
 399 /* Returns the z3fold page where a given handle is stored */
 400 static inline struct z3fold_header *handle_to_z3fold_header(unsigned long h)
 401 {
 402         unsigned long addr = h;
 403
 404         if (!(addr & (1 << PAGE_HEADLESS)))
 405                 addr = *(unsigned long *)h;
 406
 407         return (struct z3fold_header *)(addr & PAGE_MASK);
 408 }
 409
 410 /* only for LAST bud, returns zero otherwise */
 411 static unsigned short handle_to_chunks(unsigned long handle)
 412 {
 413         unsigned long addr = *(unsigned long *)handle;
 414
 415         return (addr & ~PAGE_MASK) >> BUDDY_SHIFT;
 416 }
 417
 418 /*
 419  * (handle & BUDDY_MASK) < zhdr->first_num is possible in encode_handle
 420  *  but that doesn't matter. because the masking will result in the
 421  *  correct buddy number.
 422  */
 423 static enum buddy handle_to_buddy(unsigned long handle)
 424 {
 425         struct z3fold_header *zhdr;
 426         unsigned long addr;
 427
 428         WARN_ON(handle & (1 << PAGE_HEADLESS));
 429         addr = *(unsigned long *)handle;
 430         zhdr = (struct z3fold_header *)(addr & PAGE_MASK);
 431         return (addr - zhdr->first_num) & BUDDY_MASK;
 432 }
 433
 434 static inline struct z3fold_pool *zhdr_to_pool(struct z3fold_header *zhdr)
 435 {
 436         return zhdr->pool;
 437 }
 438
 439 static void __release_z3fold_page(struct z3fold_header *zhdr, bool locked)
 440 {
 441         struct page *page = virt_to_page(zhdr);
 442         struct z3fold_pool *pool = zhdr_to_pool(zhdr);
 443
 444         WARN_ON(!list_empty(&zhdr->buddy));
 445         set_bit(PAGE_STALE, &page->private);
 446         clear_bit(NEEDS_COMPACTING, &page->private);
 447         spin_lock(&pool->lock);
 448         if (!list_empty(&page->lru))
 449                 list_del_init(&page->lru);
 450         spin_unlock(&pool->lock);
 451         if (locked)
 452                 z3fold_page_unlock(zhdr);
 453         spin_lock(&pool->stale_lock);
 454         list_add(&zhdr->buddy, &pool->stale);
 455         queue_work(pool->release_wq, &pool->work);
 456         spin_unlock(&pool->stale_lock);
 457 }
 458
 459 static void __attribute__((__unused__))
 460                         release_z3fold_page(struct kref *ref)
 461 {
 462         struct z3fold_header *zhdr = container_of(ref, struct z3fold_header,
 463                                                 refcount);
 464         __release_z3fold_page(zhdr, false);
 465 }
 466
 467 static void release_z3fold_page_locked(struct kref *ref)
 468 {
 469         struct z3fold_header *zhdr = container_of(ref, struct z3fold_header,
 470                                                 refcount);
 471         WARN_ON(z3fold_page_trylock(zhdr));
 472         __release_z3fold_page(zhdr, true);
 473 }
 474
 475 static void release_z3fold_page_locked_list(struct kref *ref)
 476 {
 477         struct z3fold_header *zhdr = container_of(ref, struct z3fold_header,
 478                                                refcount);
 479         struct z3fold_pool *pool = zhdr_to_pool(zhdr);
 480         spin_lock(&pool->lock);
 481         list_del_init(&zhdr->buddy);
 482         spin_unlock(&pool->lock);
 483
 484         WARN_ON(z3fold_page_trylock(zhdr));
 485         __release_z3fold_page(zhdr, true);
 486 }
 487
 488 static void free_pages_work(struct work_struct *w)
 489 {
 490         struct z3fold_pool *pool = container_of(w, struct z3fold_pool, work);
 491
 492         spin_lock(&pool->stale_lock);
 493         while (!list_empty(&pool->stale)) {
 494                 struct z3fold_header *zhdr = list_first_entry(&pool->stale,
 495                                                 struct z3fold_header, buddy);
 496                 struct page *page = virt_to_page(zhdr);
 497
 498                 list_del(&zhdr->buddy);
 499                 if (WARN_ON(!test_bit(PAGE_STALE, &page->private)))
 500                         continue;
 501                 spin_unlock(&pool->stale_lock);
 502                 cancel_work_sync(&zhdr->work);
 503                 free_z3fold_page(page, false);
 504                 cond_resched();
 505                 spin_lock(&pool->stale_lock);
 506         }
 507         spin_unlock(&pool->stale_lock);
 508 }
 509
 510 /*
 511  * Returns the number of free chunks in a z3fold page.
 512  * NB: can't be used with HEADLESS pages.
 513  */
 514 static int num_free_chunks(struct z3fold_header *zhdr)
 515 {
 516         int nfree;
 517         /*
 518          * If there is a middle object, pick up the bigger free space
 519          * either before or after it. Otherwise just subtract the number
 520          * of chunks occupied by the first and the last objects.
 521          */
 522         if (zhdr->middle_chunks != 0) {
 523                 int nfree_before = zhdr->first_chunks ?
 524                         0 : zhdr->start_middle - ZHDR_CHUNKS;
 525                 int nfree_after = zhdr->last_chunks ?
 526                         0 : TOTAL_CHUNKS -
 527                                 (zhdr->start_middle + zhdr->middle_chunks);
 528                 nfree = max(nfree_before, nfree_after);
 529         } else
 530                 nfree = NCHUNKS - zhdr->first_chunks - zhdr->last_chunks;
 531         return nfree;
 532 }
 533
 534 /* Add to the appropriate unbuddied list */
 535 static inline void add_to_unbuddied(struct z3fold_pool *pool,
 536                                 struct z3fold_header *zhdr)
 537 {
 538         if (zhdr->first_chunks == 0 || zhdr->last_chunks == 0 ||
 539                         zhdr->middle_chunks == 0) {
 540                 struct list_head *unbuddied = get_cpu_ptr(pool->unbuddied);
 541
 542                 int freechunks = num_free_chunks(zhdr);
 543                 spin_lock(&pool->lock);
 544                 list_add(&zhdr->buddy, &unbuddied[freechunks]);
 545                 spin_unlock(&pool->lock);
 546                 zhdr->cpu = smp_processor_id();
 547                 put_cpu_ptr(pool->unbuddied);
 548         }
 549 }
 550
 551 static inline void *mchunk_memmove(struct z3fold_header *zhdr,
 552                                 unsigned short dst_chunk)
 553 {
 554         void *beg = zhdr;
 555         return memmove(beg + (dst_chunk << CHUNK_SHIFT),
 556                        beg + (zhdr->start_middle << CHUNK_SHIFT),
 557                        zhdr->middle_chunks << CHUNK_SHIFT);
 558 }
 559
 560 #define BIG_CHUNK_GAP   3
 561 /* Has to be called with lock held */
 562 static int z3fold_compact_page(struct z3fold_header *zhdr)
 563 {
 564         struct page *page = virt_to_page(zhdr);
 565
 566         if (test_bit(MIDDLE_CHUNK_MAPPED, &page->private))
 567                 return 0; /* can't move middle chunk, it's used */
 568
 569         if (unlikely(PageIsolated(page)))
 570                 return 0;
 571
 572         if (zhdr->middle_chunks == 0)
 573                 return 0; /* nothing to compact */
 574
 575         if (zhdr->first_chunks == 0 && zhdr->last_chunks == 0) {
 576                 /* move to the beginning */
 577                 mchunk_memmove(zhdr, ZHDR_CHUNKS);
 578                 zhdr->first_chunks = zhdr->middle_chunks;
 579                 zhdr->middle_chunks = 0;
 580                 zhdr->start_middle = 0;
 581                 zhdr->first_num++;
 582                 return 1;
 583         }
 584
 585         /*
 586          * moving data is expensive, so let's only do that if
 587          * there's substantial gain (at least BIG_CHUNK_GAP chunks)
 588          */
 589         if (zhdr->first_chunks != 0 && zhdr->last_chunks == 0 &&
 590             zhdr->start_middle - (zhdr->first_chunks + ZHDR_CHUNKS) >=
 591                         BIG_CHUNK_GAP) {
 592                 mchunk_memmove(zhdr, zhdr->first_chunks + ZHDR_CHUNKS);
 593                 zhdr->start_middle = zhdr->first_chunks + ZHDR_CHUNKS;
 594                 return 1;
 595         } else if (zhdr->last_chunks != 0 && zhdr->first_chunks == 0 &&
 596                    TOTAL_CHUNKS - (zhdr->last_chunks + zhdr->start_middle
 597                                         + zhdr->middle_chunks) >=
 598                         BIG_CHUNK_GAP) {
 599                 unsigned short new_start = TOTAL_CHUNKS - zhdr->last_chunks -
 600                         zhdr->middle_chunks;
 601                 mchunk_memmove(zhdr, new_start);
 602                 zhdr->start_middle = new_start;
 603                 return 1;
 604         }
 605
 606         return 0;
 607 }
 608
 609 static void do_compact_page(struct z3fold_header *zhdr, bool locked)
 610 {
 611         struct z3fold_pool *pool = zhdr_to_pool(zhdr);
 612         struct page *page;
 613
 614         page = virt_to_page(zhdr);
 615         if (locked)
 616                 WARN_ON(z3fold_page_trylock(zhdr));
 617         else
 618                 z3fold_page_lock(zhdr);
 619         if (WARN_ON(!test_and_clear_bit(NEEDS_COMPACTING, &page->private))) {
 620                 z3fold_page_unlock(zhdr);
 621                 return;
 622         }
 623         spin_lock(&pool->lock);
 624         list_del_init(&zhdr->buddy);
 625         spin_unlock(&pool->lock);
 626
 627         if (kref_put(&zhdr->refcount, release_z3fold_page_locked)) {
 628                 atomic64_dec(&pool->pages_nr);
 629                 return;
 630         }
 631
 632         if (unlikely(PageIsolated(page) ||
 633                      test_bit(PAGE_STALE, &page->private))) {
 634                 z3fold_page_unlock(zhdr);
 635                 return;
 636         }
 637
 638         z3fold_compact_page(zhdr);
 639         add_to_unbuddied(pool, zhdr);
 640         z3fold_page_unlock(zhdr);
 641 }
 642
 643 static void compact_page_work(struct work_struct *w)
 644 {
 645         struct z3fold_header *zhdr = container_of(w, struct z3fold_header,
 646                                                 work);
 647
 648         do_compact_page(zhdr, false);
 649 }
 650
 651 /* returns _locked_ z3fold page header or NULL */
 652 static inline struct z3fold_header *__z3fold_alloc(struct z3fold_pool *pool,
 653                                                 size_t size, bool can_sleep)
 654 {
 655         struct z3fold_header *zhdr = NULL;
 656         struct page *page;
 657         struct list_head *unbuddied;
 658         int chunks = size_to_chunks(size), i;
 659
 660 lookup:
 661         /* First, try to find an unbuddied z3fold page. */
 662         unbuddied = get_cpu_ptr(pool->unbuddied);
 663         for_each_unbuddied_list(i, chunks) {
 664                 struct list_head *l = &unbuddied[i];
 665
 666                 zhdr = list_first_entry_or_null(READ_ONCE(l),
 667                                         struct z3fold_header, buddy);
 668
 669                 if (!zhdr)
 670                         continue;
 671
 672                 /* Re-check under lock. */
 673                 spin_lock(&pool->lock);
 674                 l = &unbuddied[i];
 675                 if (unlikely(zhdr != list_first_entry(READ_ONCE(l),
 676                                                 struct z3fold_header, buddy)) ||
 677                     !z3fold_page_trylock(zhdr)) {
 678                         spin_unlock(&pool->lock);
 679                         zhdr = NULL;
 680                         put_cpu_ptr(pool->unbuddied);
 681                         if (can_sleep)
 682                                 cond_resched();
 683                         goto lookup;
 684                 }
 685                 list_del_init(&zhdr->buddy);
 686                 zhdr->cpu = -1;
 687                 spin_unlock(&pool->lock);
 688
 689                 page = virt_to_page(zhdr);
 690                 if (test_bit(NEEDS_COMPACTING, &page->private)) {
 691                         z3fold_page_unlock(zhdr);
 692                         zhdr = NULL;
 693                         put_cpu_ptr(pool->unbuddied);
 694                         if (can_sleep)
 695                                 cond_resched();
 696                         goto lookup;
 697                 }
 698
 699                 /*
 700                  * this page could not be removed from its unbuddied
 701                  * list while pool lock was held, and then we've taken
 702                  * page lock so kref_put could not be called before
 703                  * we got here, so it's safe to just call kref_get()
 704                  */
 705                 kref_get(&zhdr->refcount);
 706                 break;
 707         }
 708         put_cpu_ptr(pool->unbuddied);
 709
 710         if (!zhdr) {
 711                 int cpu;
 712
 713                 /* look for _exact_ match on other cpus' lists */
 714                 for_each_online_cpu(cpu) {
 715                         struct list_head *l;
 716
 717                         unbuddied = per_cpu_ptr(pool->unbuddied, cpu);
 718                         spin_lock(&pool->lock);
 719                         l = &unbuddied[chunks];
 720
 721                         zhdr = list_first_entry_or_null(READ_ONCE(l),
 722                                                 struct z3fold_header, buddy);
 723
 724                         if (!zhdr || !z3fold_page_trylock(zhdr)) {
 725                                 spin_unlock(&pool->lock);
 726                                 zhdr = NULL;
 727                                 continue;
 728                         }
 729                         list_del_init(&zhdr->buddy);
 730                         zhdr->cpu = -1;
 731                         spin_unlock(&pool->lock);
 732
 733                         page = virt_to_page(zhdr);
 734                         if (test_bit(NEEDS_COMPACTING, &page->private)) {
 735                                 z3fold_page_unlock(zhdr);
 736                                 zhdr = NULL;
 737                                 if (can_sleep)
 738                                         cond_resched();
 739                                 continue;
 740                         }
 741                         kref_get(&zhdr->refcount);
 742                         break;
 743                 }
 744         }
 745
 746         return zhdr;
 747 }
 748
 749 /*
 750  * API Functions
 751  */
 752
 753 /**
 754  * z3fold_create_pool() - create a new z3fold pool
 755  * @name:       pool name
 756  * @gfp:        gfp flags when allocating the z3fold pool structure
 757  * @ops:        user-defined operations for the z3fold pool
 758  *
 759  * Return: pointer to the new z3fold pool or NULL if the metadata allocation
 760  * failed.
 761  */
 762 static struct z3fold_pool *z3fold_create_pool(const char *name, gfp_t gfp,
 763                 const struct z3fold_ops *ops)
 764 {
 765         struct z3fold_pool *pool = NULL;
 766         int i, cpu;
 767
 768         pool = kzalloc(sizeof(struct z3fold_pool), gfp);
 769         if (!pool)
 770                 goto out;
 771         pool->c_handle = kmem_cache_create("z3fold_handle",
 772                                 sizeof(struct z3fold_buddy_slots),
 773                                 SLOTS_ALIGN, 0, NULL);
 774         if (!pool->c_handle)
 775                 goto out_c;
 776         spin_lock_init(&pool->lock);
 777         spin_lock_init(&pool->stale_lock);
 778         init_waitqueue_head(&pool->isolate_wait);
 779         pool->unbuddied = __alloc_percpu(sizeof(struct list_head)*NCHUNKS, 2);
 780         if (!pool->unbuddied)
 781                 goto out_pool;
 782         for_each_possible_cpu(cpu) {
 783                 struct list_head *unbuddied =
 784                                 per_cpu_ptr(pool->unbuddied, cpu);
 785                 for_each_unbuddied_list(i, 0)
 786                         INIT_LIST_HEAD(&unbuddied[i]);
 787         }
 788         INIT_LIST_HEAD(&pool->lru);
 789         INIT_LIST_HEAD(&pool->stale);
 790         atomic64_set(&pool->pages_nr, 0);
 791         pool->name = name;
 792         pool->compact_wq = create_singlethread_workqueue(pool->name);
 793         if (!pool->compact_wq)
 794                 goto out_unbuddied;
 795         pool->release_wq = create_singlethread_workqueue(pool->name);
 796         if (!pool->release_wq)
 797                 goto out_wq;
 798         if (z3fold_register_migration(pool))
 799                 goto out_rwq;
 800         INIT_WORK(&pool->work, free_pages_work);
 801         pool->ops = ops;
 802         return pool;
 803
 804 out_rwq:
 805         destroy_workqueue(pool->release_wq);
 806 out_wq:
 807         destroy_workqueue(pool->compact_wq);
 808 out_unbuddied:
 809         free_percpu(pool->unbuddied);
 810 out_pool:
 811         kmem_cache_destroy(pool->c_handle);
 812 out_c:
 813         kfree(pool);
 814 out:
 815         return NULL;
 816 }
 817
 818 static bool pool_isolated_are_drained(struct z3fold_pool *pool)
 819 {
 820         bool ret;
 821
 822         spin_lock(&pool->lock);
 823         ret = pool->isolated == 0;
 824         spin_unlock(&pool->lock);
 825         return ret;
 826 }
 827 /**
 828  * z3fold_destroy_pool() - destroys an existing z3fold pool
 829  * @pool:       the z3fold pool to be destroyed
 830  *
 831  * The pool should be emptied before this function is called.
 832  */
 833 static void z3fold_destroy_pool(struct z3fold_pool *pool)
 834 {
 835         kmem_cache_destroy(pool->c_handle);
 836         /*
 837          * We set pool-> destroying under lock to ensure that
 838          * z3fold_page_isolate() sees any changes to destroying. This way we
 839          * avoid the need for any memory barriers.
 840          */
 841
 842         spin_lock(&pool->lock);
 843         pool->destroying = true;
 844         spin_unlock(&pool->lock);
 845
 846         /*
 847          * We need to ensure that no pages are being migrated while we destroy
 848          * these workqueues, as migration can queue work on either of the
 849          * workqueues.
 850          */
 851         wait_event(pool->isolate_wait, !pool_isolated_are_drained(pool));
 852
 853         /*
 854          * We need to destroy pool->compact_wq before pool->release_wq,
 855          * as any pending work on pool->compact_wq will call
 856          * queue_work(pool->release_wq, &pool->work).
 857          *
 858          * There are still outstanding pages until both workqueues are drained,
 859          * so we cannot unregister migration until then.
 860          */
 861
 862         destroy_workqueue(pool->compact_wq);
 863         destroy_workqueue(pool->release_wq);
 864         z3fold_unregister_migration(pool);
 865         kfree(pool);
 866 }
 867
 868 /**
 869  * z3fold_alloc() - allocates a region of a given size
 870  * @pool:       z3fold pool from which to allocate
 871  * @size:       size in bytes of the desired allocation
 872  * @gfp:        gfp flags used if the pool needs to grow
 873  * @handle:     handle of the new allocation
 874  *
 875  * This function will attempt to find a free region in the pool large enough to
 876  * satisfy the allocation request.  A search of the unbuddied lists is
 877  * performed first. If no suitable free region is found, then a new page is
 878  * allocated and added to the pool to satisfy the request.
 879  *
 880  * gfp should not set __GFP_HIGHMEM as highmem pages cannot be used
 881  * as z3fold pool pages.
 882  *
 883  * Return: 0 if success and handle is set, otherwise -EINVAL if the size or
 884  * gfp arguments are invalid or -ENOMEM if the pool was unable to allocate
 885  * a new page.
 886  */
 887 static int z3fold_alloc(struct z3fold_pool *pool, size_t size, gfp_t gfp,
 888                         unsigned long *handle)
 889 {
 890         int chunks = size_to_chunks(size);
 891         struct z3fold_header *zhdr = NULL;
 892         struct page *page = NULL;
 893         enum buddy bud;
 894         bool can_sleep = gfpflags_allow_blocking(gfp);
 895
 896         if (!size)
 897                 return -EINVAL;
 898
 899         if (size > PAGE_SIZE)
 900                 return -ENOSPC;
 901
 902         if (size > PAGE_SIZE - ZHDR_SIZE_ALIGNED - CHUNK_SIZE)
 903                 bud = HEADLESS;
 904         else {
 905 retry:
 906                 zhdr = __z3fold_alloc(pool, size, can_sleep);
 907                 if (zhdr) {
 908                         if (zhdr->first_chunks == 0) {
 909                                 if (zhdr->middle_chunks != 0 &&
 910                                     chunks >= zhdr->start_middle)
 911                                         bud = LAST;
 912                                 else
 913                                         bud = FIRST;
 914                         } else if (zhdr->last_chunks == 0)
 915                                 bud = LAST;
 916                         else if (zhdr->middle_chunks == 0)
 917                                 bud = MIDDLE;
 918                         else {
 919                                 if (kref_put(&zhdr->refcount,
 920                                              release_z3fold_page_locked))
 921                                         atomic64_dec(&pool->pages_nr);
 922                                 else
 923                                         z3fold_page_unlock(zhdr);
 924                                 pr_err("No free chunks in unbuddied\n");
 925                                 WARN_ON(1);
 926                                 goto retry;
 927                         }
 928                         page = virt_to_page(zhdr);
 929                         goto found;
 930                 }
 931                 bud = FIRST;
 932         }
 933
 934         page = NULL;
 935         if (can_sleep) {
 936                 spin_lock(&pool->stale_lock);
 937                 zhdr = list_first_entry_or_null(&pool->stale,
 938                                                 struct z3fold_header, buddy);
 939                 /*
 940                  * Before allocating a page, let's see if we can take one from
 941                  * the stale pages list. cancel_work_sync() can sleep so we
 942                  * limit this case to the contexts where we can sleep
 943                  */
 944                 if (zhdr) {
 945                         list_del(&zhdr->buddy);
 946                         spin_unlock(&pool->stale_lock);
 947                         cancel_work_sync(&zhdr->work);
 948                         page = virt_to_page(zhdr);
 949                 } else {
 950                         spin_unlock(&pool->stale_lock);
 951                 }
 952         }
 953         if (!page)
 954                 page = alloc_page(gfp);
 955
 956         if (!page)
 957                 return -ENOMEM;
 958
 959         zhdr = init_z3fold_page(page, pool, gfp);
 960         if (!zhdr) {
 961                 __free_page(page);
 962                 return -ENOMEM;
 963         }
 964         atomic64_inc(&pool->pages_nr);
 965
 966         if (bud == HEADLESS) {
 967                 set_bit(PAGE_HEADLESS, &page->private);
 968                 goto headless;
 969         }
 970         if (can_sleep) {
 971                 lock_page(page);
 972                 __SetPageMovable(page, pool->inode->i_mapping);
 973                 unlock_page(page);
 974         } else {
 975                 if (trylock_page(page)) {
 976                         __SetPageMovable(page, pool->inode->i_mapping);
 977                         unlock_page(page);
 978                 }
 979         }
 980         z3fold_page_lock(zhdr);
 981
 982 found:
 983         if (bud == FIRST)
 984                 zhdr->first_chunks = chunks;
 985         else if (bud == LAST)
 986                 zhdr->last_chunks = chunks;
 987         else {
 988                 zhdr->middle_chunks = chunks;
 989                 zhdr->start_middle = zhdr->first_chunks + ZHDR_CHUNKS;
 990         }
 991         add_to_unbuddied(pool, zhdr);
 992
 993 headless:
 994         spin_lock(&pool->lock);
 995         /* Add/move z3fold page to beginning of LRU */
 996         if (!list_empty(&page->lru))
 997                 list_del(&page->lru);
 998
 999         list_add(&page->lru, &pool->lru);
1000
1001         *handle = encode_handle(zhdr, bud);
1002         spin_unlock(&pool->lock);
1003         if (bud != HEADLESS)
1004                 z3fold_page_unlock(zhdr);
1005
1006         return 0;
1007 }
1008
1009 /**
1010  * z3fold_free() - frees the allocation associated with the given handle
1011  * @pool:       pool in which the allocation resided
1012  * @handle:     handle associated with the allocation returned by z3fold_alloc()
1013  *
1014  * In the case that the z3fold page in which the allocation resides is under
1015  * reclaim, as indicated by the PG_reclaim flag being set, this function
1016  * only sets the first|last_chunks to 0.  The page is actually freed
1017  * once both buddies are evicted (see z3fold_reclaim_page() below).
1018  */
1019 static void z3fold_free(struct z3fold_pool *pool, unsigned long handle)
1020 {
1021         struct z3fold_header *zhdr;
1022         struct page *page;
1023         enum buddy bud;
1024
1025         zhdr = handle_to_z3fold_header(handle);
1026         page = virt_to_page(zhdr);
1027
1028         if (test_bit(PAGE_HEADLESS, &page->private)) {
1029                 /* if a headless page is under reclaim, just leave.
1030                  * NB: we use test_and_set_bit for a reason: if the bit
1031                  * has not been set before, we release this page
1032                  * immediately so we don't care about its value any more.
1033                  */
1034                 if (!test_and_set_bit(PAGE_CLAIMED, &page->private)) {
1035                         spin_lock(&pool->lock);
1036                         list_del(&page->lru);
1037                         spin_unlock(&pool->lock);
1038                         free_z3fold_page(page, true);
1039                         atomic64_dec(&pool->pages_nr);
1040                 }
1041                 return;
1042         }
1043
1044         /* Non-headless case */
1045         z3fold_page_lock(zhdr);
1046         bud = handle_to_buddy(handle);
1047
1048         switch (bud) {
1049         case FIRST:
1050                 zhdr->first_chunks = 0;
1051                 break;
1052         case MIDDLE:
1053                 zhdr->middle_chunks = 0;
1054                 break;
1055         case LAST:
1056                 zhdr->last_chunks = 0;
1057                 break;
1058         default:
1059                 pr_err("%s: unknown bud %d\n", __func__, bud);
1060                 WARN_ON(1);
1061                 z3fold_page_unlock(zhdr);
1062                 return;
1063         }
1064
1065         free_handle(handle);
1066         if (kref_put(&zhdr->refcount, release_z3fold_page_locked_list)) {
1067                 atomic64_dec(&pool->pages_nr);
1068                 return;
1069         }
1070         if (test_bit(PAGE_CLAIMED, &page->private)) {
1071                 z3fold_page_unlock(zhdr);
1072                 return;
1073         }
1074         if (unlikely(PageIsolated(page)) ||
1075             test_and_set_bit(NEEDS_COMPACTING, &page->private)) {
1076                 z3fold_page_unlock(zhdr);
1077                 return;
1078         }
1079         if (zhdr->cpu < 0 || !cpu_online(zhdr->cpu)) {
1080                 spin_lock(&pool->lock);
1081                 list_del_init(&zhdr->buddy);
1082                 spin_unlock(&pool->lock);
1083                 zhdr->cpu = -1;
1084                 kref_get(&zhdr->refcount);
1085                 do_compact_page(zhdr, true);
1086                 return;
1087         }
1088         kref_get(&zhdr->refcount);
1089         queue_work_on(zhdr->cpu, pool->compact_wq, &zhdr->work);
1090         z3fold_page_unlock(zhdr);
1091 }
1092
1093 /**
1094  * z3fold_reclaim_page() - evicts allocations from a pool page and frees it
1095  * @pool:       pool from which a page will attempt to be evicted
1096  * @retries:    number of pages on the LRU list for which eviction will
1097  *              be attempted before failing
1098  *
1099  * z3fold reclaim is different from normal system reclaim in that it is done
1100  * from the bottom, up. This is because only the bottom layer, z3fold, has
1101  * information on how the allocations are organized within each z3fold page.
1102  * This has the potential to create interesting locking situations between
1103  * z3fold and the user, however.
1104  *
1105  * To avoid these, this is how z3fold_reclaim_page() should be called:
1106  *
1107  * The user detects a page should be reclaimed and calls z3fold_reclaim_page().
1108  * z3fold_reclaim_page() will remove a z3fold page from the pool LRU list and
1109  * call the user-defined eviction handler with the pool and handle as
1110  * arguments.
1111  *
1112  * If the handle can not be evicted, the eviction handler should return
1113  * non-zero. z3fold_reclaim_page() will add the z3fold page back to the
1114  * appropriate list and try the next z3fold page on the LRU up to
1115  * a user defined number of retries.
1116  *
1117  * If the handle is successfully evicted, the eviction handler should
1118  * return 0 _and_ should have called z3fold_free() on the handle. z3fold_free()
1119  * contains logic to delay freeing the page if the page is under reclaim,
1120  * as indicated by the setting of the PG_reclaim flag on the underlying page.
1121  *
1122  * If all buddies in the z3fold page are successfully evicted, then the
1123  * z3fold page can be freed.
1124  *
1125  * Returns: 0 if page is successfully freed, otherwise -EINVAL if there are
1126  * no pages to evict or an eviction handler is not registered, -EAGAIN if
1127  * the retry limit was hit.
1128  */
1129 static int z3fold_reclaim_page(struct z3fold_pool *pool, unsigned int retries)
1130 {
1131         int i, ret = 0;
1132         struct z3fold_header *zhdr = NULL;
1133         struct page *page = NULL;
1134         struct list_head *pos;
1135         unsigned long first_handle = 0, middle_handle = 0, last_handle = 0;
1136
1137         spin_lock(&pool->lock);
1138         if (!pool->ops || !pool->ops->evict || retries == 0) {
1139                 spin_unlock(&pool->lock);
1140                 return -EINVAL;
1141         }
1142         for (i = 0; i < retries; i++) {
1143                 if (list_empty(&pool->lru)) {
1144                         spin_unlock(&pool->lock);
1145                         return -EINVAL;
1146                 }
1147                 list_for_each_prev(pos, &pool->lru) {
1148                         page = list_entry(pos, struct page, lru);
1149
1150                         /* this bit could have been set by free, in which case
1151                          * we pass over to the next page in the pool.
1152                          */
1153                         if (test_and_set_bit(PAGE_CLAIMED, &page->private))
1154                                 continue;
1155
1156                         if (unlikely(PageIsolated(page)))
1157                                 continue;
1158                         if (test_bit(PAGE_HEADLESS, &page->private))
1159                                 break;
1160
1161                         zhdr = page_address(page);
1162                         if (!z3fold_page_trylock(zhdr)) {
1163                                 zhdr = NULL;
1164                                 continue; /* can't evict at this point */
1165                         }
1166                         kref_get(&zhdr->refcount);
1167                         list_del_init(&zhdr->buddy);
1168                         zhdr->cpu = -1;
1169                         break;
1170                 }
1171
1172                 if (!zhdr)
1173                         break;
1174
1175                 list_del_init(&page->lru);
1176                 spin_unlock(&pool->lock);
1177
1178                 if (!test_bit(PAGE_HEADLESS, &page->private)) {
1179                         /*
1180                          * We need encode the handles before unlocking, since
1181                          * we can race with free that will set
1182                          * (first|last)_chunks to 0
1183                          */
1184                         first_handle = 0;
1185                         last_handle = 0;
1186                         middle_handle = 0;
1187                         if (zhdr->first_chunks)
1188                                 first_handle = encode_handle(zhdr, FIRST);
1189                         if (zhdr->middle_chunks)
1190                                 middle_handle = encode_handle(zhdr, MIDDLE);
1191                         if (zhdr->last_chunks)
1192                                 last_handle = encode_handle(zhdr, LAST);
1193                         /*
1194                          * it's safe to unlock here because we hold a
1195                          * reference to this page
1196                          */
1197                         z3fold_page_unlock(zhdr);
1198                 } else {
1199                         first_handle = encode_handle(zhdr, HEADLESS);
1200                         last_handle = middle_handle = 0;
1201                 }
1202
1203                 /* Issue the eviction callback(s) */
1204                 if (middle_handle) {
1205                         ret = pool->ops->evict(pool, middle_handle);
1206                         if (ret)
1207                                 goto next;
1208                 }
1209                 if (first_handle) {
1210                         ret = pool->ops->evict(pool, first_handle);
1211                         if (ret)
1212                                 goto next;
1213                 }
1214                 if (last_handle) {
1215                         ret = pool->ops->evict(pool, last_handle);
1216                         if (ret)
1217                                 goto next;
1218                 }
1219 next:
1220                 if (test_bit(PAGE_HEADLESS, &page->private)) {
1221                         if (ret == 0) {
1222                                 free_z3fold_page(page, true);
1223                                 atomic64_dec(&pool->pages_nr);
1224                                 return 0;
1225                         }
1226                         spin_lock(&pool->lock);
1227                         list_add(&page->lru, &pool->lru);
1228                         spin_unlock(&pool->lock);
1229                 } else {
1230                         z3fold_page_lock(zhdr);
1231                         clear_bit(PAGE_CLAIMED, &page->private);
1232                         if (kref_put(&zhdr->refcount,
1233                                         release_z3fold_page_locked)) {
1234                                 atomic64_dec(&pool->pages_nr);
1235                                 return 0;
1236                         }
1237                         /*
1238                          * if we are here, the page is still not completely
1239                          * free. Take the global pool lock then to be able
1240                          * to add it back to the lru list
1241                          */
1242                         spin_lock(&pool->lock);
1243                         list_add(&page->lru, &pool->lru);
1244                         spin_unlock(&pool->lock);
1245                         z3fold_page_unlock(zhdr);
1246                 }
1247
1248                 /* We started off locked to we need to lock the pool back */
1249                 spin_lock(&pool->lock);
1250         }
1251         spin_unlock(&pool->lock);
1252         return -EAGAIN;
1253 }
1254
1255 /**
1256  * z3fold_map() - maps the allocation associated with the given handle
1257  * @pool:       pool in which the allocation resides
1258  * @handle:     handle associated with the allocation to be mapped
1259  *
1260  * Extracts the buddy number from handle and constructs the pointer to the
1261  * correct starting chunk within the page.
1262  *
1263  * Returns: a pointer to the mapped allocation
1264  */
1265 static void *z3fold_map(struct z3fold_pool *pool, unsigned long handle)
1266 {
1267         struct z3fold_header *zhdr;
1268         struct page *page;
1269         void *addr;
1270         enum buddy buddy;
1271
1272         zhdr = handle_to_z3fold_header(handle);
1273         addr = zhdr;
1274         page = virt_to_page(zhdr);
1275
1276         if (test_bit(PAGE_HEADLESS, &page->private))
1277                 goto out;
1278
1279         z3fold_page_lock(zhdr);
1280         buddy = handle_to_buddy(handle);
1281         switch (buddy) {
1282         case FIRST:
1283                 addr += ZHDR_SIZE_ALIGNED;
1284                 break;
1285         case MIDDLE:
1286                 addr += zhdr->start_middle << CHUNK_SHIFT;
1287                 set_bit(MIDDLE_CHUNK_MAPPED, &page->private);
1288                 break;
1289         case LAST:
1290                 addr += PAGE_SIZE - (handle_to_chunks(handle) << CHUNK_SHIFT);
1291                 break;
1292         default:
1293                 pr_err("unknown buddy id %d\n", buddy);
1294                 WARN_ON(1);
1295                 addr = NULL;
1296                 break;
1297         }
1298
1299         if (addr)
1300                 zhdr->mapped_count++;
1301         z3fold_page_unlock(zhdr);
1302 out:
1303         return addr;
1304 }
1305
1306 /**
1307  * z3fold_unmap() - unmaps the allocation associated with the given handle
1308  * @pool:       pool in which the allocation resides
1309  * @handle:     handle associated with the allocation to be unmapped
1310  */
1311 static void z3fold_unmap(struct z3fold_pool *pool, unsigned long handle)
1312 {
1313         struct z3fold_header *zhdr;
1314         struct page *page;
1315         enum buddy buddy;
1316
1317         zhdr = handle_to_z3fold_header(handle);
1318         page = virt_to_page(zhdr);
1319
1320         if (test_bit(PAGE_HEADLESS, &page->private))
1321                 return;
1322
1323         z3fold_page_lock(zhdr);
1324         buddy = handle_to_buddy(handle);
1325         if (buddy == MIDDLE)
1326                 clear_bit(MIDDLE_CHUNK_MAPPED, &page->private);
1327         zhdr->mapped_count--;
1328         z3fold_page_unlock(zhdr);
1329 }
1330
1331 /**
1332  * z3fold_get_pool_size() - gets the z3fold pool size in pages
1333  * @pool:       pool whose size is being queried
1334  *
1335  * Returns: size in pages of the given pool.
1336  */
1337 static u64 z3fold_get_pool_size(struct z3fold_pool *pool)
1338 {
1339         return atomic64_read(&pool->pages_nr);
1340 }
1341
1342 /*
1343  * z3fold_dec_isolated() expects to be called while pool->lock is held.
1344  */
1345 static void z3fold_dec_isolated(struct z3fold_pool *pool)
1346 {
1347         assert_spin_locked(&pool->lock);
1348         VM_BUG_ON(pool->isolated <= 0);
1349         pool->isolated--;
1350
1351         /*
1352          * If we have no more isolated pages, we have to see if
1353          * z3fold_destroy_pool() is waiting for a signal.
1354          */
1355         if (pool->isolated == 0 && waitqueue_active(&pool->isolate_wait))
1356                 wake_up_all(&pool->isolate_wait);
1357 }
1358
1359 static void z3fold_inc_isolated(struct z3fold_pool *pool)
1360 {
1361         pool->isolated++;
1362 }
1363
1364 static bool z3fold_page_isolate(struct page *page, isolate_mode_t mode)
1365 {
1366         struct z3fold_header *zhdr;
1367         struct z3fold_pool *pool;
1368
1369         VM_BUG_ON_PAGE(!PageMovable(page), page);
1370         VM_BUG_ON_PAGE(PageIsolated(page), page);
1371
1372         if (test_bit(PAGE_HEADLESS, &page->private))
1373                 return false;
1374
1375         zhdr = page_address(page);
1376         z3fold_page_lock(zhdr);
1377         if (test_bit(NEEDS_COMPACTING, &page->private) ||
1378             test_bit(PAGE_STALE, &page->private))
1379                 goto out;
1380
1381         pool = zhdr_to_pool(zhdr);
1382
1383         if (zhdr->mapped_count == 0) {
1384                 kref_get(&zhdr->refcount);
1385                 if (!list_empty(&zhdr->buddy))
1386                         list_del_init(&zhdr->buddy);
1387                 spin_lock(&pool->lock);
1388                 if (!list_empty(&page->lru))
1389                         list_del(&page->lru);
1390                 /*
1391                  * We need to check for destruction while holding pool->lock, as
1392                  * otherwise destruction could see 0 isolated pages, and
1393                  * proceed.
1394                  */
1395                 if (unlikely(pool->destroying)) {
1396                         spin_unlock(&pool->lock);
1397                         /*
1398                          * If this page isn't stale, somebody else holds a
1399                          * reference to it. Let't drop our refcount so that they
1400                          * can call the release logic.
1401                          */
1402                         if (unlikely(kref_put(&zhdr->refcount,
1403                                               release_z3fold_page_locked))) {
1404                                 /*
1405                                  * If we get here we have kref problems, so we
1406                                  * should freak out.
1407                                  */
1408                                 WARN(1, "Z3fold is experiencing kref problems\n");
1409                                 return false;
1410                         }
1411                         z3fold_page_unlock(zhdr);
1412                         return false;
1413                 }
1414
1415
1416                 z3fold_inc_isolated(pool);
1417                 spin_unlock(&pool->lock);
1418                 z3fold_page_unlock(zhdr);
1419                 return true;
1420         }
1421 out:
1422         z3fold_page_unlock(zhdr);
1423         return false;
1424 }
1425
1426 static int z3fold_page_migrate(struct address_space *mapping, struct page *newpage,
1427                                struct page *page, enum migrate_mode mode)
1428 {
1429         struct z3fold_header *zhdr, *new_zhdr;
1430         struct z3fold_pool *pool;
1431         struct address_space *new_mapping;
1432
1433         VM_BUG_ON_PAGE(!PageMovable(page), page);
1434         VM_BUG_ON_PAGE(!PageIsolated(page), page);
1435         VM_BUG_ON_PAGE(!PageLocked(newpage), newpage);
1436
1437         zhdr = page_address(page);
1438         pool = zhdr_to_pool(zhdr);
1439
1440         if (!z3fold_page_trylock(zhdr)) {
1441                 return -EAGAIN;
1442         }
1443         if (zhdr->mapped_count != 0) {
1444                 z3fold_page_unlock(zhdr);
1445                 return -EBUSY;
1446         }
1447         if (work_pending(&zhdr->work)) {
1448                 z3fold_page_unlock(zhdr);
1449                 return -EAGAIN;
1450         }
1451         new_zhdr = page_address(newpage);
1452         memcpy(new_zhdr, zhdr, PAGE_SIZE);
1453         newpage->private = page->private;
1454         page->private = 0;
1455         z3fold_page_unlock(zhdr);
1456         spin_lock_init(&new_zhdr->page_lock);
1457         INIT_WORK(&new_zhdr->work, compact_page_work);
1458         /*
1459          * z3fold_page_isolate() ensures that new_zhdr->buddy is empty,
1460          * so we only have to reinitialize it.
1461          */
1462         INIT_LIST_HEAD(&new_zhdr->buddy);
1463         new_mapping = page_mapping(page);
1464         __ClearPageMovable(page);
1465         ClearPagePrivate(page);
1466
1467         get_page(newpage);
1468         z3fold_page_lock(new_zhdr);
1469         if (new_zhdr->first_chunks)
1470                 encode_handle(new_zhdr, FIRST);
1471         if (new_zhdr->last_chunks)
1472                 encode_handle(new_zhdr, LAST);
1473         if (new_zhdr->middle_chunks)
1474                 encode_handle(new_zhdr, MIDDLE);
1475         set_bit(NEEDS_COMPACTING, &newpage->private);
1476         new_zhdr->cpu = smp_processor_id();
1477         spin_lock(&pool->lock);
1478         list_add(&newpage->lru, &pool->lru);
1479         spin_unlock(&pool->lock);
1480         __SetPageMovable(newpage, new_mapping);
1481         z3fold_page_unlock(new_zhdr);
1482
1483         queue_work_on(new_zhdr->cpu, pool->compact_wq, &new_zhdr->work);
1484
1485         spin_lock(&pool->lock);
1486         z3fold_dec_isolated(pool);
1487         spin_unlock(&pool->lock);
1488
1489         page_mapcount_reset(page);
1490         put_page(page);
1491         return 0;
1492 }
1493
1494 static void z3fold_page_putback(struct page *page)
1495 {
1496         struct z3fold_header *zhdr;
1497         struct z3fold_pool *pool;
1498
1499         zhdr = page_address(page);
1500         pool = zhdr_to_pool(zhdr);
1501
1502         z3fold_page_lock(zhdr);
1503         if (!list_empty(&zhdr->buddy))
1504                 list_del_init(&zhdr->buddy);
1505         INIT_LIST_HEAD(&page->lru);
1506         if (kref_put(&zhdr->refcount, release_z3fold_page_locked)) {
1507                 atomic64_dec(&pool->pages_nr);
1508                 spin_lock(&pool->lock);
1509                 z3fold_dec_isolated(pool);
1510                 spin_unlock(&pool->lock);
1511                 return;
1512         }
1513         spin_lock(&pool->lock);
1514         list_add(&page->lru, &pool->lru);
1515         z3fold_dec_isolated(pool);
1516         spin_unlock(&pool->lock);
1517         z3fold_page_unlock(zhdr);
1518 }
1519
1520 static const struct address_space_operations z3fold_aops = {
1521         .isolate_page = z3fold_page_isolate,
1522         .migratepage = z3fold_page_migrate,
1523         .putback_page = z3fold_page_putback,
1524 };
1525
1526 /*****************
1527  * zpool
1528  ****************/
1529
1530 static int z3fold_zpool_evict(struct z3fold_pool *pool, unsigned long handle)
1531 {
1532         if (pool->zpool && pool->zpool_ops && pool->zpool_ops->evict)
1533                 return pool->zpool_ops->evict(pool->zpool, handle);
1534         else
1535                 return -ENOENT;
1536 }
1537
1538 static const struct z3fold_ops z3fold_zpool_ops = {
1539         .evict =        z3fold_zpool_evict
1540 };
1541
1542 static void *z3fold_zpool_create(const char *name, gfp_t gfp,
1543                                const struct zpool_ops *zpool_ops,
1544                                struct zpool *zpool)
1545 {
1546         struct z3fold_pool *pool;
1547
1548         pool = z3fold_create_pool(name, gfp,
1549                                 zpool_ops ? &z3fold_zpool_ops : NULL);
1550         if (pool) {
1551                 pool->zpool = zpool;
1552                 pool->zpool_ops = zpool_ops;
1553         }
1554         return pool;
1555 }
1556
1557 static void z3fold_zpool_destroy(void *pool)
1558 {
1559         z3fold_destroy_pool(pool);
1560 }
1561
1562 static int z3fold_zpool_malloc(void *pool, size_t size, gfp_t gfp,
1563                         unsigned long *handle)
1564 {
1565         return z3fold_alloc(pool, size, gfp, handle);
1566 }
1567 static void z3fold_zpool_free(void *pool, unsigned long handle)
1568 {
1569         z3fold_free(pool, handle);
1570 }
1571
1572 static int z3fold_zpool_shrink(void *pool, unsigned int pages,
1573                         unsigned int *reclaimed)
1574 {
1575         unsigned int total = 0;
1576         int ret = -EINVAL;
1577
1578         while (total < pages) {
1579                 ret = z3fold_reclaim_page(pool, 8);
1580                 if (ret < 0)
1581                         break;
1582                 total++;
1583         }
1584
1585         if (reclaimed)
1586                 *reclaimed = total;
1587
1588         return ret;
1589 }
1590
1591 static void *z3fold_zpool_map(void *pool, unsigned long handle,
1592                         enum zpool_mapmode mm)
1593 {
1594         return z3fold_map(pool, handle);
1595 }
1596 static void z3fold_zpool_unmap(void *pool, unsigned long handle)
1597 {
1598         z3fold_unmap(pool, handle);
1599 }
1600
1601 static u64 z3fold_zpool_total_size(void *pool)
1602 {
1603         return z3fold_get_pool_size(pool) * PAGE_SIZE;
1604 }
1605
1606 static struct zpool_driver z3fold_zpool_driver = {
1607         .type =         "z3fold",
1608         .owner =        THIS_MODULE,
1609         .create =       z3fold_zpool_create,
1610         .destroy =      z3fold_zpool_destroy,
1611         .malloc =       z3fold_zpool_malloc,
1612         .free =         z3fold_zpool_free,
1613         .shrink =       z3fold_zpool_shrink,
1614         .map =          z3fold_zpool_map,
1615         .unmap =        z3fold_zpool_unmap,
1616         .total_size =   z3fold_zpool_total_size,
1617 };
1618
1619 MODULE_ALIAS("zpool-z3fold");
1620
1621 static int __init init_z3fold(void)
1622 {
1623         int ret;
1624
1625         /* Make sure the z3fold header is not larger than the page size */
1626         BUILD_BUG_ON(ZHDR_SIZE_ALIGNED > PAGE_SIZE);
1627         ret = z3fold_mount();
1628         if (ret)
1629                 return ret;
1630
1631         zpool_register_driver(&z3fold_zpool_driver);
1632
1633         return 0;
1634 }
1635
1636 static void __exit exit_z3fold(void)
1637 {
1638         z3fold_unmount();
1639         zpool_unregister_driver(&z3fold_zpool_driver);
1640 }
1641
1642 module_init(init_z3fold);
1643 module_exit(exit_z3fold);
1644
1645 MODULE_LICENSE("GPL");
1646 MODULE_AUTHOR("Vitaly Wool <vitalywool@gmail.com>");
1647 MODULE_DESCRIPTION("3-Fold Allocator for Compressed Pages");