/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _LINUX_PAGEWALK_H
#define _LINUX_PAGEWALK_H

#include <linux/mm.h>

struct mm_walk;

/* Locking requirement during a page walk. */
enum page_walk_lock {
 /* mmap_lock should be locked for read to stabilize the vma tree */
 PGWALK_RDLOCK = 0,
 /* vma will be write-locked during the walk */
 PGWALK_WRLOCK = 1,
 /* vma is expected to be already write-locked during the walk */
 PGWALK_WRLOCK_VERIFY = 2,
 /* vma is expected to be already read-locked during the walk */
 PGWALK_VMA_RDLOCK_VERIFY = 3,
};

/**
 * struct mm_walk_ops - callbacks for walk_page_range
 * @pgd_entry:  if set, called for each non-empty PGD (top-level) entry
 * @p4d_entry:  if set, called for each non-empty P4D entry
 * @pud_entry:  if set, called for each non-empty PUD entry
 * @pmd_entry:  if set, called for each non-empty PMD entry
 *   this handler is required to be able to handle
 *   pmd_trans_huge() pmds.  They may simply choose to
 *   split_huge_page() instead of handling it explicitly.
 * @pte_entry:  if set, called for each PTE (lowest-level) entry
 *   including empty ones, except if @install_pte is set.
 *   If @install_pte is set, @pte_entry is called only for
 *   existing PTEs.
 * @pte_hole:  if set, called for each hole at all levels,
 *   depth is -1 if not known, 0:PGD, 1:P4D, 2:PUD, 3:PMD.
 *   Any folded depths (where PTRS_PER_P?D is equal to 1)
 *   are skipped. If @install_pte is specified, this will
 *   not trigger for any populated ranges.
 * @hugetlb_entry: if set, called for each hugetlb entry. This hook
 *   function is called with the vma lock held, in order to
 *   protect against a concurrent freeing of the pte_t* or
 *   the ptl. In some cases, the hook function needs to drop
 *   and retake the vma lock in order to avoid deadlocks
 *   while calling other functions. In such cases the hook
 *   function must either refrain from accessing the pte or
 *   ptl after dropping the vma lock, or else revalidate
 *   those items after re-acquiring the vma lock and before
 *   accessing them.
 * @test_walk:  caller specific callback function to determine whether
 *   we walk over the current vma or not. Returning 0 means
 *   "do page table walk over the current vma", returning
 *   a negative value means "abort current page table walk
 *   right now" and returning 1 means "skip the current vma"
 *   Note that this callback is not called when the caller
 *   passes in a single VMA as for walk_page_vma().
 * @pre_vma:            if set, called before starting walk on a non-null vma.
 * @post_vma:           if set, called after a walk on a non-null vma, provided
 *                      that @pre_vma and the vma walk succeeded.
 * @install_pte:        if set, missing page table entries are installed and
 *                      thus all levels are always walked in the specified
 *                      range. This callback is then invoked at the PTE level
 *                      (having split any THP pages prior), providing the PTE to
 *                      install. If allocations fail, the walk is aborted. This
 *                      operation is only available for userland memory. Not
 *                      usable for hugetlb ranges.
 *
 * p?d_entry callbacks are called even if those levels are folded on a
 * particular architecture/configuration.
 */
struct mm_walk_ops {
 int (*pgd_entry)(pgd_t *pgd, unsigned long addr,
    unsigned long next, struct mm_walk *walk);
 int (*p4d_entry)(p4d_t *p4d, unsigned long addr,
    unsigned long next, struct mm_walk *walk);
 int (*pud_entry)(pud_t *pud, unsigned long addr,
    unsigned long next, struct mm_walk *walk);
 int (*pmd_entry)(pmd_t *pmd, unsigned long addr,
    unsigned long next, struct mm_walk *walk);
 int (*pte_entry)(pte_t *pte, unsigned long addr,
    unsigned long next, struct mm_walk *walk);
 int (*pte_hole)(unsigned long addr, unsigned long next,
   int depth, struct mm_walk *walk);
 int (*hugetlb_entry)(pte_t *pte, unsigned long hmask,
        unsigned long addr, unsigned long next,
        struct mm_walk *walk);
 int (*test_walk)(unsigned long addr, unsigned long next,
   struct mm_walk *walk);
 int (*pre_vma)(unsigned long start, unsigned long end,
         struct mm_walk *walk);
 void (*post_vma)(struct mm_walk *walk);
 int (*install_pte)(unsigned long addr, unsigned long next,
      pte_t *ptep, struct mm_walk *walk);
 enum page_walk_lock walk_lock;
};

