mm/frontswap.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Frontswap frontend
   4  *
   5  * This code provides the generic "frontend" layer to call a matching
   6  * "backend" driver implementation of frontswap.  See
   7  * Documentation/vm/frontswap.rst for more information.
   8  *
   9  * Copyright (C) 2009-2012 Oracle Corp.  All rights reserved.
  10  * Author: Dan Magenheimer
  11  */
  12
  13 #include <linux/mman.h>
  14 #include <linux/swap.h>
  15 #include <linux/swapops.h>
  16 #include <linux/security.h>
  17 #include <linux/module.h>
  18 #include <linux/debugfs.h>
  19 #include <linux/frontswap.h>
  20 #include <linux/swapfile.h>
  21
  22 DEFINE_STATIC_KEY_FALSE(frontswap_enabled_key);
  23
  24 /*
  25  * frontswap_ops are added by frontswap_register_ops, and provide the
  26  * frontswap "backend" implementation functions.  Multiple implementations
  27  * may be registered, but implementations can never deregister.  This
  28  * is a simple singly-linked list of all registered implementations.
  29  */
  30 static struct frontswap_ops *frontswap_ops __read_mostly;
  31
  32 #define for_each_frontswap_ops(ops)             \
  33         for ((ops) = frontswap_ops; (ops); (ops) = (ops)->next)
  34
  35 #ifdef CONFIG_DEBUG_FS
  36 /*
  37  * Counters available via /sys/kernel/debug/frontswap (if debugfs is
  38  * properly configured).  These are for information only so are not protected
  39  * against increment races.
  40  */
  41 static u64 frontswap_loads;
  42 static u64 frontswap_succ_stores;
  43 static u64 frontswap_failed_stores;
  44 static u64 frontswap_invalidates;
  45
  46 static inline void inc_frontswap_loads(void)
  47 {
  48         data_race(frontswap_loads++);
  49 }
  50 static inline void inc_frontswap_succ_stores(void)
  51 {
  52         data_race(frontswap_succ_stores++);
  53 }
  54 static inline void inc_frontswap_failed_stores(void)
  55 {
  56         data_race(frontswap_failed_stores++);
  57 }
  58 static inline void inc_frontswap_invalidates(void)
  59 {
  60         data_race(frontswap_invalidates++);
  61 }
  62 #else
  63 static inline void inc_frontswap_loads(void) { }
  64 static inline void inc_frontswap_succ_stores(void) { }
  65 static inline void inc_frontswap_failed_stores(void) { }
  66 static inline void inc_frontswap_invalidates(void) { }
  67 #endif
  68
  69 /*
  70  * Due to the asynchronous nature of the backends loading potentially
  71  * _after_ the swap system has been activated, we have chokepoints
  72  * on all frontswap functions to not call the backend until the backend
  73  * has registered.
  74  *
  75  * This would not guards us against the user deciding to call swapoff right as
  76  * we are calling the backend to initialize (so swapon is in action).
  77  * Fortunately for us, the swapon_mutex has been taken by the callee so we are
  78  * OK. The other scenario where calls to frontswap_store (called via
  79  * swap_writepage) is racing with frontswap_invalidate_area (called via
  80  * swapoff) is again guarded by the swap subsystem.
  81  *
  82  * While no backend is registered all calls to frontswap_[store|load|
  83  * invalidate_area|invalidate_page] are ignored or fail.
  84  *
  85  * The time between the backend being registered and the swap file system
  86  * calling the backend (via the frontswap_* functions) is indeterminate as
  87  * frontswap_ops is not atomic_t (or a value guarded by a spinlock).
  88  * That is OK as we are comfortable missing some of these calls to the newly
  89  * registered backend.
  90  *
  91  * Obviously the opposite (unloading the backend) must be done after all
  92  * the frontswap_[store|load|invalidate_area|invalidate_page] start
  93  * ignoring or failing the requests.  However, there is currently no way
  94  * to unload a backend once it is registered.
  95  */
  96
  97 /*
  98  * Register operations for frontswap
  99  */
 100 void frontswap_register_ops(struct frontswap_ops *ops)
 101 {
 102         DECLARE_BITMAP(a, MAX_SWAPFILES);
 103         DECLARE_BITMAP(b, MAX_SWAPFILES);
 104         struct swap_info_struct *si;
 105         unsigned int i;
 106
 107         bitmap_zero(a, MAX_SWAPFILES);
 108         bitmap_zero(b, MAX_SWAPFILES);
 109
 110         spin_lock(&swap_lock);
 111         plist_for_each_entry(si, &swap_active_head, list) {
 112                 if (!WARN_ON(!si->frontswap_map))
 113                         __set_bit(si->type, a);
 114         }
 115         spin_unlock(&swap_lock);
 116
 117         /* the new ops needs to know the currently active swap devices */
 118         for_each_set_bit(i, a, MAX_SWAPFILES)
 119                 ops->init(i);
 120
 121         /*
 122          * Setting frontswap_ops must happen after the ops->init() calls
 123          * above; cmpxchg implies smp_mb() which will ensure the init is
 124          * complete at this point.
 125          */
 126         do {
 127                 ops->next = frontswap_ops;
 128         } while (cmpxchg(&frontswap_ops, ops->next, ops) != ops->next);
 129
 130         static_branch_inc(&frontswap_enabled_key);
 131
 132         spin_lock(&swap_lock);
 133         plist_for_each_entry(si, &swap_active_head, list) {
 134                 if (si->frontswap_map)
 135                         __set_bit(si->type, b);
 136         }
 137         spin_unlock(&swap_lock);
 138
 139         /*
 140          * On the very unlikely chance that a swap device was added or
 141          * removed between setting the "a" list bits and the ops init
 142          * calls, we re-check and do init or invalidate for any changed
 143          * bits.
 144          */
 145         if (unlikely(!bitmap_equal(a, b, MAX_SWAPFILES))) {
 146                 for (i = 0; i < MAX_SWAPFILES; i++) {
 147                         if (!test_bit(i, a) && test_bit(i, b))
 148                                 ops->init(i);
 149                         else if (test_bit(i, a) && !test_bit(i, b))
 150                                 ops->invalidate_area(i);
 151                 }
 152         }
 153 }
 154 EXPORT_SYMBOL(frontswap_register_ops);
 155
 156 /*
 157  * Called when a swap device is swapon'd.
 158  */
 159 void __frontswap_init(unsigned type, unsigned long *map)
 160 {
 161         struct swap_info_struct *sis = swap_info[type];
 162         struct frontswap_ops *ops;
 163
 164         VM_BUG_ON(sis == NULL);
 165
 166         /*
 167          * p->frontswap is a bitmap that we MUST have to figure out which page
 168          * has gone in frontswap. Without it there is no point of continuing.
 169          */
 170         if (WARN_ON(!map))
 171                 return;
 172         /*
 173          * Irregardless of whether the frontswap backend has been loaded
 174          * before this function or it will be later, we _MUST_ have the
 175          * p->frontswap set to something valid to work properly.
 176          */
 177         frontswap_map_set(sis, map);
 178
 179         for_each_frontswap_ops(ops)
 180                 ops->init(type);
 181 }
 182 EXPORT_SYMBOL(__frontswap_init);
 183
 184 bool __frontswap_test(struct swap_info_struct *sis,
 185                                 pgoff_t offset)
 186 {
 187         if (sis->frontswap_map)
 188                 return test_bit(offset, sis->frontswap_map);
 189         return false;
 190 }
 191 EXPORT_SYMBOL(__frontswap_test);
 192
 193 static inline void __frontswap_set(struct swap_info_struct *sis,
 194                                    pgoff_t offset)
 195 {
 196         set_bit(offset, sis->frontswap_map);
 197         atomic_inc(&sis->frontswap_pages);
 198 }
 199
 200 static inline void __frontswap_clear(struct swap_info_struct *sis,
 201                                      pgoff_t offset)
 202 {
 203         clear_bit(offset, sis->frontswap_map);
 204         atomic_dec(&sis->frontswap_pages);
 205 }
 206
 207 /*
 208  * "Store" data from a page to frontswap and associate it with the page's
 209  * swaptype and offset.  Page must be locked and in the swap cache.
 210  * If frontswap already contains a page with matching swaptype and
 211  * offset, the frontswap implementation may either overwrite the data and
 212  * return success or invalidate the page from frontswap and return failure.
 213  */
 214 int __frontswap_store(struct page *page)
 215 {
 216         int ret = -1;
 217         swp_entry_t entry = { .val = page_private(page), };
 218         int type = swp_type(entry);
 219         struct swap_info_struct *sis = swap_info[type];
 220         pgoff_t offset = swp_offset(entry);
 221         struct frontswap_ops *ops;
 222
 223         VM_BUG_ON(!frontswap_ops);
 224         VM_BUG_ON(!PageLocked(page));
 225         VM_BUG_ON(sis == NULL);
 226
 227         /*
 228          * If a dup, we must remove the old page first; we can't leave the
 229          * old page no matter if the store of the new page succeeds or fails,
 230          * and we can't rely on the new page replacing the old page as we may
 231          * not store to the same implementation that contains the old page.
 232          */
 233         if (__frontswap_test(sis, offset)) {
 234                 __frontswap_clear(sis, offset);
 235                 for_each_frontswap_ops(ops)
 236                         ops->invalidate_page(type, offset);
 237         }
 238
 239         /* Try to store in each implementation, until one succeeds. */
 240         for_each_frontswap_ops(ops) {
 241                 ret = ops->store(type, offset, page);
 242                 if (!ret) /* successful store */
 243                         break;
 244         }
 245         if (ret == 0) {
 246                 __frontswap_set(sis, offset);
 247                 inc_frontswap_succ_stores();
 248         } else {
 249                 inc_frontswap_failed_stores();
 250         }
 251
 252         return ret;
 253 }
 254 EXPORT_SYMBOL(__frontswap_store);
 255
 256 /*
 257  * "Get" data from frontswap associated with swaptype and offset that were
 258  * specified when the data was put to frontswap and use it to fill the
 259  * specified page with data. Page must be locked and in the swap cache.
 260  */
 261 int __frontswap_load(struct page *page)
 262 {
 263         int ret = -1;
 264         swp_entry_t entry = { .val = page_private(page), };
 265         int type = swp_type(entry);
 266         struct swap_info_struct *sis = swap_info[type];
 267         pgoff_t offset = swp_offset(entry);
 268         struct frontswap_ops *ops;
 269
 270         VM_BUG_ON(!frontswap_ops);
 271         VM_BUG_ON(!PageLocked(page));
 272         VM_BUG_ON(sis == NULL);
 273
 274         if (!__frontswap_test(sis, offset))
 275                 return -1;
 276
 277         /* Try loading from each implementation, until one succeeds. */
 278         for_each_frontswap_ops(ops) {
 279                 ret = ops->load(type, offset, page);
 280                 if (!ret) /* successful load */
 281                         break;
 282         }
 283         if (ret == 0)
 284                 inc_frontswap_loads();
 285         return ret;
 286 }
 287 EXPORT_SYMBOL(__frontswap_load);
 288
 289 /*
 290  * Invalidate any data from frontswap associated with the specified swaptype
 291  * and offset so that a subsequent "get" will fail.
 292  */
 293 void __frontswap_invalidate_page(unsigned type, pgoff_t offset)
 294 {
 295         struct swap_info_struct *sis = swap_info[type];
 296         struct frontswap_ops *ops;
 297
 298         VM_BUG_ON(!frontswap_ops);
 299         VM_BUG_ON(sis == NULL);
 300
 301         if (!__frontswap_test(sis, offset))
 302                 return;
 303
 304         for_each_frontswap_ops(ops)
 305                 ops->invalidate_page(type, offset);
 306         __frontswap_clear(sis, offset);
 307         inc_frontswap_invalidates();
 308 }
 309 EXPORT_SYMBOL(__frontswap_invalidate_page);
 310
 311 /*
 312  * Invalidate all data from frontswap associated with all offsets for the
 313  * specified swaptype.
 314  */
 315 void __frontswap_invalidate_area(unsigned type)
 316 {
 317         struct swap_info_struct *sis = swap_info[type];
 318         struct frontswap_ops *ops;
 319
 320         VM_BUG_ON(!frontswap_ops);
 321         VM_BUG_ON(sis == NULL);
 322
 323         if (sis->frontswap_map == NULL)
 324                 return;
 325
 326         for_each_frontswap_ops(ops)
 327                 ops->invalidate_area(type);
 328         atomic_set(&sis->frontswap_pages, 0);
 329         bitmap_zero(sis->frontswap_map, sis->max);
 330 }
 331 EXPORT_SYMBOL(__frontswap_invalidate_area);
 332
 333 static unsigned long __frontswap_curr_pages(void)
 334 {
 335         unsigned long totalpages = 0;
 336         struct swap_info_struct *si = NULL;
 337
 338         assert_spin_locked(&swap_lock);
 339         plist_for_each_entry(si, &swap_active_head, list)
 340                 totalpages += atomic_read(&si->frontswap_pages);
 341         return totalpages;
 342 }
 343
 344 static int __frontswap_unuse_pages(unsigned long total, unsigned long *unused,
 345                                         int *swapid)
 346 {
 347         int ret = -EINVAL;
 348         struct swap_info_struct *si = NULL;
 349         int si_frontswap_pages;
 350         unsigned long total_pages_to_unuse = total;
 351         unsigned long pages = 0, pages_to_unuse = 0;
 352
 353         assert_spin_locked(&swap_lock);
 354         plist_for_each_entry(si, &swap_active_head, list) {
 355                 si_frontswap_pages = atomic_read(&si->frontswap_pages);
 356                 if (total_pages_to_unuse < si_frontswap_pages) {
 357                         pages = pages_to_unuse = total_pages_to_unuse;
 358                 } else {
 359                         pages = si_frontswap_pages;
 360                         pages_to_unuse = 0; /* unuse all */
 361                 }
 362                 /* ensure there is enough RAM to fetch pages from frontswap */
 363                 if (security_vm_enough_memory_mm(current->mm, pages)) {
 364                         ret = -ENOMEM;
 365                         continue;
 366                 }
 367                 vm_unacct_memory(pages);
 368                 *unused = pages_to_unuse;
 369                 *swapid = si->type;
 370                 ret = 0;
 371                 break;
 372         }
 373
 374         return ret;
 375 }
 376
 377 /*
 378  * Used to check if it's necessary and feasible to unuse pages.
 379  * Return 1 when nothing to do, 0 when need to shrink pages,
 380  * error code when there is an error.
 381  */
 382 static int __frontswap_shrink(unsigned long target_pages,
 383                                 unsigned long *pages_to_unuse,
 384                                 int *type)
 385 {
 386         unsigned long total_pages = 0, total_pages_to_unuse;
 387
 388         assert_spin_locked(&swap_lock);
 389
 390         total_pages = __frontswap_curr_pages();
 391         if (total_pages <= target_pages) {
 392                 /* Nothing to do */
 393                 *pages_to_unuse = 0;
 394                 return 1;
 395         }
 396         total_pages_to_unuse = total_pages - target_pages;
 397         return __frontswap_unuse_pages(total_pages_to_unuse, pages_to_unuse, type);
 398 }
 399
 400 /*
 401  * Frontswap, like a true swap device, may unnecessarily retain pages
 402  * under certain circumstances; "shrink" frontswap is essentially a
 403  * "partial swapoff" and works by calling try_to_unuse to attempt to
 404  * unuse enough frontswap pages to attempt to -- subject to memory
 405  * constraints -- reduce the number of pages in frontswap to the
 406  * number given in the parameter target_pages.
 407  */
 408 void frontswap_shrink(unsigned long target_pages)
 409 {
 410         unsigned long pages_to_unuse = 0;
 411         int type, ret;
 412
 413         /*
 414          * we don't want to hold swap_lock while doing a very
 415          * lengthy try_to_unuse, but swap_list may change
 416          * so restart scan from swap_active_head each time
 417          */
 418         spin_lock(&swap_lock);
 419         ret = __frontswap_shrink(target_pages, &pages_to_unuse, &type);
 420         spin_unlock(&swap_lock);
 421         if (ret == 0)
 422                 try_to_unuse(type, true, pages_to_unuse);
 423         return;
 424 }
 425 EXPORT_SYMBOL(frontswap_shrink);
 426
 427 /*
 428  * Count and return the number of frontswap pages across all
 429  * swap devices.  This is exported so that backend drivers can
 430  * determine current usage without reading debugfs.
 431  */
 432 unsigned long frontswap_curr_pages(void)
 433 {
 434         unsigned long totalpages = 0;
 435
 436         spin_lock(&swap_lock);
 437         totalpages = __frontswap_curr_pages();
 438         spin_unlock(&swap_lock);
 439
 440         return totalpages;
 441 }
 442 EXPORT_SYMBOL(frontswap_curr_pages);
 443
 444 static int __init init_frontswap(void)
 445 {
 446 #ifdef CONFIG_DEBUG_FS
 447         struct dentry *root = debugfs_create_dir("frontswap", NULL);
 448         if (root == NULL)
 449                 return -ENXIO;
 450         debugfs_create_u64("loads", 0444, root, &frontswap_loads);
 451         debugfs_create_u64("succ_stores", 0444, root, &frontswap_succ_stores);
 452         debugfs_create_u64("failed_stores", 0444, root,
 453                            &frontswap_failed_stores);
 454         debugfs_create_u64("invalidates", 0444, root, &frontswap_invalidates);
 455 #endif
 456         return 0;
 457 }
 458
 459 module_init(init_frontswap);