Contributors: 25
| Author |
Tokens |
Token Proportion |
Commits |
Commit Proportion |
| Christoph Hellwig |
189 |
41.54% |
2 |
6.06% |
| Andi Kleen |
61 |
13.41% |
1 |
3.03% |
| Steven Price |
54 |
11.87% |
4 |
12.12% |
| Thomas Hellstrom |
25 |
5.49% |
1 |
3.03% |
| Suren Baghdasaryan |
24 |
5.27% |
1 |
3.03% |
| Linus Torvalds (pre-git) |
22 |
4.84% |
5 |
15.15% |
| Matt Mackall |
14 |
3.08% |
1 |
3.03% |
| Christoph Lameter |
11 |
2.42% |
1 |
3.03% |
| Naoya Horiguchi |
8 |
1.76% |
1 |
3.03% |
| Dominik Dingel |
7 |
1.54% |
1 |
3.03% |
| Tejun Heo |
5 |
1.10% |
1 |
3.03% |
| Linus Torvalds |
5 |
1.10% |
1 |
3.03% |
| Kirill A. Shutemov |
5 |
1.10% |
1 |
3.03% |
| Konstantin Khlebnikov |
4 |
0.88% |
1 |
3.03% |
| Hugh Dickins |
3 |
0.66% |
1 |
3.03% |
| Venkatesh Pallipadi |
3 |
0.66% |
1 |
3.03% |
| David S. Miller |
2 |
0.44% |
1 |
3.03% |
| David Hildenbrand |
2 |
0.44% |
1 |
3.03% |
| Andy Whitcroft |
2 |
0.44% |
1 |
3.03% |
| Martin Schwidefsky |
2 |
0.44% |
1 |
3.03% |
| Mel Gorman |
2 |
0.44% |
1 |
3.03% |
| Andrew Morton |
2 |
0.44% |
1 |
3.03% |
| Lukas Bulwahn |
1 |
0.22% |
1 |
3.03% |
| Greg Kroah-Hartman |
1 |
0.22% |
1 |
3.03% |
| Peter Xu |
1 |
0.22% |
1 |
3.03% |
| Total |
455 |
|
33 |
|
/* 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,
};
/**
* 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
* @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.
* @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.
*
* 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);
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_page_range_novma(struct mm_struct *mm, 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);
#endif /* _LINUX_PAGEWALK_H */