/*
 * Action for pud_entry / pmd_entry callbacks.
 * ACTION_SUBTREE is the default
 */
enum page_walk_action {
 /* Descend to next level, splitting huge pages if needed and possible */
 ACTION_SUBTREE = 0,
 /* Continue to next entry at this level (ignoring any subtree) */
 ACTION_CONTINUE = 1,
 /* Call again for this entry */
 ACTION_AGAIN = 2
};

/**
 * struct mm_walk - walk_page_range data
 * @ops: operation to call during the walk
 * @mm:  mm_struct representing the target process of page table walk
 * @pgd: pointer to PGD; only valid with no_vma (otherwise set to NULL)
 * @vma: vma currently walked (NULL if walking outside vmas)
 * @action: next action to perform (see enum page_walk_action)
 * @no_vma: walk ignoring vmas (vma will always be NULL)
 * @private: private data for callbacks' usage
 *
 * (see the comment on walk_page_range() for more details)
 */
struct mm_walk {
 const struct mm_walk_ops *ops;
 struct mm_struct *mm;
 pgd_t *pgd;
 struct vm_area_struct *vma;
 enum page_walk_action action;
 bool no_vma;
 void *private;
};

int walk_page_range(struct mm_struct *mm, unsigned long start,
  unsigned long end, const struct mm_walk_ops *ops,
  void *private);
int walk_kernel_page_table_range(unsigned long start,
  unsigned long end, const struct mm_walk_ops *ops,
  pgd_t *pgd, void *private);
int walk_page_range_vma(struct vm_area_struct *vma, unsigned long start,
   unsigned long end, const struct mm_walk_ops *ops,
   void *private);
int walk_page_vma(struct vm_area_struct *vma, const struct mm_walk_ops *ops,
  void *private);
int walk_page_mapping(struct address_space *mapping, pgoff_t first_index,
        pgoff_t nr, const struct mm_walk_ops *ops,
        void *private);

typedef int __bitwise folio_walk_flags_t;

/*
 * Walk migration entries as well. Careful: a large folio might get split
 * concurrently.
 */
#define FW_MIGRATION   ((__force folio_walk_flags_t)BIT(0))

/* Walk shared zeropages (small + huge) as well. */
#define FW_ZEROPAGE   ((__force folio_walk_flags_t)BIT(1))

enum folio_walk_level {
 FW_LEVEL_PTE,
 FW_LEVEL_PMD,
 FW_LEVEL_PUD,
};

/**
 * struct folio_walk - folio_walk_start() / folio_walk_end() data
 * @page: exact folio page referenced (if applicable)
 * @level: page table level identifying the entry type
 * @pte: pointer to the page table entry (FW_LEVEL_PTE).
 * @pmd: pointer to the page table entry (FW_LEVEL_PMD).
 * @pud: pointer to the page table entry (FW_LEVEL_PUD).
 * @ptl: pointer to the page table lock.
 *
 * (see folio_walk_start() documentation for more details)
 */
struct folio_walk {
 /* public */
 struct page *page;
 enum folio_walk_level level;
 union {
  pte_t *ptep;
  pud_t *pudp;
  pmd_t *pmdp;
 };
 union {
  pte_t pte;
  pud_t pud;
  pmd_t pmd;
 };
 /* private */
 struct vm_area_struct *vma;
 spinlock_t *ptl;
};

struct folio *folio_walk_start(struct folio_walk *fw,
  struct vm_area_struct *vma, unsigned long addr,
  folio_walk_flags_t flags);

#define folio_walk_end(__fw, __vma) do { \
 spin_unlock((__fw)->ptl); \
 if (likely((__fw)->level == FW_LEVEL_PTE)) \
  pte_unmap((__fw)->ptep); \
 vma_pgtable_walk_end(__vma); \
} while (0)

#endif /* _LINUX_PAGEWALK_H */