Merge tag 'clk-bulk-get-prep-enable' of git://git.kernel.org/pub/scm/linux/kernel...
[sfrench/cifs-2.6.git] / mm / swap_slots.c
1 /*
2  * Manage cache of swap slots to be used for and returned from
3  * swap.
4  *
5  * Copyright(c) 2016 Intel Corporation.
6  *
7  * Author: Tim Chen <tim.c.chen@linux.intel.com>
8  *
9  * We allocate the swap slots from the global pool and put
10  * it into local per cpu caches.  This has the advantage
11  * of no needing to acquire the swap_info lock every time
12  * we need a new slot.
13  *
14  * There is also opportunity to simply return the slot
15  * to local caches without needing to acquire swap_info
16  * lock.  We do not reuse the returned slots directly but
17  * move them back to the global pool in a batch.  This
18  * allows the slots to coaellesce and reduce fragmentation.
19  *
20  * The swap entry allocated is marked with SWAP_HAS_CACHE
21  * flag in map_count that prevents it from being allocated
22  * again from the global pool.
23  *
24  * The swap slots cache is protected by a mutex instead of
25  * a spin lock as when we search for slots with scan_swap_map,
26  * we can possibly sleep.
27  */
28
29 #include <linux/swap_slots.h>
30 #include <linux/cpu.h>
31 #include <linux/cpumask.h>
32 #include <linux/vmalloc.h>
33 #include <linux/mutex.h>
34 #include <linux/mm.h>
35
36 #ifdef CONFIG_SWAP
37
38 static DEFINE_PER_CPU(struct swap_slots_cache, swp_slots);
39 static bool     swap_slot_cache_active;
40 bool    swap_slot_cache_enabled;
41 static bool     swap_slot_cache_initialized;
42 DEFINE_MUTEX(swap_slots_cache_mutex);
43 /* Serialize swap slots cache enable/disable operations */
44 DEFINE_MUTEX(swap_slots_cache_enable_mutex);
45
46 static void __drain_swap_slots_cache(unsigned int type);
47 static void deactivate_swap_slots_cache(void);
48 static void reactivate_swap_slots_cache(void);
49
50 #define use_swap_slot_cache (swap_slot_cache_active && \
51                 swap_slot_cache_enabled && swap_slot_cache_initialized)
52 #define SLOTS_CACHE 0x1
53 #define SLOTS_CACHE_RET 0x2
54
55 static void deactivate_swap_slots_cache(void)
56 {
57         mutex_lock(&swap_slots_cache_mutex);
58         swap_slot_cache_active = false;
59         __drain_swap_slots_cache(SLOTS_CACHE|SLOTS_CACHE_RET);
60         mutex_unlock(&swap_slots_cache_mutex);
61 }
62
63 static void reactivate_swap_slots_cache(void)
64 {
65         mutex_lock(&swap_slots_cache_mutex);
66         swap_slot_cache_active = true;
67         mutex_unlock(&swap_slots_cache_mutex);
68 }
69
70 /* Must not be called with cpu hot plug lock */
71 void disable_swap_slots_cache_lock(void)
72 {
73         mutex_lock(&swap_slots_cache_enable_mutex);
74         swap_slot_cache_enabled = false;
75         if (swap_slot_cache_initialized) {
76                 /* serialize with cpu hotplug operations */
77                 get_online_cpus();
78                 __drain_swap_slots_cache(SLOTS_CACHE|SLOTS_CACHE_RET);
79                 put_online_cpus();
80         }
81 }
82
83 static void __reenable_swap_slots_cache(void)
84 {
85         swap_slot_cache_enabled = has_usable_swap();
86 }
87
88 void reenable_swap_slots_cache_unlock(void)
89 {
90         __reenable_swap_slots_cache();
91         mutex_unlock(&swap_slots_cache_enable_mutex);
92 }
93
94 static bool check_cache_active(void)
95 {
96         long pages;
97
98         if (!swap_slot_cache_enabled || !swap_slot_cache_initialized)
99                 return false;
100
101         pages = get_nr_swap_pages();
102         if (!swap_slot_cache_active) {
103                 if (pages > num_online_cpus() *
104                     THRESHOLD_ACTIVATE_SWAP_SLOTS_CACHE)
105                         reactivate_swap_slots_cache();
106                 goto out;
107         }
108
109         /* if global pool of slot caches too low, deactivate cache */
110         if (pages < num_online_cpus() * THRESHOLD_DEACTIVATE_SWAP_SLOTS_CACHE)
111                 deactivate_swap_slots_cache();
112 out:
113         return swap_slot_cache_active;
114 }
115
116 static int alloc_swap_slot_cache(unsigned int cpu)
117 {
118         struct swap_slots_cache *cache;
119         swp_entry_t *slots, *slots_ret;
120
121         /*
122          * Do allocation outside swap_slots_cache_mutex
123          * as kvzalloc could trigger reclaim and get_swap_page,
124          * which can lock swap_slots_cache_mutex.
125          */
126         slots = kvzalloc(sizeof(swp_entry_t) * SWAP_SLOTS_CACHE_SIZE,
127                          GFP_KERNEL);
128         if (!slots)
129                 return -ENOMEM;
130
131         slots_ret = kvzalloc(sizeof(swp_entry_t) * SWAP_SLOTS_CACHE_SIZE,
132                              GFP_KERNEL);
133         if (!slots_ret) {
134                 kvfree(slots);
135                 return -ENOMEM;
136         }
137
138         mutex_lock(&swap_slots_cache_mutex);
139         cache = &per_cpu(swp_slots, cpu);
140         if (cache->slots || cache->slots_ret)
141                 /* cache already allocated */
142                 goto out;
143         if (!cache->lock_initialized) {
144                 mutex_init(&cache->alloc_lock);
145                 spin_lock_init(&cache->free_lock);
146                 cache->lock_initialized = true;
147         }
148         cache->nr = 0;
149         cache->cur = 0;
150         cache->n_ret = 0;
151         cache->slots = slots;
152         slots = NULL;
153         cache->slots_ret = slots_ret;
154         slots_ret = NULL;
155 out:
156         mutex_unlock(&swap_slots_cache_mutex);
157         if (slots)
158                 kvfree(slots);
159         if (slots_ret)
160                 kvfree(slots_ret);
161         return 0;
162 }
163
164 static void drain_slots_cache_cpu(unsigned int cpu, unsigned int type,
165                                   bool free_slots)
166 {
167         struct swap_slots_cache *cache;
168         swp_entry_t *slots = NULL;
169
170         cache = &per_cpu(swp_slots, cpu);
171         if ((type & SLOTS_CACHE) && cache->slots) {
172                 mutex_lock(&cache->alloc_lock);
173                 swapcache_free_entries(cache->slots + cache->cur, cache->nr);
174                 cache->cur = 0;
175                 cache->nr = 0;
176                 if (free_slots && cache->slots) {
177                         kvfree(cache->slots);
178                         cache->slots = NULL;
179                 }
180                 mutex_unlock(&cache->alloc_lock);
181         }
182         if ((type & SLOTS_CACHE_RET) && cache->slots_ret) {
183                 spin_lock_irq(&cache->free_lock);
184                 swapcache_free_entries(cache->slots_ret, cache->n_ret);
185                 cache->n_ret = 0;
186                 if (free_slots && cache->slots_ret) {
187                         slots = cache->slots_ret;
188                         cache->slots_ret = NULL;
189                 }
190                 spin_unlock_irq(&cache->free_lock);
191                 if (slots)
192                         kvfree(slots);
193         }
194 }
195
196 static void __drain_swap_slots_cache(unsigned int type)
197 {
198         unsigned int cpu;
199
200         /*
201          * This function is called during
202          *      1) swapoff, when we have to make sure no
203          *         left over slots are in cache when we remove
204          *         a swap device;
205          *      2) disabling of swap slot cache, when we run low
206          *         on swap slots when allocating memory and need
207          *         to return swap slots to global pool.
208          *
209          * We cannot acquire cpu hot plug lock here as
210          * this function can be invoked in the cpu
211          * hot plug path:
212          * cpu_up -> lock cpu_hotplug -> cpu hotplug state callback
213          *   -> memory allocation -> direct reclaim -> get_swap_page
214          *   -> drain_swap_slots_cache
215          *
216          * Hence the loop over current online cpu below could miss cpu that
217          * is being brought online but not yet marked as online.
218          * That is okay as we do not schedule and run anything on a
219          * cpu before it has been marked online. Hence, we will not
220          * fill any swap slots in slots cache of such cpu.
221          * There are no slots on such cpu that need to be drained.
222          */
223         for_each_online_cpu(cpu)
224                 drain_slots_cache_cpu(cpu, type, false);
225 }
226
227 static int free_slot_cache(unsigned int cpu)
228 {
229         mutex_lock(&swap_slots_cache_mutex);
230         drain_slots_cache_cpu(cpu, SLOTS_CACHE | SLOTS_CACHE_RET, true);
231         mutex_unlock(&swap_slots_cache_mutex);
232         return 0;
233 }
234
235 int enable_swap_slots_cache(void)
236 {
237         int ret = 0;
238
239         mutex_lock(&swap_slots_cache_enable_mutex);
240         if (swap_slot_cache_initialized) {
241                 __reenable_swap_slots_cache();
242                 goto out_unlock;
243         }
244
245         ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "swap_slots_cache",
246                                 alloc_swap_slot_cache, free_slot_cache);
247         if (WARN_ONCE(ret < 0, "Cache allocation failed (%s), operating "
248                                "without swap slots cache.\n", __func__))
249                 goto out_unlock;
250
251         swap_slot_cache_initialized = true;
252         __reenable_swap_slots_cache();
253 out_unlock:
254         mutex_unlock(&swap_slots_cache_enable_mutex);
255         return 0;
256 }
257
258 /* called with swap slot cache's alloc lock held */
259 static int refill_swap_slots_cache(struct swap_slots_cache *cache)
260 {
261         if (!use_swap_slot_cache || cache->nr)
262                 return 0;
263
264         cache->cur = 0;
265         if (swap_slot_cache_active)
266                 cache->nr = get_swap_pages(SWAP_SLOTS_CACHE_SIZE, false,
267                                            cache->slots);
268
269         return cache->nr;
270 }
271
272 int free_swap_slot(swp_entry_t entry)
273 {
274         struct swap_slots_cache *cache;
275
276         cache = raw_cpu_ptr(&swp_slots);
277         if (use_swap_slot_cache && cache->slots_ret) {
278                 spin_lock_irq(&cache->free_lock);
279                 /* Swap slots cache may be deactivated before acquiring lock */
280                 if (!use_swap_slot_cache || !cache->slots_ret) {
281                         spin_unlock_irq(&cache->free_lock);
282                         goto direct_free;
283                 }
284                 if (cache->n_ret >= SWAP_SLOTS_CACHE_SIZE) {
285                         /*
286                          * Return slots to global pool.
287                          * The current swap_map value is SWAP_HAS_CACHE.
288                          * Set it to 0 to indicate it is available for
289                          * allocation in global pool
290                          */
291                         swapcache_free_entries(cache->slots_ret, cache->n_ret);
292                         cache->n_ret = 0;
293                 }
294                 cache->slots_ret[cache->n_ret++] = entry;
295                 spin_unlock_irq(&cache->free_lock);
296         } else {
297 direct_free:
298                 swapcache_free_entries(&entry, 1);
299         }
300
301         return 0;
302 }
303
304 swp_entry_t get_swap_page(struct page *page)
305 {
306         swp_entry_t entry, *pentry;
307         struct swap_slots_cache *cache;
308
309         entry.val = 0;
310
311         if (PageTransHuge(page)) {
312                 if (IS_ENABLED(CONFIG_THP_SWAP))
313                         get_swap_pages(1, true, &entry);
314                 return entry;
315         }
316
317         /*
318          * Preemption is allowed here, because we may sleep
319          * in refill_swap_slots_cache().  But it is safe, because
320          * accesses to the per-CPU data structure are protected by the
321          * mutex cache->alloc_lock.
322          *
323          * The alloc path here does not touch cache->slots_ret
324          * so cache->free_lock is not taken.
325          */
326         cache = raw_cpu_ptr(&swp_slots);
327
328         if (check_cache_active()) {
329                 mutex_lock(&cache->alloc_lock);
330                 if (cache->slots) {
331 repeat:
332                         if (cache->nr) {
333                                 pentry = &cache->slots[cache->cur++];
334                                 entry = *pentry;
335                                 pentry->val = 0;
336                                 cache->nr--;
337                         } else {
338                                 if (refill_swap_slots_cache(cache))
339                                         goto repeat;
340                         }
341                 }
342                 mutex_unlock(&cache->alloc_lock);
343                 if (entry.val)
344                         return entry;
345         }
346
347         get_swap_pages(1, false, &entry);
348
349         return entry;
350 }
351
352 #endif /* CONFIG_SWAP */