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