Lines Matching full:swap
6 * Swap reorganised 29.12.95, Stephen Tweedie
17 #include <linux/swap.h>
51 #include "swap.h"
61 * Some modules use swappable objects and may try to swap them out under
63 * check to see if any swap space is available.
74 static const char Bad_file[] = "Bad swap file entry ";
75 static const char Unused_file[] = "Unused swap file entry ";
76 static const char Bad_offset[] = "Bad swap offset entry ";
77 static const char Unused_offset[] = "Unused swap offset entry ";
123 /* Reclaim the swap entry anyway if possible */
126 * Reclaim the swap entry if there are no more mappings of the
130 /* Reclaim the swap entry if swap is getting full*/
133 /* returns 1 if swap entry is freed */
175 * swapon tell device that all the old swap contents can be discarded,
176 * to allow the swap device to optimize its wear-levelling.
185 /* Do not discard the swap header page! */ in discard_swap()
245 * swap allocation tell device that a cluster of swap can now be discarded,
246 * to allow the swap device to optimize its wear-levelling.
466 * taken by scan_swap_map_slots(), mark the swap entries bad (occupied). in swap_cluster_schedule_discard()
546 * If the swap is discardable, prepare discard the cluster in free_cluster()
624 * Try to get a swap entry from current cpu's swap entry pool (a cluster). This
768 * Cross the swap address space size aligned trunk, choose in set_cluster_next()
769 * another trunk randomly to avoid lock contention on swap in set_cluster_next()
774 /* No free swap slots available */ in set_cluster_next()
813 * We try to cluster swap pages by allocating them sequentially in scan_swap_map_slots()
814 * in swap. Once we've allocated SWAPFILE_CLUSTER pages this in scan_swap_map_slots()
816 * a new cluster. This prevents us from scattering swap pages in scan_swap_map_slots()
817 * all over the entire swap partition, so that we reduce in scan_swap_map_slots()
818 * overall disk seek times between swap pages. -- sct in scan_swap_map_slots()
820 * And we let swap pages go all over an SSD partition. Hugh in scan_swap_map_slots()
826 * cluster and swap cache. For HDD, sequential access is more in scan_swap_map_slots()
849 * start of partition, to minimize the span of allocated swap. in scan_swap_map_slots()
897 /* reuse swap entry of cache-only swap if not busy. */ in scan_swap_map_slots()
1011 * page swap is disabled. Warn and fail the allocation. in swap_alloc_cluster()
1223 * When we get a swap entry, if there aren't some other ways to
1224 * prevent swapoff, such as the folio in swap cache is locked, page
1225 * table lock is held, etc., the swap entry may become invalid because
1226 * of swapoff. Then, we need to enclose all swap related functions
1227 * with get_swap_device() and put_swap_device(), unless the swap
1231 * after freeing a swap entry. Therefore, immediately after
1232 * __swap_entry_free(), the swap info might become stale and should not
1235 * Check whether swap entry is valid in the swap device. If so,
1236 * return pointer to swap_info_struct, and keep the swap entry valid
1237 * via preventing the swap device from being swapoff, until
1256 * changing partly because the specified swap entry may be for another
1257 * swap device which has been swapoff. And in do_swap_page(), after
1258 * the page is read from the swap device, the PTE is verified not
1259 * changed with the page table locked to check whether the swap device
1331 * Caller has made sure that the swap device corresponding to entry
1344 * Called after dropping swapcache to decrease refcnt to swap entries.
1429 * Sort swap entries by swap device, so each lock is only taken once. in swapcache_free_entries()
1455 * This does not give an exact answer when swap count is continued,
1545 swp_entry_t entry = folio->swap; in folio_swapped()
1558 * folio_free_swap() - Free the swap space used for this folio.
1561 * If swap is getting full, or if there are no more mappings of this folio,
1562 * then call folio_free_swap to free its swap space.
1564 * Return: true if we were able to release the swap space.
1581 * hibernation is allocating its own swap pages for the image, in folio_free_swap()
1583 * the swap from a folio which has already been recorded in the in folio_free_swap()
1584 * image as a clean swapcache folio, and then reuse its swap for in folio_free_swap()
1587 * later read back in from swap, now with the wrong data. in folio_free_swap()
1601 * Free the swap entry like above, but also try to
1639 /* This is called for allocating swap entry, not cache */ in get_swap_page_of_type()
1649 * Find the swap type that corresponds to given device (if any).
1652 * from 0, in which the swap header is expected to be located.
1703 * corresponding to given index in swap_info (swap type).
1717 * Return either the total number of swap pages of given type, or the number
1749 * No need to decide whether this PTE shares the swap entry with others,
1796 * when reading from swap. This metadata may be indexed by swap entry in unuse_pte()
2113 * swap cache just before we acquired the page lock. The folio in try_to_unuse()
2114 * might even be back in swap cache on another swap area. But in try_to_unuse()
2125 * Lets check again to see if there are still swap entries in the map. in try_to_unuse()
2127 * Under global memory pressure, swap entries can be reinserted back in try_to_unuse()
2131 * above fails, that mm is likely to be freeing swap from in try_to_unuse()
2134 * folio_alloc_swap(), temporarily hiding that swap. It's easy in try_to_unuse()
2147 * After a successful try_to_unuse, if no swap is now in use, we know
2237 * A `swap extent' is a simple thing which maps a contiguous range of pages
2238 * onto a contiguous range of disk blocks. A rbtree of swap extents is
2244 * swap files identically.
2246 * Whether the swapdev is an S_ISREG file or an S_ISBLK blockdev, the swap
2256 * For all swap devices we set S_SWAPFILE across the life of the swapon. This
2257 * prevents users from writing to the swap device, which will corrupt memory.
2259 * The amount of disk space which a single swap extent represents varies.
2316 * low-to-high, while swap ordering is high-to-low in setup_swap_info()
2347 * which allocates swap pages from the highest available priority in _enable_swap_info()
2352 /* add to available list iff swap device is not full */ in _enable_swap_info()
2369 * Finished initializing swap device, now it's safe to reference it. in enable_swap_info()
2478 /* re-insert swap space back into swap_list */ in SYSCALL_DEFINE1()
2487 * Wait for swap operations protected by get/put_swap_device() in SYSCALL_DEFINE1()
2491 * the swap cache data structure. in SYSCALL_DEFINE1()
2540 /* Destroy swap account information */ in SYSCALL_DEFINE1()
2593 static void *swap_start(struct seq_file *swap, loff_t *pos) in swap_start() argument
2614 static void *swap_next(struct seq_file *swap, void *v, loff_t *pos) in swap_next() argument
2634 static void swap_stop(struct seq_file *swap, void *v) in swap_stop() argument
2639 static int swap_show(struct seq_file *swap, void *v) in swap_show() argument
2647 seq_puts(swap, "Filename\t\t\t\tType\t\tSize\t\tUsed\t\tPriority\n"); in swap_show()
2655 len = seq_file_path(swap, file, " \t\n\\"); in swap_show()
2656 seq_printf(swap, "%*s%s\t%lu\t%s%lu\t%s%d\n", in swap_show()
2807 * Find out how many pages are allowed for a single swap device. There
2809 * 1) the number of bits for the swap offset in the swp_entry_t type, and
2810 * 2) the number of bits in the swap pte, as defined by the different
2813 * In order to find the largest possible bit mask, a swap entry with
2814 * swap type 0 and swap offset ~0UL is created, encoded to a swap pte,
2815 * decoded to a swp_entry_t again, and finally the swap offset is
2820 * of a swap pte.
2844 pr_err("Unable to find swap-space signature\n"); in read_swap_header()
2848 /* swap partition endianness hack... */ in read_swap_header()
2858 /* Check the swap header's sub-version */ in read_swap_header()
2860 pr_warn("Unable to handle swap header version %d\n", in read_swap_header()
2872 pr_warn("Empty swap-file\n"); in read_swap_header()
2876 pr_warn("Truncating oversized swap area, only using %luk out of %luk\n", in read_swap_header()
2891 pr_warn("Swap area shorter than signature indicates\n"); in read_swap_header()
2962 pr_warn("Empty swap-file\n"); in setup_swap_map_and_extents()
3057 * Read the swap header. in SYSCALL_DEFINE2()
3076 /* OK, set up the swap map and apply the bad block list */ in SYSCALL_DEFINE2()
3148 * When discard is enabled for swap with no particular in SYSCALL_DEFINE2()
3149 * policy flagged, we set all swap discard flags here in in SYSCALL_DEFINE2()
3159 * perform discards for released swap page-clusters. in SYSCALL_DEFINE2()
3182 * swap device. in SYSCALL_DEFINE2()
3198 pr_info("Adding %uk swap on %s. Priority:%d extents:%d across:%lluk %s%s%s%s\n", in SYSCALL_DEFINE2()
3292 * Verify that a swap entry is valid and increment its swap map count.
3298 * - swap-cache reference is requested but there is already one. -> EEXIST
3299 * - swap-cache reference is requested but the entry is not used. -> ENOENT
3300 * - swap-mapped reference requested but needs continued swap count. -> ENOMEM
3319 * swapin_readahead() doesn't check if a swap entry is valid, so the in __swap_duplicate()
3320 * swap entry could be SWAP_MAP_BAD. Check here with lock held. in __swap_duplicate()
3352 err = -ENOENT; /* unused swap entry */ in __swap_duplicate()
3362 * Help swapoff by noting that swap entry belongs to shmem/tmpfs
3371 * Increase reference count of swap entry by 1.
3387 * @entry: swap entry for which we allocate swap cache.
3389 * Called when allocating swap cache for existing swap entry,
3391 * -EEXIST means there is a swap cache.
3434 swp_entry_t swap = page_swap_entry(page); in __page_file_index() local
3435 return swp_offset(swap); in __page_file_index()
3440 * add_swap_count_continuation - called when a swap count is duplicated
3443 * (for that entry and for its neighbouring PAGE_SIZE swap entries). Called
3475 * __swap_duplicate(): the swap device may be swapoff in add_swap_count_continuation()
3489 * The higher the swap count, the more likely it is that tasks in add_swap_count_continuation()
3490 * will race to add swap count continuation: we need to avoid in add_swap_count_continuation()
3558 * Called while __swap_duplicate() or swap_entry_free() holds swap or cluster
3676 * We've already scheduled a throttle, avoid taking the global swap in __folio_throttle_swaprate()
3701 pr_emerg("Not enough memory for swap heads, swap is disabled\n"); in swapfile_init()