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  * This global enablement flag reduces overhead on systems where frontswap_ops
  31  * has not been registered, so is preferred to the slower alternative: a
  32  * function call that checks a non-global.
  33  */
  34 bool frontswap_enabled __read_mostly;
  35 EXPORT_SYMBOL(frontswap_enabled);
  36
  37 /*
  38  * If enabled, frontswap_store will return failure even on success.  As
  39  * a result, the swap subsystem will always write the page to swap, in
  40  * effect converting frontswap into a writethrough cache.  In this mode,
  41  * there is no direct reduction in swap writes, but a frontswap backend
  42  * can unilaterally "reclaim" any pages in use with no data loss, thus
  43  * providing increases control over maximum memory usage due to frontswap.
  44  */
  45 static bool frontswap_writethrough_enabled __read_mostly;
  46
  47 #ifdef CONFIG_DEBUG_FS
  48 /*
  49  * Counters available via /sys/kernel/debug/frontswap (if debugfs is
  50  * properly configured).  These are for information only so are not protected
  51  * against increment races.
  52  */
  53 static u64 frontswap_loads;
  54 static u64 frontswap_succ_stores;
  55 static u64 frontswap_failed_stores;
  56 static u64 frontswap_invalidates;
  57
  58 static inline void inc_frontswap_loads(void) {
  59         frontswap_loads++;
  60 }
  61 static inline void inc_frontswap_succ_stores(void) {
  62         frontswap_succ_stores++;
  63 }
  64 static inline void inc_frontswap_failed_stores(void) {
  65         frontswap_failed_stores++;
  66 }
  67 static inline void inc_frontswap_invalidates(void) {
  68         frontswap_invalidates++;
  69 }
  70 #else
  71 static inline void inc_frontswap_loads(void) { }
  72 static inline void inc_frontswap_succ_stores(void) { }
  73 static inline void inc_frontswap_failed_stores(void) { }
  74 static inline void inc_frontswap_invalidates(void) { }
  75 #endif
  76 /*
  77  * Register operations for frontswap, returning previous thus allowing
  78  * detection of multiple backends and possible nesting.
  79  */
  80 struct frontswap_ops frontswap_register_ops(struct frontswap_ops *ops)
  81 {
  82         struct frontswap_ops old = frontswap_ops;
  83
  84         frontswap_ops = *ops;
  85         frontswap_enabled = true;
  86         return old;
  87 }
  88 EXPORT_SYMBOL(frontswap_register_ops);
  89
  90 /*
  91  * Enable/disable frontswap writethrough (see above).
  92  */
  93 void frontswap_writethrough(bool enable)
  94 {
  95         frontswap_writethrough_enabled = enable;
  96 }
  97 EXPORT_SYMBOL(frontswap_writethrough);
  98
  99 /*
 100  * Called when a swap device is swapon'd.
 101  */
 102 void __frontswap_init(unsigned type)
 103 {
 104         struct swap_info_struct *sis = swap_info[type];
 105
 106         BUG_ON(sis == NULL);
 107         if (sis->frontswap_map == NULL)
 108                 return;
 109         frontswap_ops.init(type);
 110 }
 111 EXPORT_SYMBOL(__frontswap_init);
 112
 113 static inline void __frontswap_clear(struct swap_info_struct *sis, pgoff_t offset)
 114 {
 115         frontswap_clear(sis, offset);
 116         atomic_dec(&sis->frontswap_pages);
 117 }
 118
 119 /*
 120  * "Store" data from a page to frontswap and associate it with the page's
 121  * swaptype and offset.  Page must be locked and in the swap cache.
 122  * If frontswap already contains a page with matching swaptype and
 123  * offset, the frontswap implementation may either overwrite the data and
 124  * return success or invalidate the page from frontswap and return failure.
 125  */
 126 int __frontswap_store(struct page *page)
 127 {
 128         int ret = -1, dup = 0;
 129         swp_entry_t entry = { .val = page_private(page), };
 130         int type = swp_type(entry);
 131         struct swap_info_struct *sis = swap_info[type];
 132         pgoff_t offset = swp_offset(entry);
 133
 134         BUG_ON(!PageLocked(page));
 135         BUG_ON(sis == NULL);
 136         if (frontswap_test(sis, offset))
 137                 dup = 1;
 138         ret = frontswap_ops.store(type, offset, page);
 139         if (ret == 0) {
 140                 frontswap_set(sis, offset);
 141                 inc_frontswap_succ_stores();
 142                 if (!dup)
 143                         atomic_inc(&sis->frontswap_pages);
 144         } else {
 145                 /*
 146                   failed dup always results in automatic invalidate of
 147                   the (older) page from frontswap
 148                  */
 149                 inc_frontswap_failed_stores();
 150                 if (dup)
 151                         __frontswap_clear(sis, offset);
 152         }
 153         if (frontswap_writethrough_enabled)
 154                 /* report failure so swap also writes to swap device */
 155                 ret = -1;
 156         return ret;
 157 }
 158 EXPORT_SYMBOL(__frontswap_store);
 159
 160 /*
 161  * "Get" data from frontswap associated with swaptype and offset that were
 162  * specified when the data was put to frontswap and use it to fill the
 163  * specified page with data. Page must be locked and in the swap cache.
 164  */
 165 int __frontswap_load(struct page *page)
 166 {
 167         int ret = -1;
 168         swp_entry_t entry = { .val = page_private(page), };
 169         int type = swp_type(entry);
 170         struct swap_info_struct *sis = swap_info[type];
 171         pgoff_t offset = swp_offset(entry);
 172
 173         BUG_ON(!PageLocked(page));
 174         BUG_ON(sis == NULL);
 175         if (frontswap_test(sis, offset))
 176                 ret = frontswap_ops.load(type, offset, page);
 177         if (ret == 0)
 178                 inc_frontswap_loads();
 179         return ret;
 180 }
 181 EXPORT_SYMBOL(__frontswap_load);
 182
 183 /*
 184  * Invalidate any data from frontswap associated with the specified swaptype
 185  * and offset so that a subsequent "get" will fail.
 186  */
 187 void __frontswap_invalidate_page(unsigned type, pgoff_t offset)
 188 {
 189         struct swap_info_struct *sis = swap_info[type];
 190
 191         BUG_ON(sis == NULL);
 192         if (frontswap_test(sis, offset)) {
 193                 frontswap_ops.invalidate_page(type, offset);
 194                 __frontswap_clear(sis, offset);
 195                 inc_frontswap_invalidates();
 196         }
 197 }
 198 EXPORT_SYMBOL(__frontswap_invalidate_page);
 199
 200 /*
 201  * Invalidate all data from frontswap associated with all offsets for the
 202  * specified swaptype.
 203  */
 204 void __frontswap_invalidate_area(unsigned type)
 205 {
 206         struct swap_info_struct *sis = swap_info[type];
 207
 208         BUG_ON(sis == NULL);
 209         if (sis->frontswap_map == NULL)
 210                 return;
 211         frontswap_ops.invalidate_area(type);
 212         atomic_set(&sis->frontswap_pages, 0);
 213         memset(sis->frontswap_map, 0, sis->max / sizeof(long));
 214 }
 215 EXPORT_SYMBOL(__frontswap_invalidate_area);
 216
 217 static unsigned long __frontswap_curr_pages(void)
 218 {
 219         int type;
 220         unsigned long totalpages = 0;
 221         struct swap_info_struct *si = NULL;
 222
 223         assert_spin_locked(&swap_lock);
 224         for (type = swap_list.head; type >= 0; type = si->next) {
 225                 si = swap_info[type];
 226                 totalpages += atomic_read(&si->frontswap_pages);
 227         }
 228         return totalpages;
 229 }
 230
 231 static int __frontswap_unuse_pages(unsigned long total, unsigned long *unused,
 232                                         int *swapid)
 233 {
 234         int ret = -EINVAL;
 235         struct swap_info_struct *si = NULL;
 236         int si_frontswap_pages;
 237         unsigned long total_pages_to_unuse = total;
 238         unsigned long pages = 0, pages_to_unuse = 0;
 239         int type;
 240
 241         assert_spin_locked(&swap_lock);
 242         for (type = swap_list.head; type >= 0; type = si->next) {
 243                 si = swap_info[type];
 244                 si_frontswap_pages = atomic_read(&si->frontswap_pages);
 245                 if (total_pages_to_unuse < si_frontswap_pages) {
 246                         pages = pages_to_unuse = total_pages_to_unuse;
 247                 } else {
 248                         pages = si_frontswap_pages;
 249                         pages_to_unuse = 0; /* unuse all */
 250                 }
 251                 /* ensure there is enough RAM to fetch pages from frontswap */
 252                 if (security_vm_enough_memory_mm(current->mm, pages)) {
 253                         ret = -ENOMEM;
 254                         continue;
 255                 }
 256                 vm_unacct_memory(pages);
 257                 *unused = pages_to_unuse;
 258                 *swapid = type;
 259                 ret = 0;
 260                 break;
 261         }
 262
 263         return ret;
 264 }
 265
 266 static int __frontswap_shrink(unsigned long target_pages,
 267                                 unsigned long *pages_to_unuse,
 268                                 int *type)
 269 {
 270         unsigned long total_pages = 0, total_pages_to_unuse;
 271
 272         assert_spin_locked(&swap_lock);
 273
 274         total_pages = __frontswap_curr_pages();
 275         if (total_pages <= target_pages) {
 276                 /* Nothing to do */
 277                 *pages_to_unuse = 0;
 278                 return 0;
 279         }
 280         total_pages_to_unuse = total_pages - target_pages;
 281         return __frontswap_unuse_pages(total_pages_to_unuse, pages_to_unuse, type);
 282 }
 283
 284 /*
 285  * Frontswap, like a true swap device, may unnecessarily retain pages
 286  * under certain circumstances; "shrink" frontswap is essentially a
 287  * "partial swapoff" and works by calling try_to_unuse to attempt to
 288  * unuse enough frontswap pages to attempt to -- subject to memory
 289  * constraints -- reduce the number of pages in frontswap to the
 290  * number given in the parameter target_pages.
 291  */
 292 void frontswap_shrink(unsigned long target_pages)
 293 {
 294         unsigned long pages_to_unuse = 0;
 295         int type, ret;
 296
 297         /*
 298          * we don't want to hold swap_lock while doing a very
 299          * lengthy try_to_unuse, but swap_list may change
 300          * so restart scan from swap_list.head each time
 301          */
 302         spin_lock(&swap_lock);
 303         ret = __frontswap_shrink(target_pages, &pages_to_unuse, &type);
 304         spin_unlock(&swap_lock);
 305         if (ret == 0 && pages_to_unuse)
 306                 try_to_unuse(type, true, pages_to_unuse);
 307         return;
 308 }
 309 EXPORT_SYMBOL(frontswap_shrink);
 310
 311 /*
 312  * Count and return the number of frontswap pages across all
 313  * swap devices.  This is exported so that backend drivers can
 314  * determine current usage without reading debugfs.
 315  */
 316 unsigned long frontswap_curr_pages(void)
 317 {
 318         unsigned long totalpages = 0;
 319
 320         spin_lock(&swap_lock);
 321         totalpages = __frontswap_curr_pages();
 322         spin_unlock(&swap_lock);
 323
 324         return totalpages;
 325 }
 326 EXPORT_SYMBOL(frontswap_curr_pages);
 327
 328 static int __init init_frontswap(void)
 329 {
 330 #ifdef CONFIG_DEBUG_FS
 331         struct dentry *root = debugfs_create_dir("frontswap", NULL);
 332         if (root == NULL)
 333                 return -ENXIO;
 334         debugfs_create_u64("loads", S_IRUGO, root, &frontswap_loads);
 335         debugfs_create_u64("succ_stores", S_IRUGO, root, &frontswap_succ_stores);
 336         debugfs_create_u64("failed_stores", S_IRUGO, root,
 337                                 &frontswap_failed_stores);
 338         debugfs_create_u64("invalidates", S_IRUGO,
 339                                 root, &frontswap_invalidates);
 340 #endif
 341         return 0;
 342 }
 343
 344 module_init(init_frontswap);