mm/frontswap.c

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