drivers/video/tegra/nvmap/nvmap_pp.c

   1 /*
   2  * drivers/video/tegra/nvmap/nvmap_pp.c
   3  *
   4  * Manage page pools to speed up page allocation.
   5  *
   6  * Copyright (c) 2009-2014, NVIDIA CORPORATION. All rights reserved.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful, but WITHOUT
  14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  16  * more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; if not, write to the Free Software Foundation, Inc.,
  20  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  21  */
  22
  23 #define pr_fmt(fmt) "%s: " fmt, __func__
  24
  25 #include <linux/kernel.h>
  26 #include <linux/vmalloc.h>
  27 #include <linux/moduleparam.h>
  28 #include <linux/shrinker.h>
  29 #include <linux/kthread.h>
  30 #include <linux/debugfs.h>
  31
  32 #include "nvmap_priv.h"
  33
  34 #define NVMAP_TEST_PAGE_POOL_SHRINKER     1
  35 #define PENDING_PAGES_SIZE                128
  36 #define MIN_AVAILABLE_MB                  128
  37
  38 static bool enable_pp = 1;
  39 static int pool_size;
  40
  41 static struct task_struct *background_allocator;
  42 static struct page *pending_pages[PENDING_PAGES_SIZE];
  43 static atomic_t bg_pages_to_fill;
  44
  45 #ifdef CONFIG_NVMAP_PAGE_POOL_DEBUG
  46 static inline void __pp_dbg_var_add(u64 *dbg_var, u32 nr)
  47 {
  48         *dbg_var += nr;
  49 }
  50 #else
  51 #define __pp_dbg_var_add(dbg_var, nr)
  52 #endif
  53
  54 #define pp_alloc_add(pool, nr) __pp_dbg_var_add(&(pool)->allocs, nr)
  55 #define pp_fill_add(pool, nr)  __pp_dbg_var_add(&(pool)->fills, nr)
  56 #define pp_hit_add(pool, nr)   __pp_dbg_var_add(&(pool)->hits, nr)
  57 #define pp_miss_add(pool, nr)  __pp_dbg_var_add(&(pool)->misses, nr)
  58
  59 static int __nvmap_page_pool_fill_lots_locked(struct nvmap_page_pool *pool,
  60                                        struct page **pages, u32 nr);
  61
  62 static inline struct page *get_page_list_page(struct nvmap_page_pool *pool)
  63 {
  64         struct page *page;
  65
  66         if (list_empty(&pool->page_list))
  67                 return NULL;
  68
  69         page = list_first_entry(&pool->page_list, struct page, lru);
  70         list_del(&page->lru);
  71
  72         pool->count--;
  73
  74         return page;
  75 }
  76
  77 /*
  78  * Allocate n pages one by one. Not the most efficient allocation scheme ever;
  79  * however, it will make it easier later on to handle single or small number of
  80  * page allocations from the page pool being individually freed.
  81  */
  82 static int __nvmap_pp_alloc_n_pages(struct page **pages, int n, gfp_t flags)
  83 {
  84         int i;
  85
  86         for (i = 0; i < n; i++) {
  87                 pages[i] = alloc_page(flags);
  88                 if (!pages[i])
  89                         goto no_mem;
  90         }
  91
  92         return 0;
  93
  94 no_mem:
  95         for (i -= 1; i >= 0; i--)
  96                 __free_page(pages[i]);
  97         return -ENOMEM;
  98 }
  99
 100 /*
 101  * Actually do the fill. This requires a few steps:
 102  *
 103  *  1. Allocate a bunch of pages.
 104  *
 105  *  2. Fill the page pool with the allocated pages. We don't want to hold the
 106  *     PP lock for too long so this is the only time we hold the PP lock.
 107  *
 108  *  3. Rinse and repeat until we have allocated all the pages we think we need
 109  *     or the page pool is full. Since we are not holding the lock for the
 110  *     entire fill it is possible that other pages were filled into the pool.
 111  *
 112  *  4. Free any left over pages if the pool is filled before we finish.
 113  */
 114 static void nvmap_pp_do_background_fill(struct nvmap_page_pool *pool)
 115 {
 116         int err;
 117         u32 pages = 0, nr, i;
 118         gfp_t gfp = GFP_NVMAP | __GFP_NOMEMALLOC |
 119                     __GFP_NORETRY | __GFP_NO_KSWAPD;
 120
 121         pages = (u32)atomic_xchg(&bg_pages_to_fill, pages);
 122
 123         if (!pages || !enable_pp)
 124                 return;
 125
 126         /* If this param is set, force zero page allocation. */
 127         if (zero_memory)
 128                 gfp |= __GFP_ZERO;
 129
 130         do {
 131                 nr = min_t(u32, PENDING_PAGES_SIZE, pages);
 132                 err = __nvmap_pp_alloc_n_pages(pending_pages, nr, gfp);
 133                 if (err) {
 134                         pr_info("Failed to alloc %u pages for PP!\n", pages);
 135                         return;
 136                 }
 137
 138                 mutex_lock(&pool->lock);
 139                 i = __nvmap_page_pool_fill_lots_locked(pool, pending_pages, nr);
 140                 mutex_unlock(&pool->lock);
 141                 pages -= nr;
 142         } while (pages && i == nr);
 143
 144         for (; i < nr; i++)
 145                 __free_page(pending_pages[i]);
 146 }
 147
 148 /*
 149  * This thread fills the page pools with zeroed pages. We avoid releasing the
 150  * pages directly back into the page pools since we would then have to zero
 151  * them ourselves. Instead it is easier to just reallocate zeroed pages. This
 152  * happens in the background so that the overhead of allocating zeroed pages is
 153  * not directly seen by userspace. Of course if the page pools are empty user
 154  * space will suffer.
 155  */
 156 static int nvmap_background_zero_allocator(void *arg)
 157 {
 158         pr_info("PP alloc thread starting.\n");
 159
 160         while (1) {
 161                 if (kthread_should_stop())
 162                         break;
 163
 164                 nvmap_pp_do_background_fill(&nvmap_dev->pool);
 165
 166                 /* Pending work is done - go to sleep. */
 167                 set_current_state(TASK_INTERRUPTIBLE);
 168                 schedule();
 169         }
 170
 171         return 0;
 172 }
 173
 174 /*
 175  * Call this if the background allocator should possibly wake up. This function
 176  * will check to make sure its actually a good idea for that to happen before
 177  * waking the allocator up.
 178  */
 179 static inline void nvmap_pp_wake_up_allocator(void)
 180 {
 181         struct nvmap_page_pool *pool = &nvmap_dev->pool;
 182         struct sysinfo info;
 183         int free_pages, tmp;
 184
 185         if (!enable_pp)
 186                 return;
 187
 188         /* Hueristic: if we don't need to prefill explicitly zero'ed memory then
 189          * lots of memory can be placed back in the pools by possible frees.
 190          * Therefor don't fill the pool unless we really need to as we may get
 191          * more memory without needing to alloc pages.
 192          */
 193         if (!zero_memory && pool->count > NVMAP_PP_ZERO_MEM_FILL_MIN)
 194                 return;
 195
 196         if (pool->max - pool->count < NVMAP_PP_DEF_FILL_THRESH)
 197                 return;
 198
 199         si_meminfo(&info);
 200         free_pages = (int)info.freeram;
 201
 202         tmp = free_pages - (MIN_AVAILABLE_MB << (20 - PAGE_SHIFT));
 203         if (tmp <= 0)
 204                 return;
 205
 206         /* Let the background thread know how much memory to fill. */
 207         atomic_set(&bg_pages_to_fill,
 208                    min(tmp, (int)(pool->max - pool->count)));
 209         wake_up_process(background_allocator);
 210 }
 211
 212 /*
 213  * This removes a page from the page pool. If ignore_disable is set, then
 214  * the enable_pp flag is ignored.
 215  */
 216 static struct page *nvmap_page_pool_alloc_locked(struct nvmap_page_pool *pool,
 217                                                  int force_alloc)
 218 {
 219         struct page *page;
 220
 221         if (!force_alloc && !enable_pp)
 222                 return NULL;
 223
 224         if (list_empty(&pool->page_list)) {
 225                 pp_miss_add(pool, 1);
 226                 return NULL;
 227         }
 228
 229         if (IS_ENABLED(CONFIG_NVMAP_PAGE_POOL_DEBUG))
 230                 BUG_ON(pool->count == 0);
 231
 232         page = get_page_list_page(pool);
 233         if (!page)
 234                 return NULL;
 235
 236         /* Sanity check. */
 237         if (IS_ENABLED(CONFIG_NVMAP_PAGE_POOL_DEBUG)) {
 238                 atomic_dec(&page->_count);
 239                 BUG_ON(atomic_read(&page->_count) != 1);
 240         }
 241
 242         pp_alloc_add(pool, 1);
 243         pp_hit_add(pool, 1);
 244
 245         return page;
 246 }
 247
 248 /*
 249  * Alloc a bunch of pages from the page pool. This will alloc as many as it can
 250  * and return the number of pages allocated. Pages are placed into the passed
 251  * array in a linear fashion starting from index 0.
 252  *
 253  * You must lock the page pool before using this.
 254  */
 255 static int __nvmap_page_pool_alloc_lots_locked(struct nvmap_page_pool *pool,
 256                                         struct page **pages, u32 nr)
 257 {
 258         u32 real_nr;
 259         u32 ind = 0;
 260
 261         if (!enable_pp)
 262                 return 0;
 263
 264         real_nr = min_t(u32, nr, pool->count);
 265
 266         while (real_nr--) {
 267                 struct page *page;
 268                 if (IS_ENABLED(CONFIG_NVMAP_PAGE_POOL_DEBUG))
 269                         BUG_ON(list_empty(&pool->page_list));
 270                 page = get_page_list_page(pool);
 271                 pages[ind++] = page;
 272                 if (IS_ENABLED(CONFIG_NVMAP_PAGE_POOL_DEBUG)) {
 273                         atomic_dec(&page->_count);
 274                         BUG_ON(atomic_read(&page->_count) != 1);
 275                 }
 276         }
 277
 278         pp_alloc_add(pool, ind);
 279         pp_hit_add(pool, ind);
 280         pp_miss_add(pool, nr - ind);
 281         nvmap_pp_wake_up_allocator();
 282
 283         return ind;
 284 }
 285
 286 int nvmap_page_pool_alloc_lots(struct nvmap_page_pool *pool,
 287                                 struct page **pages, u32 nr)
 288 {
 289         int ret;
 290
 291         mutex_lock(&pool->lock);
 292         ret = __nvmap_page_pool_alloc_lots_locked(pool, pages, nr);
 293         mutex_unlock(&pool->lock);
 294
 295         return ret;
 296 }
 297
 298 /*
 299  * This adds a page to the pool. Returns true if the passed page is added.
 300  * That means if the pool is full this operation will fail.
 301  */
 302 static bool nvmap_page_pool_fill_locked(struct nvmap_page_pool *pool,
 303                                         struct page *page)
 304 {
 305         if (!enable_pp)
 306                 return false;
 307
 308         if (pool->count >= pool->max)
 309                 return false;
 310
 311         /* Sanity check. */
 312         if (IS_ENABLED(CONFIG_NVMAP_PAGE_POOL_DEBUG)) {
 313                 atomic_inc(&page->_count);
 314                 BUG_ON(atomic_read(&page->_count) != 2);
 315                 BUG_ON(pool->count > pool->max);
 316         }
 317
 318         list_add_tail(&page->lru, &pool->page_list);
 319         pool->count++;
 320         pp_fill_add(pool, 1);
 321
 322         return true;
 323 }
 324
 325 /*
 326  * Fill a bunch of pages into the page pool. This will fill as many as it can
 327  * and return the number of pages filled. Pages are used from the start of the
 328  * passed page pointer array in a linear fashion.
 329  *
 330  * You must lock the page pool before using this.
 331  */
 332 static int __nvmap_page_pool_fill_lots_locked(struct nvmap_page_pool *pool,
 333                                        struct page **pages, u32 nr)
 334 {
 335         u32 real_nr;
 336         u32 ind = 0;
 337
 338         if (!enable_pp)
 339                 return 0;
 340
 341         real_nr = min_t(u32, pool->max - pool->count, nr);
 342         if (real_nr == 0)
 343                 return 0;
 344
 345         while (real_nr--) {
 346                 if (IS_ENABLED(CONFIG_NVMAP_PAGE_POOL_DEBUG)) {
 347                         atomic_inc(&pages[ind]->_count);
 348                         BUG_ON(atomic_read(&pages[ind]->_count) != 2);
 349                 }
 350                 list_add_tail(&pages[ind++]->lru, &pool->page_list);
 351         }
 352
 353         pool->count += ind;
 354         pp_fill_add(pool, ind);
 355
 356         return ind;
 357 }
 358
 359 int nvmap_page_pool_fill_lots(struct nvmap_page_pool *pool,
 360                                        struct page **pages, u32 nr)
 361 {
 362         int ret;
 363
 364         mutex_lock(&pool->lock);
 365         ret = __nvmap_page_pool_fill_lots_locked(pool, pages, nr);
 366         mutex_unlock(&pool->lock);
 367
 368         return ret;
 369 }
 370
 371 bool nvmap_page_pool_fill(struct nvmap_page_pool *pool, struct page *page)
 372 {
 373         bool ret = false;
 374
 375         if (pool) {
 376                 mutex_lock(&pool->lock);
 377                 ret = nvmap_page_pool_fill_locked(pool, page);
 378                 mutex_unlock(&pool->lock);
 379         }
 380
 381         return ret;
 382 }
 383
 384 /*
 385  * Free the passed number of pages from the page pool. This happen irregardless
 386  * of whether ther page pools are enabled. This lets one disable the page pools
 387  * and then free all the memory therein.
 388  */
 389 static int nvmap_page_pool_free(struct nvmap_page_pool *pool, int nr_free)
 390 {
 391         int i = nr_free;
 392         struct page *page;
 393
 394         if (!nr_free)
 395                 return nr_free;
 396
 397         mutex_lock(&pool->lock);
 398         while (i) {
 399                 page = nvmap_page_pool_alloc_locked(pool, 1);
 400                 if (!page)
 401                         break;
 402                 __free_page(page);
 403                 i--;
 404         }
 405         mutex_unlock(&pool->lock);
 406
 407         return i;
 408 }
 409
 410 ulong nvmap_page_pool_get_unused_pages(void)
 411 {
 412         int total = 0;
 413
 414         if (!nvmap_dev)
 415                 return 0;
 416
 417         total = nvmap_dev->pool.count;
 418
 419         return total;
 420 }
 421
 422 /*
 423  * Remove and free to the system all the pages currently in the page
 424  * pool. This operation will happen even if the page pools are disabled.
 425  */
 426 int nvmap_page_pool_clear(void)
 427 {
 428         struct page *page;
 429         struct nvmap_page_pool *pool = &nvmap_dev->pool;
 430
 431         mutex_lock(&pool->lock);
 432
 433         while ((page = nvmap_page_pool_alloc_locked(pool, 1)) != NULL)
 434                 __free_page(page);
 435
 436         /* For some reason, if an error occured... */
 437         if (!list_empty(&pool->page_list)) {
 438                 mutex_unlock(&pool->lock);
 439                 return -ENOMEM;
 440         }
 441
 442         mutex_unlock(&pool->lock);
 443         nvmap_pp_wake_up_allocator();
 444
 445         return 0;
 446 }
 447
 448 /*
 449  * Resizes the page pool to the passed size. If the passed size is 0 then
 450  * all associated resources are released back to the system. This operation
 451  * will only occur if the page pools are enabled.
 452  */
 453 static void nvmap_page_pool_resize(struct nvmap_page_pool *pool, int size)
 454 {
 455         if (!enable_pp || size == pool->max || size < 0)
 456                 return;
 457
 458         mutex_lock(&pool->lock);
 459
 460         while (pool->count > size)
 461                 __free_page(nvmap_page_pool_alloc_locked(pool, 0));
 462
 463         pool->max = size;
 464
 465         pr_debug("page pool resized to %d from %d pages\n", size, pool->max);
 466         mutex_unlock(&pool->lock);
 467 }
 468
 469 static int nvmap_page_pool_shrink(struct shrinker *shrinker,
 470                                   struct shrink_control *sc)
 471 {
 472         int shrink_pages = sc->nr_to_scan;
 473
 474         if (!shrink_pages)
 475                 goto out;
 476
 477         pr_debug("sh_pages=%d", shrink_pages);
 478
 479         shrink_pages = nvmap_page_pool_free(&nvmap_dev->pool, shrink_pages);
 480 out:
 481         return nvmap_page_pool_get_unused_pages();
 482 }
 483
 484 static struct shrinker nvmap_page_pool_shrinker = {
 485         .shrink = nvmap_page_pool_shrink,
 486         .seeks = 1,
 487 };
 488
 489 static void shrink_page_pools(int *total_pages, int *available_pages)
 490 {
 491         struct shrink_control sc;
 492
 493         if (*total_pages == 0) {
 494                 sc.gfp_mask = GFP_KERNEL;
 495                 sc.nr_to_scan = 0;
 496                 *total_pages = nvmap_page_pool_shrink(NULL, &sc);
 497         }
 498         sc.nr_to_scan = *total_pages;
 499         *available_pages = nvmap_page_pool_shrink(NULL, &sc);
 500 }
 501
 502 #if NVMAP_TEST_PAGE_POOL_SHRINKER
 503 static int shrink_pp;
 504 static int shrink_set(const char *arg, const struct kernel_param *kp)
 505 {
 506         int cpu = smp_processor_id();
 507         unsigned long long t1, t2;
 508         int total_pages, available_pages;
 509
 510         param_set_int(arg, kp);
 511
 512         if (shrink_pp) {
 513                 total_pages = shrink_pp;
 514                 t1 = cpu_clock(cpu);
 515                 shrink_page_pools(&total_pages, &available_pages);
 516                 t2 = cpu_clock(cpu);
 517                 pr_debug("shrink page pools: time=%lldns, "
 518                         "total_pages_released=%d, free_pages_available=%d",
 519                         t2-t1, total_pages, available_pages);
 520         }
 521         return 0;
 522 }
 523
 524 static int shrink_get(char *buff, const struct kernel_param *kp)
 525 {
 526         return param_get_int(buff, kp);
 527 }
 528
 529 static struct kernel_param_ops shrink_ops = {
 530         .get = shrink_get,
 531         .set = shrink_set,
 532 };
 533
 534 module_param_cb(shrink_page_pools, &shrink_ops, &shrink_pp, 0644);
 535 #endif
 536
 537 static int enable_pp_set(const char *arg, const struct kernel_param *kp)
 538 {
 539         int ret;
 540
 541         ret = param_set_bool(arg, kp);
 542         if (ret)
 543                 return ret;
 544
 545         if (!enable_pp)
 546                 nvmap_page_pool_clear();
 547
 548         return 0;
 549 }
 550
 551 static int enable_pp_get(char *buff, const struct kernel_param *kp)
 552 {
 553         return param_get_int(buff, kp);
 554 }
 555
 556 static struct kernel_param_ops enable_pp_ops = {
 557         .get = enable_pp_get,
 558         .set = enable_pp_set,
 559 };
 560
 561 module_param_cb(enable_page_pools, &enable_pp_ops, &enable_pp, 0644);
 562
 563 static int pool_size_set(const char *arg, const struct kernel_param *kp)
 564 {
 565         param_set_int(arg, kp);
 566         nvmap_page_pool_resize(&nvmap_dev->pool, pool_size);
 567         return 0;
 568 }
 569
 570 static int pool_size_get(char *buff, const struct kernel_param *kp)
 571 {
 572         return param_get_int(buff, kp);
 573 }
 574
 575 static struct kernel_param_ops pool_size_ops = {
 576         .get = pool_size_get,
 577         .set = pool_size_set,
 578 };
 579
 580 module_param_cb(pool_size, &pool_size_ops, &pool_size, 0644);
 581
 582 int nvmap_page_pool_debugfs_init(struct dentry *nvmap_root)
 583 {
 584         struct dentry *pp_root;
 585
 586         if (!nvmap_root)
 587                 return -ENODEV;
 588
 589         pp_root = debugfs_create_dir("pagepool", nvmap_root);
 590         if (!pp_root)
 591                 return -ENODEV;
 592
 593         debugfs_create_u32("page_pool_available_pages",
 594                            S_IRUGO, pp_root,
 595                            &nvmap_dev->pool.count);
 596 #ifdef CONFIG_NVMAP_PAGE_POOL_DEBUG
 597         debugfs_create_u64("page_pool_allocs",
 598                            S_IRUGO, pp_root,
 599                            &nvmap_dev->pool.allocs);
 600         debugfs_create_u64("page_pool_fills",
 601                            S_IRUGO, pp_root,
 602                            &nvmap_dev->pool.fills);
 603         debugfs_create_u64("page_pool_hits",
 604                            S_IRUGO, pp_root,
 605                            &nvmap_dev->pool.hits);
 606         debugfs_create_u64("page_pool_misses",
 607                            S_IRUGO, pp_root,
 608                            &nvmap_dev->pool.misses);
 609 #endif
 610
 611         return 0;
 612 }
 613
 614 int nvmap_page_pool_init(struct nvmap_device *dev)
 615 {
 616         static int reg = 1;
 617         unsigned long totalram_mb;
 618         struct sysinfo info;
 619         struct nvmap_page_pool *pool = &dev->pool;
 620 #ifdef CONFIG_NVMAP_PAGE_POOLS_INIT_FILLUP
 621         int i;
 622         struct page *page;
 623         int pages_to_fill;
 624         int highmem_pages = 0;
 625 #endif
 626
 627         memset(pool, 0x0, sizeof(*pool));
 628         mutex_init(&pool->lock);
 629         INIT_LIST_HEAD(&pool->page_list);
 630
 631         si_meminfo(&info);
 632         totalram_mb = (info.totalram * info.mem_unit) >> 20;
 633         pr_info("Total MB RAM: %lu\n", totalram_mb);
 634
 635         if (!CONFIG_NVMAP_PAGE_POOL_SIZE)
 636                 /* The ratio is pool pages per 1K ram pages. So, the >> 10. */
 637                 pool->max = (info.totalram * NVMAP_PP_POOL_SIZE) >> 10;
 638         else
 639                 pool->max = CONFIG_NVMAP_PAGE_POOL_SIZE;
 640
 641         if (pool->max >= info.totalram)
 642                 goto fail;
 643         pool_size = pool->max;
 644
 645         pr_info("nvmap page pool size: %u pages (%u MB)\n", pool->max,
 646                 (pool->max * info.mem_unit) >> 20);
 647
 648         if (reg) {
 649                 reg = 0;
 650                 register_shrinker(&nvmap_page_pool_shrinker);
 651         }
 652
 653         background_allocator = kthread_create(nvmap_background_zero_allocator,
 654                                             NULL, "nvmap-bz");
 655         if (IS_ERR_OR_NULL(background_allocator))
 656                 goto fail;
 657
 658 #ifdef CONFIG_NVMAP_PAGE_POOLS_INIT_FILLUP
 659         pages_to_fill = CONFIG_NVMAP_PAGE_POOLS_INIT_FILLUP_SIZE * SZ_1M /
 660                         PAGE_SIZE;
 661         pages_to_fill = pages_to_fill ? : pool->count;
 662
 663         for (i = 0; i < pages_to_fill; i++) {
 664                 page = alloc_page(GFP_NVMAP);
 665                 if (!page)
 666                         goto done;
 667                 if (!nvmap_page_pool_fill_locked(pool, page)) {
 668                         __free_page(page);
 669                         goto done;
 670                 }
 671                 if (PageHighMem(page))
 672                         highmem_pages++;
 673         }
 674
 675         si_meminfo(&info);
 676         pr_info("highmem=%d, pool_size=%d,"
 677                 "totalram=%lu, freeram=%lu, totalhigh=%lu, freehigh=%lu\n",
 678                 highmem_pages, pool->count,
 679                 info.totalram, info.freeram, info.totalhigh, info.freehigh);
 680 done:
 681 #endif
 682         return 0;
 683 fail:
 684         nvmap_page_pool_fini(dev);
 685         return -ENOMEM;
 686 }
 687
 688 int nvmap_page_pool_fini(struct nvmap_device *dev)
 689 {
 690         struct nvmap_page_pool *pool = &dev->pool;
 691
 692         if (!IS_ERR_OR_NULL(background_allocator))
 693                 kthread_stop(background_allocator);
 694
 695         WARN_ON(!list_empty(&pool->page_list));
 696
 697         return 0;
 698 }