Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : #ifndef _MM_SWAP_H
       3             : #define _MM_SWAP_H
       4             : 
       5             : #ifdef CONFIG_SWAP
       6             : #include <linux/blk_types.h> /* for bio_end_io_t */
       7             : 
       8             : /* linux/mm/page_io.c */
       9             : int sio_pool_init(void);
      10             : struct swap_iocb;
      11             : void swap_readpage(struct page *page, bool do_poll, struct swap_iocb **plug);
      12             : void __swap_read_unplug(struct swap_iocb *plug);
      13             : static inline void swap_read_unplug(struct swap_iocb *plug)
      14             : {
      15           0 :         if (unlikely(plug))
      16           0 :                 __swap_read_unplug(plug);
      17             : }
      18             : void swap_write_unplug(struct swap_iocb *sio);
      19             : int swap_writepage(struct page *page, struct writeback_control *wbc);
      20             : void __swap_writepage(struct page *page, struct writeback_control *wbc);
      21             : 
      22             : /* linux/mm/swap_state.c */
      23             : /* One swap address space for each 64M swap space */
      24             : #define SWAP_ADDRESS_SPACE_SHIFT        14
      25             : #define SWAP_ADDRESS_SPACE_PAGES        (1 << SWAP_ADDRESS_SPACE_SHIFT)
      26             : extern struct address_space *swapper_spaces[];
      27             : #define swap_address_space(entry)                           \
      28             :         (&swapper_spaces[swp_type(entry)][swp_offset(entry) \
      29             :                 >> SWAP_ADDRESS_SPACE_SHIFT])
      30             : 
      31             : void show_swap_cache_info(void);
      32             : bool add_to_swap(struct folio *folio);
      33             : void *get_shadow_from_swap_cache(swp_entry_t entry);
      34             : int add_to_swap_cache(struct folio *folio, swp_entry_t entry,
      35             :                       gfp_t gfp, void **shadowp);
      36             : void __delete_from_swap_cache(struct folio *folio,
      37             :                               swp_entry_t entry, void *shadow);
      38             : void delete_from_swap_cache(struct folio *folio);
      39             : void clear_shadow_from_swap_cache(int type, unsigned long begin,
      40             :                                   unsigned long end);
      41             : struct folio *swap_cache_get_folio(swp_entry_t entry,
      42             :                 struct vm_area_struct *vma, unsigned long addr);
      43             : struct folio *filemap_get_incore_folio(struct address_space *mapping,
      44             :                 pgoff_t index);
      45             : 
      46             : struct page *read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,
      47             :                                    struct vm_area_struct *vma,
      48             :                                    unsigned long addr,
      49             :                                    bool do_poll,
      50             :                                    struct swap_iocb **plug);
      51             : struct page *__read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,
      52             :                                      struct vm_area_struct *vma,
      53             :                                      unsigned long addr,
      54             :                                      bool *new_page_allocated);
      55             : struct page *swap_cluster_readahead(swp_entry_t entry, gfp_t flag,
      56             :                                     struct vm_fault *vmf);
      57             : struct page *swapin_readahead(swp_entry_t entry, gfp_t flag,
      58             :                               struct vm_fault *vmf);
      59             : 
      60             : static inline unsigned int folio_swap_flags(struct folio *folio)
      61             : {
      62           0 :         return page_swap_info(&folio->page)->flags;
      63             : }
      64             : #else /* CONFIG_SWAP */
      65             : struct swap_iocb;
      66             : static inline void swap_readpage(struct page *page, bool do_poll,
      67             :                 struct swap_iocb **plug)
      68             : {
      69             : }
      70             : static inline void swap_write_unplug(struct swap_iocb *sio)
      71             : {
      72             : }
      73             : 
      74             : static inline struct address_space *swap_address_space(swp_entry_t entry)
      75             : {
      76             :         return NULL;
      77             : }
      78             : 
      79             : static inline void show_swap_cache_info(void)
      80             : {
      81             : }
      82             : 
      83             : static inline struct page *swap_cluster_readahead(swp_entry_t entry,
      84             :                                 gfp_t gfp_mask, struct vm_fault *vmf)
      85             : {
      86             :         return NULL;
      87             : }
      88             : 
      89             : static inline struct page *swapin_readahead(swp_entry_t swp, gfp_t gfp_mask,
      90             :                         struct vm_fault *vmf)
      91             : {
      92             :         return NULL;
      93             : }
      94             : 
      95             : static inline int swap_writepage(struct page *p, struct writeback_control *wbc)
      96             : {
      97             :         return 0;
      98             : }
      99             : 
     100             : static inline struct folio *swap_cache_get_folio(swp_entry_t entry,
     101             :                 struct vm_area_struct *vma, unsigned long addr)
     102             : {
     103             :         return NULL;
     104             : }
     105             : 
     106             : static inline
     107             : struct folio *filemap_get_incore_folio(struct address_space *mapping,
     108             :                 pgoff_t index)
     109             : {
     110             :         return filemap_get_folio(mapping, index);
     111             : }
     112             : 
     113             : static inline bool add_to_swap(struct folio *folio)
     114             : {
     115             :         return false;
     116             : }
     117             : 
     118             : static inline void *get_shadow_from_swap_cache(swp_entry_t entry)
     119             : {
     120             :         return NULL;
     121             : }
     122             : 
     123             : static inline int add_to_swap_cache(struct folio *folio, swp_entry_t entry,
     124             :                                         gfp_t gfp_mask, void **shadowp)
     125             : {
     126             :         return -1;
     127             : }
     128             : 
     129             : static inline void __delete_from_swap_cache(struct folio *folio,
     130             :                                         swp_entry_t entry, void *shadow)
     131             : {
     132             : }
     133             : 
     134             : static inline void delete_from_swap_cache(struct folio *folio)
     135             : {
     136             : }
     137             : 
     138             : static inline void clear_shadow_from_swap_cache(int type, unsigned long begin,
     139             :                                 unsigned long end)
     140             : {
     141             : }
     142             : 
     143             : static inline unsigned int folio_swap_flags(struct folio *folio)
     144             : {
     145             :         return 0;
     146             : }
     147             : #endif /* CONFIG_SWAP */
     148             : #endif /* _MM_SWAP_H */