arch/alpha/mm/init.c

121

p4d_t *p4d;

arch/alpha/mm/init.c

161

p4d = p4d_offset(pgd, VMALLOC_START);

arch/alpha/mm/init.c

162

pud = pud_offset(p4d, VMALLOC_START);

arch/arc/include/asm/pgtable-levels.h

111

#define p4d_pgtable(p4d) ((pud_t *)(p4d_val(p4d) & PAGE_MASK))

arch/arc/include/asm/pgtable-levels.h

112

#define p4d_page(p4d) virt_to_page(p4d_pgtable(p4d))

arch/arc/include/asm/pgtable-levels.h

113

#define set_p4d(p4dp, p4d) (*(p4dp) = p4d)

arch/arc/mm/fault.c

33

p4d_t *p4d, *p4d_k;

arch/arc/mm/fault.c

45

p4d = p4d_offset(pgd, address);

arch/arc/mm/fault.c

49

if (!p4d_present(*p4d))

arch/arc/mm/fault.c

50

set_p4d(p4d, *p4d_k);

arch/arc/mm/fault.c

52

pud = pud_offset(p4d, address);

arch/arm/lib/uaccess_with_memcpy.c

27

p4d_t *p4d;

arch/arm/lib/uaccess_with_memcpy.c

37

p4d = p4d_offset(pgd, addr);

arch/arm/lib/uaccess_with_memcpy.c

38

if (unlikely(p4d_none(*p4d) || p4d_bad(*p4d)))

arch/arm/lib/uaccess_with_memcpy.c

41

pud = pud_offset(p4d, addr);

arch/arm/mm/dump.c

366

static void walk_pud(struct pg_state *st, p4d_t *p4d, unsigned long start)

arch/arm/mm/dump.c

368

pud_t *pud = pud_offset(p4d, 0);

arch/arm/mm/dump.c

384

p4d_t *p4d = p4d_offset(pgd, 0);

arch/arm/mm/dump.c

388

for (i = 0; i < PTRS_PER_P4D; i++, p4d++) {

arch/arm/mm/dump.c

390

if (!p4d_none(*p4d)) {

arch/arm/mm/dump.c

391

walk_pud(st, p4d, addr);

arch/arm/mm/dump.c

393

note_page(st, addr, 2, p4d_val(*p4d), NULL);

arch/arm/mm/fault-armv.c

69

p4d_t *p4d;

arch/arm/mm/fault-armv.c

80

p4d = p4d_offset(pgd, address);

arch/arm/mm/fault-armv.c

81

if (p4d_none_or_clear_bad(p4d))

arch/arm/mm/fault-armv.c

84

pud = pud_offset(p4d, address);

arch/arm/mm/fault.c

250

p4d_t *p4d, *p4d_k;

arch/arm/mm/fault.c

259

p4d = p4d_offset(pgd, addr);

arch/arm/mm/fault.c

264

if (!p4d_present(*p4d))

arch/arm/mm/fault.c

265

set_p4d(p4d, *p4d_k);

arch/arm/mm/fault.c

267

pud = pud_offset(p4d, addr);

arch/arm/mm/fault.c

52

p4d_t *p4d;

arch/arm/mm/fault.c

57

p4d = p4d_offset(pgd, addr);

arch/arm/mm/fault.c

58

if (p4d_none(*p4d))

arch/arm/mm/fault.c

61

if (p4d_bad(*p4d)) {

arch/arm/mm/fault.c

66

pud = pud_offset(p4d, addr);

arch/arm/mm/idmap.c

72

p4d_t *p4d = p4d_offset(pgd, addr);

arch/arm/mm/idmap.c

73

pud_t *pud = pud_offset(p4d, addr);

arch/arm/mm/mmu.c

827

static void __init alloc_init_pud(p4d_t *p4d, unsigned long addr,

arch/arm/mm/mmu.c

832

pud_t *pud = pud_offset(p4d, addr);

arch/arm/mm/mmu.c

847

p4d_t *p4d = p4d_offset(pgd, addr);

arch/arm/mm/mmu.c

852

alloc_init_pud(p4d, addr, next, phys, type, alloc, ng);

arch/arm/mm/mmu.c

854

} while (p4d++, addr = next, addr != end);

arch/arm/mm/mmu.c

904

p4d_t *p4d = p4d_offset(pgd, addr);

arch/arm/mm/mmu.c

905

pud_t *pud = pud_offset(p4d, addr);

arch/arm/mm/mmu.c

992

p4d_t *p4d;

arch/arm/mm/mmu.c

995

p4d = p4d_alloc(mm, pgd_offset(mm, md->virtual), md->virtual);

arch/arm/mm/mmu.c

996

if (WARN_ON(!p4d))

arch/arm/mm/mmu.c

998

pud = pud_alloc(mm, p4d, md->virtual);

arch/arm/mm/pgd.c

143

p4d_t *p4d;

arch/arm/mm/pgd.c

155

p4d = p4d_offset(pgd, 0);

arch/arm/mm/pgd.c

156

if (p4d_none_or_clear_bad(p4d))

arch/arm/mm/pgd.c

159

pud = pud_offset(p4d, 0);

arch/arm/mm/pgd.c

176

p4d_clear(p4d);

arch/arm/mm/pgd.c

180

p4d_free(mm, p4d);

arch/arm/mm/pgd.c

191

p4d = p4d_offset(pgd, 0);

arch/arm/mm/pgd.c

192

if (p4d_none_or_clear_bad(p4d))

arch/arm/mm/pgd.c

194

pud = pud_offset(p4d, 0);

arch/arm/mm/pgd.c

201

p4d_clear(p4d);

arch/arm/mm/pgd.c

205

p4d_free(mm, p4d);

arch/arm64/include/asm/pgtable-types.h

48

typedef struct { p4dval_t p4d; } p4d_t;

arch/arm64/include/asm/pgtable-types.h

49

#define p4d_val(x) ((x).p4d)

arch/arm64/include/asm/pgtable.h

1003

static inline pud_t *p4d_pgtable(p4d_t p4d)

arch/arm64/include/asm/pgtable.h

1005

return (pud_t *)__va(p4d_page_paddr(p4d));

arch/arm64/include/asm/pgtable.h

1016

pud_t *pud_offset_lockless(p4d_t *p4dp, p4d_t p4d, unsigned long addr)

arch/arm64/include/asm/pgtable.h

1020

return (pud_t *)__va(p4d_page_paddr(p4d)) + pud_index(addr);

arch/arm64/include/asm/pgtable.h

1058

#define p4d_page(p4d) pfn_to_page(__phys_to_pfn(__p4d_to_phys(p4d)))

arch/arm64/include/asm/pgtable.h

1064

#define p4d_page_paddr(p4d) ({ BUILD_BUG(); 0;})

arch/arm64/include/asm/pgtable.h

484

static inline pte_t p4d_pte(p4d_t p4d)

arch/arm64/include/asm/pgtable.h

486

return __pte(p4d_val(p4d));

arch/arm64/include/asm/pgtable.h

731

#define __p4d_to_phys(p4d) __pte_to_phys(p4d_pte(p4d))

arch/arm64/include/asm/pgtable.h

965

#define p4d_none(p4d) (pgtable_l4_enabled() && !p4d_val(p4d))

arch/arm64/include/asm/pgtable.h

966

#define p4d_bad(p4d) (pgtable_l4_enabled() && \

arch/arm64/include/asm/pgtable.h

967

((p4d_val(p4d) & P4D_TYPE_MASK) != \

arch/arm64/include/asm/pgtable.h

969

#define p4d_present(p4d) (!p4d_none(p4d))

arch/arm64/include/asm/pgtable.h

971

static inline void set_p4d(p4d_t *p4dp, p4d_t p4d)

arch/arm64/include/asm/pgtable.h

974

set_swapper_pgd((pgd_t *)p4dp, __pgd(p4d_val(p4d)));

arch/arm64/include/asm/pgtable.h

978

WRITE_ONCE(*p4dp, p4d);

arch/arm64/include/asm/pgtable.h

988

static inline phys_addr_t p4d_page_paddr(p4d_t p4d)

arch/arm64/include/asm/pgtable.h

990

return __p4d_to_phys(p4d);

arch/arm64/include/asm/ptdump.h

68

void note_page_p4d(struct ptdump_state *st, unsigned long addr, p4d_t p4d);

arch/arm64/include/asm/ptdump.h

84

static inline void note_page_p4d(struct ptdump_state *st, unsigned long addr, p4d_t p4d) { }

arch/arm64/mm/fault.c

162

p4d_t *p4dp, p4d;

arch/arm64/mm/fault.c

171

p4d = READ_ONCE(*p4dp);

arch/arm64/mm/fault.c

172

pr_cont(", p4d=%016llx", p4d_val(p4d));

arch/arm64/mm/fault.c

173

if (p4d_none(p4d) || p4d_bad(p4d))

arch/arm64/mm/fixmap.c

77

p4d_t p4d = READ_ONCE(*p4dp);

arch/arm64/mm/fixmap.c

80

if (CONFIG_PGTABLE_LEVELS > 3 && !p4d_none(p4d) &&

arch/arm64/mm/fixmap.c

81

p4d_page_paddr(p4d) != __pa_symbol(bm_pud)) {

arch/arm64/mm/fixmap.c

90

if (p4d_none(p4d))

arch/arm64/mm/mmu.c

1572

p4d_t *p4dp, p4d;

arch/arm64/mm/mmu.c

1577

p4d = READ_ONCE(*p4dp);

arch/arm64/mm/mmu.c

1578

if (p4d_none(p4d))

arch/arm64/mm/mmu.c

1581

WARN_ON(!p4d_present(p4d));

arch/arm64/mm/mmu.c

1737

p4d_t *p4dp, p4d;

arch/arm64/mm/mmu.c

1743

p4d = READ_ONCE(*p4dp);

arch/arm64/mm/mmu.c

1744

if (p4d_none(p4d))

arch/arm64/mm/mmu.c

1747

WARN_ON(!p4d_present(p4d));

arch/arm64/mm/mmu.c

2041

p4d_t *p4dp, p4d;

arch/arm64/mm/mmu.c

2064

p4d = p4dp_get(p4dp);

arch/arm64/mm/mmu.c

2065

if (!p4d_present(p4d))

arch/arm64/mm/mmu.c

371

p4d_t p4d = READ_ONCE(*p4dp);

arch/arm64/mm/mmu.c

374

if (p4d_none(p4d)) {

arch/arm64/mm/mmu.c

389

BUG_ON(p4d_bad(p4d));

arch/arm64/mm/mmu.c

692

p4d_t *p4dp, p4d;

arch/arm64/mm/mmu.c

716

p4d = p4dp_get(p4dp);

arch/arm64/mm/mmu.c

717

if (!p4d_present(p4d))

arch/arm64/mm/ptdump.c

269

void note_page_p4d(struct ptdump_state *pt_st, unsigned long addr, p4d_t p4d)

arch/arm64/mm/ptdump.c

271

note_page(pt_st, addr, 1, p4d_val(p4d));

arch/loongarch/include/asm/pgalloc.h

37

static inline void p4d_populate(struct mm_struct *mm, p4d_t *p4d, pud_t *pud)

arch/loongarch/include/asm/pgalloc.h

39

set_p4d(p4d, __p4d((unsigned long)pud));

arch/loongarch/include/asm/pgtable.h

157

static inline int p4d_none(p4d_t p4d)

arch/loongarch/include/asm/pgtable.h

159

return p4d_val(p4d) == (unsigned long)invalid_pud_table;

arch/loongarch/include/asm/pgtable.h

162

static inline int p4d_bad(p4d_t p4d)

arch/loongarch/include/asm/pgtable.h

164

return p4d_val(p4d) & ~PAGE_MASK;

arch/loongarch/include/asm/pgtable.h

167

static inline int p4d_present(p4d_t p4d)

arch/loongarch/include/asm/pgtable.h

169

return p4d_val(p4d) != (unsigned long)invalid_pud_table;

arch/loongarch/include/asm/pgtable.h

172

static inline pud_t *p4d_pgtable(p4d_t p4d)

arch/loongarch/include/asm/pgtable.h

174

return (pud_t *)p4d_val(p4d);

arch/loongarch/include/asm/pgtable.h

177

static inline void set_p4d(p4d_t *p4d, p4d_t p4dval)

arch/loongarch/include/asm/pgtable.h

179

WRITE_ONCE(*p4d, p4dval);

arch/loongarch/include/asm/pgtable.h

187

#define p4d_phys(p4d) PHYSADDR(p4d_val(p4d))

arch/loongarch/include/asm/pgtable.h

188

#define p4d_page(p4d) (pfn_to_page(p4d_phys(p4d) >> PAGE_SHIFT))

arch/loongarch/kvm/mmu.c

673

p4d_t p4d;

arch/loongarch/kvm/mmu.c

705

p4d = p4dp_get(p4d_offset(&pgd, hva));

arch/loongarch/kvm/mmu.c

706

if (p4d_none(p4d) || !p4d_present(p4d))

arch/loongarch/kvm/mmu.c

709

pud = pudp_get(pud_offset(&p4d, hva));

arch/loongarch/mm/fault.c

37

p4d_t *p4d;

arch/loongarch/mm/fault.c

49

p4d = p4d_offset(pgd, address);

arch/loongarch/mm/fault.c

50

if (!p4d_present(p4dp_get(p4d)))

arch/loongarch/mm/fault.c

53

pud = pud_offset(p4d, address);

arch/loongarch/mm/hugetlbpage.c

20

p4d_t *p4d;

arch/loongarch/mm/hugetlbpage.c

25

p4d = p4d_alloc(mm, pgd, addr);

arch/loongarch/mm/hugetlbpage.c

26

pud = pud_alloc(mm, p4d, addr);

arch/loongarch/mm/hugetlbpage.c

37

p4d_t *p4d;

arch/loongarch/mm/hugetlbpage.c

43

p4d = p4d_offset(pgd, addr);

arch/loongarch/mm/hugetlbpage.c

44

if (p4d_present(p4dp_get(p4d))) {

arch/loongarch/mm/hugetlbpage.c

45

pud = pud_offset(p4d, addr);

arch/loongarch/mm/init.c

163

p4d_t *p4d = p4d_offset(pgd, addr);

arch/loongarch/mm/init.c

167

if (p4d_none(p4dp_get(p4d))) {

arch/loongarch/mm/init.c

169

p4d_populate(&init_mm, p4d, pud);

arch/loongarch/mm/init.c

175

pud = pud_offset(p4d, addr);

arch/loongarch/mm/kasan_init.c

24

#define __p4d_none(early, p4d) (0)

arch/loongarch/mm/kasan_init.c

26

#define __p4d_none(early, p4d) (early ? (p4d_val(p4d) == 0) : \

arch/loongarch/mm/kasan_init.c

27

(__pa(p4d_val(p4d)) == (unsigned long)__pa(kasan_early_shadow_pud)))

arch/loongarch/mm/pageattr.c

164

p4d_t *p4d;

arch/loongarch/mm/pageattr.c

179

p4d = p4d_offset(pgd, addr);

arch/loongarch/mm/pageattr.c

180

if (p4d_none(p4dp_get(p4d)))

arch/loongarch/mm/pageattr.c

182

if (p4d_leaf(p4dp_get(p4d)))

arch/loongarch/mm/pageattr.c

185

pud = pud_offset(p4d, addr);

arch/loongarch/mm/pageattr.c

41

static int pageattr_p4d_entry(p4d_t *p4d, unsigned long addr,

arch/loongarch/mm/pageattr.c

44

p4d_t val = p4dp_get(p4d);

arch/loongarch/mm/pageattr.c

48

set_p4d(p4d, val);

arch/loongarch/mm/pgtable.c

151

p4d_t *p4d;

arch/loongarch/mm/pgtable.c

173

p4d = p4d_offset(pgd, vaddr);

arch/loongarch/mm/pgtable.c

174

pud = pud_offset(p4d, vaddr);

arch/m68k/include/asm/mmu_context.h

128

p4d = p4d_offset(pgd, mmuar);

arch/m68k/include/asm/mmu_context.h

129

if (p4d_none(*p4d))

arch/m68k/include/asm/mmu_context.h

132

pud = pud_offset(p4d, mmuar);

arch/m68k/include/asm/mmu_context.h

99

p4d_t *p4d;

arch/m68k/kernel/sys_m68k.c

470

p4d_t *p4d;

arch/m68k/kernel/sys_m68k.c

481

p4d = p4d_offset(pgd, (unsigned long)mem);

arch/m68k/kernel/sys_m68k.c

482

if (!p4d_present(*p4d))

arch/m68k/kernel/sys_m68k.c

484

pud = pud_offset(p4d, (unsigned long)mem);

arch/m68k/mm/mcfmmu.c

100

p4d = p4d_offset(pgd, mmuar);

arch/m68k/mm/mcfmmu.c

101

if (p4d_none(*p4d))

arch/m68k/mm/mcfmmu.c

104

pud = pud_offset(p4d, mmuar);

arch/m68k/mm/mcfmmu.c

80

p4d_t *p4d;

arch/m68k/sun3x/dvma.c

82

p4d_t *p4d;

arch/m68k/sun3x/dvma.c

94

p4d = p4d_offset(pgd, vaddr);

arch/m68k/sun3x/dvma.c

95

pud = pud_offset(p4d, vaddr);

arch/microblaze/mm/pgtable.c

139

p4d_t *p4d;

arch/microblaze/mm/pgtable.c

146

p4d = p4d_offset(pgd_offset_k(va), va);

arch/microblaze/mm/pgtable.c

147

pud = pud_offset(p4d, va);

arch/microblaze/mm/pgtable.c

198

p4d_t *p4d;

arch/microblaze/mm/pgtable.c

206

p4d = p4d_offset(pgd, addr & PAGE_MASK);

arch/microblaze/mm/pgtable.c

207

pud = pud_offset(p4d, addr & PAGE_MASK);

arch/mips/include/asm/pgalloc.h

94

static inline void p4d_populate(struct mm_struct *mm, p4d_t *p4d, pud_t *pud)

arch/mips/include/asm/pgalloc.h

96

set_p4d(p4d, __p4d((unsigned long)pud));

arch/mips/include/asm/pgtable-64.h

184

static inline int p4d_none(p4d_t p4d)

arch/mips/include/asm/pgtable-64.h

186

return p4d_val(p4d) == (unsigned long)invalid_pud_table;

arch/mips/include/asm/pgtable-64.h

189

static inline int p4d_bad(p4d_t p4d)

arch/mips/include/asm/pgtable-64.h

191

if (unlikely(p4d_val(p4d) & ~PAGE_MASK))

arch/mips/include/asm/pgtable-64.h

197

static inline int p4d_present(p4d_t p4d)

arch/mips/include/asm/pgtable-64.h

199

return p4d_val(p4d) != (unsigned long)invalid_pud_table;

arch/mips/include/asm/pgtable-64.h

207

static inline pud_t *p4d_pgtable(p4d_t p4d)

arch/mips/include/asm/pgtable-64.h

209

return (pud_t *)p4d_val(p4d);

arch/mips/include/asm/pgtable-64.h

212

#define p4d_phys(p4d) virt_to_phys((void *)p4d_val(p4d))

arch/mips/include/asm/pgtable-64.h

213

#define p4d_page(p4d) (pfn_to_page(p4d_phys(p4d) >> PAGE_SHIFT))

arch/mips/include/asm/pgtable-64.h

217

static inline void set_p4d(p4d_t *p4d, p4d_t p4dval)

arch/mips/include/asm/pgtable-64.h

219

*p4d = p4dval;

arch/mips/kvm/mmu.c

107

p4d_t *p4d;

arch/mips/kvm/mmu.c

117

p4d = p4d_offset(pgd, addr);

arch/mips/kvm/mmu.c

118

pud = pud_offset(p4d, addr);

arch/mips/kvm/mmu.c

230

p4d_t *p4d;

arch/mips/kvm/mmu.c

242

p4d = p4d_offset(pgd, 0);

arch/mips/kvm/mmu.c

243

pud = pud_offset(p4d + i, 0);

arch/mips/kvm/mmu.c

352

p4d_t *p4d; \

arch/mips/kvm/mmu.c

363

p4d = p4d_offset(pgd, 0); \

arch/mips/kvm/mmu.c

364

pud = pud_offset(p4d + i, 0); \

arch/mips/mm/fault.c

287

p4d_t *p4d, *p4d_k;

arch/mips/mm/fault.c

299

p4d = p4d_offset(pgd, address);

arch/mips/mm/fault.c

304

pud = pud_offset(p4d, address);

arch/mips/mm/hugetlbpage.c

28

p4d_t *p4d;

arch/mips/mm/hugetlbpage.c

33

p4d = p4d_alloc(mm, pgd, addr);

arch/mips/mm/hugetlbpage.c

34

pud = pud_alloc(mm, p4d, addr);

arch/mips/mm/hugetlbpage.c

45

p4d_t *p4d;

arch/mips/mm/hugetlbpage.c

51

p4d = p4d_offset(pgd, addr);

arch/mips/mm/hugetlbpage.c

52

if (p4d_present(*p4d)) {

arch/mips/mm/hugetlbpage.c

53

pud = pud_offset(p4d, addr);

arch/mips/mm/pgtable-32.c

47

p4d_t *p4d;

arch/mips/mm/pgtable-32.c

73

p4d = p4d_offset(pgd, vaddr);

arch/mips/mm/pgtable-32.c

74

pud = pud_offset(p4d, vaddr);

arch/nios2/mm/fault.c

231

p4d_t *p4d, *p4d_k;

arch/nios2/mm/fault.c

243

p4d = p4d_offset(pgd, address);

arch/nios2/mm/fault.c

247

pud = pud_offset(p4d, address);

arch/nios2/mm/ioremap.c

89

p4d_t *p4d;

arch/nios2/mm/ioremap.c

94

p4d = p4d_alloc(&init_mm, dir, address);

arch/nios2/mm/ioremap.c

95

if (!p4d)

arch/nios2/mm/ioremap.c

97

pud = pud_alloc(&init_mm, p4d, address);

arch/openrisc/mm/fault.c

296

p4d_t *p4d, *p4d_k;

arch/openrisc/mm/fault.c

323

p4d = p4d_offset(pgd, address);

arch/openrisc/mm/fault.c

328

pud = pud_offset(p4d, address);

arch/openrisc/mm/init.c

198

p4d_t *p4d;

arch/openrisc/mm/init.c

203

p4d = p4d_offset(pgd_offset_k(va), va);

arch/openrisc/mm/init.c

204

pud = pud_offset(p4d, va);

arch/parisc/kernel/cache.c

414

p4d_t *p4d;

arch/parisc/kernel/cache.c

419

p4d = p4d_offset(pgd, addr);

arch/parisc/kernel/cache.c

420

if (!p4d_none(*p4d)) {

arch/parisc/kernel/cache.c

421

pud = pud_offset(p4d, addr);

arch/parisc/kernel/pci-dma.c

135

p4d_t *p4d;

arch/parisc/kernel/pci-dma.c

139

p4d = p4d_offset(dir, vaddr);

arch/parisc/kernel/pci-dma.c

140

pud = pud_offset(p4d, vaddr);

arch/parisc/mm/fixmap.c

17

p4d_t *p4d = p4d_offset(pgd, vaddr);

arch/parisc/mm/fixmap.c

18

pud_t *pud = pud_offset(p4d, vaddr);

arch/parisc/mm/hugetlbpage.c

30

p4d_t *p4d;

arch/parisc/mm/hugetlbpage.c

43

p4d = p4d_offset(pgd, addr);

arch/parisc/mm/hugetlbpage.c

44

pud = pud_alloc(mm, p4d, addr);

arch/parisc/mm/hugetlbpage.c

57

p4d_t *p4d;

arch/parisc/mm/hugetlbpage.c

66

p4d = p4d_offset(pgd, addr);

arch/parisc/mm/hugetlbpage.c

67

if (!p4d_none(*p4d)) {

arch/parisc/mm/hugetlbpage.c

68

pud = pud_offset(p4d, addr);

arch/parisc/mm/init.c

375

p4d_t *p4d = p4d_offset(pgd, vaddr);

arch/parisc/mm/init.c

376

pud_t *pud = pud_offset(p4d, vaddr);

arch/parisc/mm/init.c

666

p4d_t *p4d = p4d_offset(pgd, addr);

arch/parisc/mm/init.c

667

pud_t *pud = pud_offset(p4d, addr);

arch/powerpc/include/asm/book3s/64/hash.h

152

static inline int hash__p4d_bad(p4d_t p4d)

arch/powerpc/include/asm/book3s/64/hash.h

154

return (p4d_val(p4d) == 0);

arch/powerpc/include/asm/book3s/64/pgtable.h

939

#define p4d_write(p4d) pte_write(p4d_pte(p4d))

arch/powerpc/include/asm/book3s/64/pgtable.h

946

static inline int p4d_none(p4d_t p4d)

arch/powerpc/include/asm/book3s/64/pgtable.h

948

return !p4d_raw(p4d);

arch/powerpc/include/asm/book3s/64/pgtable.h

951

static inline int p4d_present(p4d_t p4d)

arch/powerpc/include/asm/book3s/64/pgtable.h

953

return !!(p4d_raw(p4d) & cpu_to_be64(_PAGE_PRESENT));

arch/powerpc/include/asm/book3s/64/pgtable.h

956

static inline pte_t p4d_pte(p4d_t p4d)

arch/powerpc/include/asm/book3s/64/pgtable.h

958

return __pte_raw(p4d_raw(p4d));

arch/powerpc/include/asm/book3s/64/pgtable.h

966

static inline int p4d_bad(p4d_t p4d)

arch/powerpc/include/asm/book3s/64/pgtable.h

969

return radix__p4d_bad(p4d);

arch/powerpc/include/asm/book3s/64/pgtable.h

970

return hash__p4d_bad(p4d);

arch/powerpc/include/asm/book3s/64/pgtable.h

974

static inline bool p4d_access_permitted(p4d_t p4d, bool write)

arch/powerpc/include/asm/book3s/64/pgtable.h

976

return pte_access_permitted(p4d_pte(p4d), write);

arch/powerpc/include/asm/book3s/64/pgtable.h

979

extern struct page *p4d_page(p4d_t p4d);

arch/powerpc/include/asm/book3s/64/pgtable.h

984

static inline pud_t *p4d_pgtable(p4d_t p4d)

arch/powerpc/include/asm/book3s/64/pgtable.h

986

return (pud_t *)__va(p4d_val(p4d) & ~P4D_MASKED_BITS);

arch/powerpc/include/asm/book3s/64/radix.h

258

static inline int radix__p4d_bad(p4d_t p4d)

arch/powerpc/include/asm/book3s/64/radix.h

260

return !!(p4d_val(p4d) & RADIX_P4D_BAD_BITS);

arch/powerpc/include/asm/nohash/64/pgalloc.h

18

static inline void p4d_populate(struct mm_struct *mm, p4d_t *p4d, pud_t *pud)

arch/powerpc/include/asm/nohash/64/pgalloc.h

20

p4d_set(p4d, (unsigned long)pud);

arch/powerpc/include/asm/nohash/64/pgtable-4k.h

56

#define p4d_none(p4d) (!p4d_val(p4d))

arch/powerpc/include/asm/nohash/64/pgtable-4k.h

57

#define p4d_bad(p4d) (p4d_val(p4d) == 0)

arch/powerpc/include/asm/nohash/64/pgtable-4k.h

58

#define p4d_present(p4d) (p4d_val(p4d) != 0)

arch/powerpc/include/asm/nohash/64/pgtable-4k.h

62

static inline pud_t *p4d_pgtable(p4d_t p4d)

arch/powerpc/include/asm/nohash/64/pgtable-4k.h

64

return (pud_t *) (p4d_val(p4d) & ~P4D_MASKED_BITS);

arch/powerpc/include/asm/nohash/64/pgtable-4k.h

72

static inline pte_t p4d_pte(p4d_t p4d)

arch/powerpc/include/asm/nohash/64/pgtable-4k.h

74

return __pte(p4d_val(p4d));

arch/powerpc/include/asm/nohash/64/pgtable-4k.h

81

extern struct page *p4d_page(p4d_t p4d);

arch/powerpc/include/asm/nohash/64/pgtable.h

141

#define p4d_write(pgd) pte_write(p4d_pte(p4d))

arch/powerpc/kvm/book3s_64_mmu_radix.c

1291

p4d_t p4d, *p4dp;

arch/powerpc/kvm/book3s_64_mmu_radix.c

1365

p4d = READ_ONCE(*p4dp);

arch/powerpc/kvm/book3s_64_mmu_radix.c

1366

if (!(p4d_val(p4d) & _PAGE_PRESENT)) {

arch/powerpc/kvm/book3s_64_mmu_radix.c

1371

pudp = pud_offset(&p4d, gpa);

arch/powerpc/kvm/book3s_64_mmu_radix.c

553

p4d_t *p4d = p4d_offset(pgd, 0);

arch/powerpc/kvm/book3s_64_mmu_radix.c

556

if (!p4d_present(*p4d))

arch/powerpc/kvm/book3s_64_mmu_radix.c

558

pud = pud_offset(p4d, 0);

arch/powerpc/kvm/book3s_64_mmu_radix.c

560

p4d_clear(p4d);

arch/powerpc/kvm/book3s_64_mmu_radix.c

621

p4d_t *p4d;

arch/powerpc/kvm/book3s_64_mmu_radix.c

629

p4d = p4d_offset(pgd, gpa);

arch/powerpc/kvm/book3s_64_mmu_radix.c

632

if (p4d_present(*p4d))

arch/powerpc/kvm/book3s_64_mmu_radix.c

633

pud = pud_offset(p4d, gpa);

arch/powerpc/kvm/book3s_64_mmu_radix.c

654

if (p4d_none(*p4d)) {

arch/powerpc/kvm/book3s_64_mmu_radix.c

657

p4d_populate(kvm->mm, p4d, new_pud);

arch/powerpc/kvm/book3s_64_mmu_radix.c

660

pud = pud_offset(p4d, gpa);

arch/powerpc/mm/book3s64/radix_pgtable.c

1120

p4d_t *p4d;

arch/powerpc/mm/book3s64/radix_pgtable.c

1149

p4d = p4d_offset(pgd, addr);

arch/powerpc/mm/book3s64/radix_pgtable.c

1150

pud = vmemmap_pud_alloc(p4d, node, addr);

arch/powerpc/mm/book3s64/radix_pgtable.c

1225

p4d_t *p4d;

arch/powerpc/mm/book3s64/radix_pgtable.c

1231

p4d = p4d_offset(pgd, addr);

arch/powerpc/mm/book3s64/radix_pgtable.c

1232

pud = vmemmap_pud_alloc(p4d, node, addr);

arch/powerpc/mm/book3s64/radix_pgtable.c

1257

p4d_t *p4d;

arch/powerpc/mm/book3s64/radix_pgtable.c

1266

p4d = p4d_offset(pgd, map_addr);

arch/powerpc/mm/book3s64/radix_pgtable.c

1267

pud = vmemmap_pud_alloc(p4d, node, map_addr);

arch/powerpc/mm/book3s64/radix_pgtable.c

1320

p4d_t *p4d;

arch/powerpc/mm/book3s64/radix_pgtable.c

1328

p4d = p4d_offset(pgd, addr);

arch/powerpc/mm/book3s64/radix_pgtable.c

1329

pud = vmemmap_pud_alloc(p4d, node, addr);

arch/powerpc/mm/book3s64/radix_pgtable.c

723

static void free_pud_table(pud_t *pud_start, p4d_t *p4d)

arch/powerpc/mm/book3s64/radix_pgtable.c

735

p4d_clear(p4d);

arch/powerpc/mm/book3s64/radix_pgtable.c

901

p4d_t *p4d;

arch/powerpc/mm/book3s64/radix_pgtable.c

909

p4d = p4d_offset(pgd, addr);

arch/powerpc/mm/book3s64/radix_pgtable.c

910

if (!p4d_present(*p4d))

arch/powerpc/mm/book3s64/radix_pgtable.c

913

if (p4d_leaf(*p4d)) {

arch/powerpc/mm/book3s64/radix_pgtable.c

924

pud_base = p4d_pgtable(*p4d);

arch/powerpc/mm/book3s64/radix_pgtable.c

926

free_pud_table(pud_base, p4d);

arch/powerpc/mm/book3s64/subpage_prot.c

57

p4d_t *p4d;

arch/powerpc/mm/book3s64/subpage_prot.c

64

p4d = p4d_offset(pgd, addr);

arch/powerpc/mm/book3s64/subpage_prot.c

65

if (p4d_none(*p4d))

arch/powerpc/mm/book3s64/subpage_prot.c

67

pud = pud_offset(p4d, addr);

arch/powerpc/mm/hugetlbpage.c

46

p4d_t *p4d;

arch/powerpc/mm/hugetlbpage.c

52

p4d = p4d_offset(pgd_offset(mm, addr), addr);

arch/powerpc/mm/hugetlbpage.c

54

return (pte_t *)p4d;

arch/powerpc/mm/hugetlbpage.c

56

pud = pud_alloc(mm, p4d, addr);

arch/powerpc/mm/kasan/init_book3e_64.c

17

static inline bool kasan_pud_table(p4d_t p4d)

arch/powerpc/mm/kasan/init_book3e_64.c

19

return p4d_page(p4d) == virt_to_page(lm_alias(kasan_early_shadow_pud));

arch/powerpc/mm/pgtable.c

390

p4d_t *p4d;

arch/powerpc/mm/pgtable.c

400

p4d = p4d_offset(pgd, addr);

arch/powerpc/mm/pgtable.c

401

BUG_ON(p4d_none(*p4d));

arch/powerpc/mm/pgtable.c

402

pud = pud_offset(p4d, addr);

arch/powerpc/mm/pgtable.c

445

p4d_t p4d, *p4dp;

arch/powerpc/mm/pgtable.c

471

p4d = READ_ONCE(*p4dp);

arch/powerpc/mm/pgtable.c

474

if (p4d_none(p4d))

arch/powerpc/mm/pgtable.c

477

if (p4d_leaf(p4d)) {

arch/powerpc/mm/pgtable.c

488

pudp = pud_offset(&p4d, ea);

arch/powerpc/mm/pgtable_64.c

101

struct page *p4d_page(p4d_t p4d)

arch/powerpc/mm/pgtable_64.c

103

if (p4d_leaf(p4d)) {

arch/powerpc/mm/pgtable_64.c

105

VM_WARN_ON(!p4d_leaf(p4d));

arch/powerpc/mm/pgtable_64.c

106

return pte_page(p4d_pte(p4d));

arch/powerpc/mm/pgtable_64.c

108

return virt_to_page(p4d_pgtable(p4d));

arch/powerpc/mm/ptdump/hashpagetable.c

428

static void walk_pud(struct pg_state *st, p4d_t *p4d, unsigned long start)

arch/powerpc/mm/ptdump/hashpagetable.c

430

pud_t *pud = pud_offset(p4d, 0);

arch/powerpc/mm/ptdump/hashpagetable.c

444

p4d_t *p4d = p4d_offset(pgd, 0);

arch/powerpc/mm/ptdump/hashpagetable.c

448

for (i = 0; i < PTRS_PER_P4D; i++, p4d++) {

arch/powerpc/mm/ptdump/hashpagetable.c

450

if (!p4d_none(*p4d))

arch/powerpc/mm/ptdump/hashpagetable.c

452

walk_pud(st, p4d, addr);

arch/powerpc/mm/ptdump/ptdump.c

317

static void note_page_p4d(struct ptdump_state *pt_st, unsigned long addr, p4d_t p4d)

arch/powerpc/mm/ptdump/ptdump.c

319

note_page(pt_st, addr, 1, p4d_val(p4d));

arch/riscv/include/asm/pgalloc.h

100

tlb_remove_ptdesc(tlb, virt_to_ptdesc(p4d));

arch/riscv/include/asm/pgalloc.h

42

static inline void p4d_populate(struct mm_struct *mm, p4d_t *p4d, pud_t *pud)

arch/riscv/include/asm/pgalloc.h

47

set_p4d(p4d, __p4d((pfn << _PAGE_PFN_SHIFT) | _PAGE_TABLE));

arch/riscv/include/asm/pgalloc.h

51

static inline void p4d_populate_safe(struct mm_struct *mm, p4d_t *p4d,

arch/riscv/include/asm/pgalloc.h

57

set_p4d_safe(p4d,

arch/riscv/include/asm/pgalloc.h

62

static inline void pgd_populate(struct mm_struct *mm, pgd_t *pgd, p4d_t *p4d)

arch/riscv/include/asm/pgalloc.h

65

unsigned long pfn = virt_to_pfn(p4d);

arch/riscv/include/asm/pgalloc.h

72

p4d_t *p4d)

arch/riscv/include/asm/pgalloc.h

75

unsigned long pfn = virt_to_pfn(p4d);

arch/riscv/include/asm/pgalloc.h

96

static inline void __p4d_free_tlb(struct mmu_gather *tlb, p4d_t *p4d,

arch/riscv/include/asm/pgtable-64.h

276

static inline void set_p4d(p4d_t *p4dp, p4d_t p4d)

arch/riscv/include/asm/pgtable-64.h

279

WRITE_ONCE(*p4dp, p4d);

arch/riscv/include/asm/pgtable-64.h

281

set_pud((pud_t *)p4dp, (pud_t){ p4d_val(p4d) });

arch/riscv/include/asm/pgtable-64.h

284

static inline int p4d_none(p4d_t p4d)

arch/riscv/include/asm/pgtable-64.h

287

return (p4d_val(p4d) == 0);

arch/riscv/include/asm/pgtable-64.h

292

static inline int p4d_present(p4d_t p4d)

arch/riscv/include/asm/pgtable-64.h

295

return (p4d_val(p4d) & _PAGE_PRESENT);

arch/riscv/include/asm/pgtable-64.h

300

static inline int p4d_bad(p4d_t p4d)

arch/riscv/include/asm/pgtable-64.h

303

return !p4d_present(p4d);

arch/riscv/include/asm/pgtable-64.h

308

static inline void p4d_clear(p4d_t *p4d)

arch/riscv/include/asm/pgtable-64.h

311

set_p4d(p4d, __p4d(0));

arch/riscv/include/asm/pgtable-64.h

319

static inline unsigned long _p4d_pfn(p4d_t p4d)

arch/riscv/include/asm/pgtable-64.h

321

return __page_val_to_pfn(p4d_val(p4d));

arch/riscv/include/asm/pgtable-64.h

324

static inline pud_t *p4d_pgtable(p4d_t p4d)

arch/riscv/include/asm/pgtable-64.h

327

return (pud_t *)pfn_to_virt(__page_val_to_pfn(p4d_val(p4d)));

arch/riscv/include/asm/pgtable-64.h

329

return (pud_t *)pud_pgtable((pud_t) { p4d_val(p4d) });

arch/riscv/include/asm/pgtable-64.h

331

#define p4d_page_vaddr(p4d) ((unsigned long)p4d_pgtable(p4d))

arch/riscv/include/asm/pgtable-64.h

333

static inline struct page *p4d_page(p4d_t p4d)

arch/riscv/include/asm/pgtable-64.h

335

return pfn_to_page(__page_val_to_pfn(p4d_val(p4d)));

arch/riscv/include/asm/pgtable-64.h

341

pud_t *pud_offset(p4d_t *p4d, unsigned long address);

arch/riscv/include/asm/pgtable-64.h

46

unsigned long p4d;

arch/riscv/include/asm/pgtable-64.h

49

#define p4d_val(x) ((x).p4d)

arch/riscv/include/asm/pgtable.h

1285

#define set_p4d_safe(p4dp, p4d) \

arch/riscv/include/asm/pgtable.h

1287

WARN_ON_ONCE(p4d_present(*p4dp) && !p4d_same(*p4dp, p4d)); \

arch/riscv/include/asm/pgtable.h

1288

set_p4d(p4dp, p4d); \

arch/riscv/kernel/hibernate.c

293

p4d_t p4d = READ_ONCE(*src_p4dp);

arch/riscv/kernel/hibernate.c

297

if (p4d_none(p4d))

arch/riscv/kernel/hibernate.c

300

if (p4d_leaf(p4d)) {

arch/riscv/kernel/hibernate.c

301

set_p4d(dst_p4dp, __p4d(p4d_val(p4d) | pgprot_val(prot)));

arch/riscv/kvm/mmu.c

367

p4d_t p4d;

arch/riscv/kvm/mmu.c

389

p4d = p4dp_get(p4d_offset(&pgd, hva));

arch/riscv/kvm/mmu.c

390

if (p4d_none(p4d) || !p4d_present(p4d))

arch/riscv/kvm/mmu.c

393

pud = pudp_get(pud_offset(&p4d, hva));

arch/riscv/mm/fault.c

31

p4d_t *p4dp, p4d;

arch/riscv/mm/fault.c

51

p4d = p4dp_get(p4dp);

arch/riscv/mm/fault.c

52

pr_cont(", p4d=%016lx", p4d_val(p4d));

arch/riscv/mm/fault.c

53

if (p4d_none(p4d) || p4d_bad(p4d) || p4d_leaf(p4d))

arch/riscv/mm/hugetlbpage.c

100

if (!p4d_present(p4dp_get(p4d)))

arch/riscv/mm/hugetlbpage.c

103

pud = pud_offset(p4d, addr);

arch/riscv/mm/hugetlbpage.c

38

p4d_t *p4d;

arch/riscv/mm/hugetlbpage.c

43

p4d = p4d_alloc(mm, pgd, addr);

arch/riscv/mm/hugetlbpage.c

44

if (!p4d)

arch/riscv/mm/hugetlbpage.c

47

pud = pud_alloc(mm, p4d, addr);

arch/riscv/mm/hugetlbpage.c

91

p4d_t *p4d;

arch/riscv/mm/hugetlbpage.c

99

p4d = p4d_offset(pgd, addr);

arch/riscv/mm/init.c

1402

p4d_t *p4d;

arch/riscv/mm/init.c

1407

p4d = p4d_alloc(&init_mm, pgd, addr);

arch/riscv/mm/init.c

1408

if (!p4d)

arch/riscv/mm/init.c

1415

pud = pud_alloc(&init_mm, p4d, addr);

arch/riscv/mm/init.c

1531

static void __meminit free_pud_table(pud_t *pud_start, p4d_t *p4d)

arch/riscv/mm/init.c

1533

struct page *page = p4d_page(*p4d);

arch/riscv/mm/init.c

1547

p4d_clear(p4d);

arch/riscv/mm/init.c

1655

p4d_t *p4dp, p4d;

arch/riscv/mm/init.c

1661

p4d = p4dp_get(p4dp);

arch/riscv/mm/init.c

1662

if (!p4d_present(p4d))

arch/riscv/mm/init.c

1665

if (p4d_leaf(p4d)) {

arch/riscv/mm/init.c

1669

free_vmemmap_storage(p4d_page(p4d), P4D_SIZE, altmap);

arch/riscv/mm/kasan_init.c

377

static void __init kasan_shallow_populate_pud(p4d_t *p4d,

arch/riscv/mm/kasan_init.c

382

pud_t *pud_k = pud_offset(p4d, vaddr);

arch/riscv/mm/kasan_init.c

80

static void __init kasan_populate_pud(p4d_t *p4d,

arch/riscv/mm/kasan_init.c

87

if (p4d_none(p4dp_get(p4d))) {

arch/riscv/mm/kasan_init.c

89

set_p4d(p4d, pfn_p4d(PFN_DOWN(__pa(p)), PAGE_TABLE));

arch/riscv/mm/kasan_init.c

92

pudp = pud_offset(p4d, vaddr);

arch/riscv/mm/pageattr.c

29

static int pageattr_p4d_entry(p4d_t *p4d, unsigned long addr,

arch/riscv/mm/pageattr.c

32

p4d_t val = p4dp_get(p4d);

arch/riscv/mm/pageattr.c

36

set_p4d(p4d, val);

arch/riscv/mm/pageattr.c

440

p4d_t *p4d;

arch/riscv/mm/pageattr.c

450

p4d = p4d_offset(pgd, addr);

arch/riscv/mm/pageattr.c

451

if (!p4d_present(p4dp_get(p4d)))

arch/riscv/mm/pageattr.c

453

if (p4d_leaf(p4dp_get(p4d)))

arch/riscv/mm/pageattr.c

456

pud = pud_offset(p4d, addr);

arch/riscv/mm/pgtable.c

42

pud_t *pud_offset(p4d_t *p4d, unsigned long address)

arch/riscv/mm/pgtable.c

45

return p4d_pgtable(p4dp_get(p4d)) + pud_index(address);

arch/riscv/mm/pgtable.c

47

return (pud_t *)p4d;

arch/riscv/mm/pgtable.c

62

int p4d_set_huge(p4d_t *p4d, phys_addr_t addr, pgprot_t prot)

arch/riscv/mm/pgtable.c

67

void p4d_clear_huge(p4d_t *p4d)

arch/riscv/mm/ptdump.c

336

static void note_page_p4d(struct ptdump_state *pt_st, unsigned long addr, p4d_t p4d)

arch/riscv/mm/ptdump.c

338

note_page(pt_st, addr, 1, p4d_val(p4d));

arch/s390/boot/vmem.c

148

static bool kasan_p4d_populate_zero_shadow(p4d_t *p4d, unsigned long addr,

arch/s390/boot/vmem.c

153

p4d_populate(&init_mm, p4d, kasan_early_shadow_pud);

arch/s390/boot/vmem.c

201

static inline bool kasan_p4d_populate_zero_shadow(p4d_t *p4d, unsigned long addr,

arch/s390/boot/vmem.c

387

static void pgtable_pud_populate(p4d_t *p4d, unsigned long addr, unsigned long end,

arch/s390/boot/vmem.c

394

pud = pud_offset(p4d, addr);

arch/s390/boot/vmem.c

424

p4d_t *p4d;

arch/s390/boot/vmem.c

427

p4d = p4d_offset(pgd, addr);

arch/s390/boot/vmem.c

428

for (; addr < end; addr = next, p4d++) {

arch/s390/boot/vmem.c

430

if (p4d_none(p4dp_get(p4d))) {

arch/s390/boot/vmem.c

431

if (kasan_p4d_populate_zero_shadow(p4d, addr, next, mode))

arch/s390/boot/vmem.c

434

p4d_populate(&init_mm, p4d, pud);

arch/s390/boot/vmem.c

436

pgtable_pud_populate(p4d, addr, next, mode);

arch/s390/boot/vmem.c

444

p4d_t *p4d;

arch/s390/boot/vmem.c

459

p4d = boot_crst_alloc(_REGION2_ENTRY_EMPTY);

arch/s390/boot/vmem.c

460

pgd_populate(&init_mm, pgd, p4d);

arch/s390/include/asm/page.h

113

DEFINE_PGVAL_FUNC(p4d)

arch/s390/include/asm/page.h

83

typedef struct { unsigned long p4d; } p4d_t;

arch/s390/include/asm/pgalloc.h

118

static inline void pgd_populate(struct mm_struct *mm, pgd_t *pgd, p4d_t *p4d)

arch/s390/include/asm/pgalloc.h

120

set_pgd(pgd, __pgd(_REGION1_ENTRY | __pa(p4d)));

arch/s390/include/asm/pgalloc.h

123

static inline void p4d_populate(struct mm_struct *mm, p4d_t *p4d, pud_t *pud)

arch/s390/include/asm/pgalloc.h

125

set_p4d(p4d, __p4d(_REGION2_ENTRY | __pa(pud)));

arch/s390/include/asm/pgalloc.h

64

static inline void p4d_free(struct mm_struct *mm, p4d_t *p4d)

arch/s390/include/asm/pgalloc.h

69

pagetable_dtor(virt_to_ptdesc(p4d));

arch/s390/include/asm/pgalloc.h

70

crst_table_free(mm, (unsigned long *) p4d);

arch/s390/include/asm/pgtable.h

1034

static inline void p4d_clear(p4d_t *p4d)

arch/s390/include/asm/pgtable.h

1036

if ((p4d_val(p4dp_get(p4d)) & _REGION_ENTRY_TYPE_MASK) == _REGION_ENTRY_TYPE_R2)

arch/s390/include/asm/pgtable.h

1037

set_p4d(p4d, __p4d(_REGION2_ENTRY_EMPTY));

arch/s390/include/asm/pgtable.h

1464

static inline pud_t *pud_offset_lockless(p4d_t *p4dp, p4d_t p4d, unsigned long address)

arch/s390/include/asm/pgtable.h

1466

if ((p4d_val(p4d) & _REGION_ENTRY_TYPE_MASK) >= _REGION_ENTRY_TYPE_R2)

arch/s390/include/asm/pgtable.h

1467

return (pud_t *) p4d_deref(p4d) + pud_index(address);

arch/s390/include/asm/pgtable.h

1509

#define p4d_page(p4d) pfn_to_page(p4d_pfn(p4d))

arch/s390/include/asm/pgtable.h

692

static inline int p4d_folded(p4d_t p4d)

arch/s390/include/asm/pgtable.h

694

return (p4d_val(p4d) & _REGION_ENTRY_TYPE_MASK) < _REGION_ENTRY_TYPE_R2;

arch/s390/include/asm/pgtable.h

697

static inline int p4d_present(p4d_t p4d)

arch/s390/include/asm/pgtable.h

699

if (p4d_folded(p4d))

arch/s390/include/asm/pgtable.h

701

return (p4d_val(p4d) & _REGION_ENTRY_ORIGIN) != 0UL;

arch/s390/include/asm/pgtable.h

704

static inline int p4d_none(p4d_t p4d)

arch/s390/include/asm/pgtable.h

706

if (p4d_folded(p4d))

arch/s390/include/asm/pgtable.h

708

return p4d_val(p4d) == _REGION2_ENTRY_EMPTY;

arch/s390/include/asm/pgtable.h

711

static inline unsigned long p4d_pfn(p4d_t p4d)

arch/s390/include/asm/pgtable.h

716

return (p4d_val(p4d) & origin_mask) >> PAGE_SHIFT;

arch/s390/include/asm/pgtable.h

775

static inline int p4d_bad(p4d_t p4d)

arch/s390/include/asm/pgtable.h

777

unsigned long type = p4d_val(p4d) & _REGION_ENTRY_TYPE_MASK;

arch/s390/include/asm/pgtable.h

783

return (p4d_val(p4d) & ~_REGION_ENTRY_BITS) != 0;

arch/s390/include/asm/pgtable.h

966

static inline void set_p4d(p4d_t *p4dp, p4d_t p4d)

arch/s390/include/asm/pgtable.h

968

WRITE_ONCE(*p4dp, p4d);

arch/s390/include/asm/tlb.h

114

static inline void p4d_free_tlb(struct mmu_gather *tlb, p4d_t *p4d,

arch/s390/include/asm/tlb.h

122

tlb_remove_ptdesc(tlb, virt_to_ptdesc(p4d));

arch/s390/kvm/dat.c

434

if (entry.p4d.h.i) {

arch/s390/kvm/dat.c

442

table = dereference_crste(entry.p4d);

arch/s390/kvm/dat.h

294

union p4d p4d;

arch/s390/kvm/dat.h

313

static_assert(sizeof(union p4d) == sizeof(unsigned long));

arch/s390/kvm/dat.h

327

union p4d p4ds[_CRST_ENTRIES];

arch/s390/kvm/dat.h

652

union p4d : (x).val, \

arch/s390/kvm/dat.h

659

union p4d : (x), \

arch/s390/kvm/dat.h

727

union p4d : (x).val & _REGION_ENTRY_ORIGIN, \

arch/s390/kvm/dat.h

818

static inline struct region3_table *dereference_p4d(union p4d p4d)

arch/s390/kvm/dat.h

820

return phys_to_virt(crste_origin(p4d));

arch/s390/kvm/dat.h

837

union p4d : _dereference_crste(_CRSTE(x)), \

arch/s390/kvm/gaccess.c

1351

if (table.p4d.i)

arch/s390/kvm/gaccess.c

1353

if (table.p4d.tt != TABLE_TYPE_REGION2)

arch/s390/kvm/gaccess.c

1355

if (vaddr.rtx01 < table.p4d.tf || vaddr.rtx01 > table.p4d.tl)

arch/s390/kvm/gaccess.c

1358

w->p |= table.p4d.p;

arch/s390/kvm/gaccess.c

1359

ptr = table.p4d.rto * PAGE_SIZE;

arch/s390/kvm/gaccess.c

31

union region2_table_entry p4d;

arch/s390/mm/dump_pagetables.c

165

static void note_page_p4d(struct ptdump_state *pt_st, unsigned long addr, p4d_t p4d)

arch/s390/mm/dump_pagetables.c

167

note_page(pt_st, addr, 1, p4d_val(p4d));

arch/s390/mm/gmap_helpers.c

46

p4d_t *p4dp, p4d;

arch/s390/mm/gmap_helpers.c

55

p4d = p4dp_get(p4dp);

arch/s390/mm/gmap_helpers.c

56

if (p4d_none(p4d) || !p4d_present(p4d))

arch/s390/mm/gmap_helpers.c

58

pudp = pud_offset_lockless(p4dp, p4d, vmaddr);

arch/s390/mm/pageattr.c

254

static int walk_pud_level(p4d_t *p4d, unsigned long addr, unsigned long end,

arch/s390/mm/pageattr.c

262

pudp = pud_offset(p4d, addr);

arch/s390/mm/pgalloc.c

111

pagetable_dtor(virt_to_ptdesc(p4d));

arch/s390/mm/pgalloc.c

112

crst_table_free(mm, p4d);

arch/s390/mm/pgalloc.c

58

unsigned long *pgd = NULL, *p4d = NULL, *__pgd;

arch/s390/mm/pgalloc.c

70

p4d = crst_table_alloc(mm);

arch/s390/mm/pgalloc.c

71

if (unlikely(!p4d))

arch/s390/mm/pgalloc.c

73

crst_table_init(p4d, _REGION2_ENTRY_EMPTY);

arch/s390/mm/pgalloc.c

74

pagetable_p4d_ctor(virt_to_ptdesc(p4d));

arch/s390/mm/pgalloc.c

86

if (p4d) {

arch/s390/mm/pgalloc.c

88

p4d_populate(mm, (p4d_t *) p4d, (pud_t *) __pgd);

arch/s390/mm/pgalloc.c

89

mm->pgd = (pgd_t *) p4d;

arch/s390/mm/vmem.c

317

static int modify_pud_table(p4d_t *p4d, unsigned long addr, unsigned long end,

arch/s390/mm/vmem.c

326

pud = pud_offset(p4d, addr);

arch/s390/mm/vmem.c

374

static void try_free_pud_table(p4d_t *p4d, unsigned long start)

arch/s390/mm/vmem.c

379

pud = pud_offset(p4d, start);

arch/s390/mm/vmem.c

384

vmem_free_pages(p4d_deref(p4dp_get(p4d)), CRST_ALLOC_ORDER, NULL);

arch/s390/mm/vmem.c

385

p4d_clear(p4d);

arch/s390/mm/vmem.c

393

p4d_t *p4d, entry;

arch/s390/mm/vmem.c

396

p4d = p4d_offset(pgd, addr);

arch/s390/mm/vmem.c

397

for (; addr < end; addr = next, p4d++) {

arch/s390/mm/vmem.c

399

entry = p4dp_get(p4d);

arch/s390/mm/vmem.c

407

p4d_populate(&init_mm, p4d, pud);

arch/s390/mm/vmem.c

409

ret = modify_pud_table(p4d, addr, next, add, direct, altmap);

arch/s390/mm/vmem.c

413

try_free_pud_table(p4d, addr & P4D_MASK);

arch/s390/mm/vmem.c

422

p4d_t *p4d;

arch/s390/mm/vmem.c

425

p4d = p4d_offset(pgd, start);

arch/s390/mm/vmem.c

426

for (i = 0; i < PTRS_PER_P4D; i++, p4d++) {

arch/s390/mm/vmem.c

427

if (!p4d_none(p4dp_get(p4d)))

arch/s390/mm/vmem.c

440

p4d_t *p4d;

arch/s390/mm/vmem.c

462

p4d = vmem_crst_alloc(_REGION2_ENTRY_EMPTY);

arch/s390/mm/vmem.c

463

if (!p4d)

arch/s390/mm/vmem.c

465

pgd_populate(&init_mm, pgd, p4d);

arch/s390/mm/vmem.c

586

p4d_t *p4d;

arch/s390/mm/vmem.c

595

p4d = vmem_crst_alloc(_REGION2_ENTRY_EMPTY);

arch/s390/mm/vmem.c

596

if (!p4d)

arch/s390/mm/vmem.c

598

pgd_populate(&init_mm, pgd, p4d);

arch/s390/mm/vmem.c

600

p4d = p4d_offset(pgd, addr);

arch/s390/mm/vmem.c

601

if (p4d_none(p4dp_get(p4d))) {

arch/s390/mm/vmem.c

607

p4d_populate(&init_mm, p4d, pud);

arch/s390/mm/vmem.c

609

pud = pud_offset(p4d, addr);

arch/sh/mm/fault.c

124

p4d_t *p4d, *p4d_k;

arch/sh/mm/fault.c

134

p4d = p4d_offset(pgd, address);

arch/sh/mm/fault.c

139

pud = pud_offset(p4d, address);

arch/sh/mm/fault.c

56

p4d_t *p4d;

arch/sh/mm/fault.c

69

p4d = p4d_offset(pgd, addr);

arch/sh/mm/fault.c

71

pr_cont(", *p4d=%0*Lx", (u32)(sizeof(*p4d) * 2),

arch/sh/mm/fault.c

72

(u64)p4d_val(*p4d));

arch/sh/mm/fault.c

74

if (p4d_none(*p4d))

arch/sh/mm/fault.c

77

if (p4d_bad(*p4d)) {

arch/sh/mm/fault.c

82

pud = pud_offset(p4d, addr);

arch/sh/mm/hugetlbpage.c

28

p4d_t *p4d;

arch/sh/mm/hugetlbpage.c

35

p4d = p4d_alloc(mm, pgd, addr);

arch/sh/mm/hugetlbpage.c

36

if (p4d) {

arch/sh/mm/hugetlbpage.c

37

pud = pud_alloc(mm, p4d, addr);

arch/sh/mm/hugetlbpage.c

53

p4d_t *p4d;

arch/sh/mm/hugetlbpage.c

60

p4d = p4d_offset(pgd, addr);

arch/sh/mm/hugetlbpage.c

61

if (p4d) {

arch/sh/mm/hugetlbpage.c

62

pud = pud_offset(p4d, addr);

arch/sh/mm/init.c

50

p4d_t *p4d;

arch/sh/mm/init.c

60

p4d = p4d_alloc(NULL, pgd, addr);

arch/sh/mm/init.c

61

if (unlikely(!p4d)) {

arch/sh/mm/init.c

62

p4d_ERROR(*p4d);

arch/sh/mm/init.c

66

pud = pud_alloc(NULL, p4d, addr);

arch/sh/mm/tlbex_32.c

27

p4d_t *p4d;

arch/sh/mm/tlbex_32.c

47

p4d = p4d_offset(pgd, address);

arch/sh/mm/tlbex_32.c

48

if (p4d_none_or_clear_bad(p4d))

arch/sh/mm/tlbex_32.c

50

pud = pud_offset(p4d, address);

arch/sparc/include/asm/pgalloc_64.h

19

static inline void __p4d_populate(p4d_t *p4d, pud_t *pud)

arch/sparc/include/asm/pgalloc_64.h

21

p4d_set(p4d, pud);

arch/sparc/include/asm/pgtable_64.h

809

#define p4d_none(p4d) (!p4d_val(p4d))

arch/sparc/include/asm/pgtable_64.h

811

#define p4d_bad(p4d) (p4d_val(p4d) & ~PAGE_MASK)

arch/sparc/include/asm/pgtable_64.h

858

#define p4d_pgtable(p4d) \

arch/sparc/include/asm/pgtable_64.h

859

((pud_t *) __va(p4d_val(p4d)))

arch/sparc/include/asm/pgtable_64.h

860

#define p4d_present(p4d) (p4d_val(p4d) != 0U)

arch/sparc/include/asm/pgtable_64.h

864

#define p4d_page(p4d) NULL

arch/sparc/mm/fault_32.c

274

p4d_t *p4d, *p4d_k;

arch/sparc/mm/fault_32.c

288

p4d = p4d_offset(pgd, address);

arch/sparc/mm/fault_32.c

289

pud = pud_offset(p4d, address);

arch/sparc/mm/hugetlbpage.c

194

p4d_t *p4d;

arch/sparc/mm/hugetlbpage.c

199

p4d = p4d_offset(pgd, addr);

arch/sparc/mm/hugetlbpage.c

200

pud = pud_alloc(mm, p4d, addr);

arch/sparc/mm/hugetlbpage.c

217

p4d_t *p4d;

arch/sparc/mm/hugetlbpage.c

224

p4d = p4d_offset(pgd, addr);

arch/sparc/mm/hugetlbpage.c

225

if (p4d_none(*p4d))

arch/sparc/mm/hugetlbpage.c

227

pud = pud_offset(p4d, addr);

arch/sparc/mm/init_64.c

1619

p4d_t *p4d;

arch/sparc/mm/init_64.c

1641

p4d = p4d_offset(pgd, addr);

arch/sparc/mm/init_64.c

1642

if (p4d_none(*p4d))

arch/sparc/mm/init_64.c

1645

pud = pud_offset(p4d, addr);

arch/sparc/mm/init_64.c

1770

p4d_t *p4d;

arch/sparc/mm/init_64.c

1786

p4d = p4d_offset(pgd, vstart);

arch/sparc/mm/init_64.c

1787

if (p4d_none(*p4d)) {

arch/sparc/mm/init_64.c

1795

p4d_populate(&init_mm, p4d, new);

arch/sparc/mm/init_64.c

1798

pud = pud_offset(p4d, vstart);

arch/sparc/mm/srmmu.c

271

p4d_t *p4d;

arch/sparc/mm/srmmu.c

300

p4d = p4d_offset(pgd, vaddr);

arch/sparc/mm/srmmu.c

301

pud = pud_offset(p4d, vaddr);

arch/sparc/mm/srmmu.c

871

p4d_t *p4d;

arch/sparc/mm/srmmu.c

934

p4d = p4d_offset(pgd, PKMAP_BASE);

arch/sparc/mm/srmmu.c

935

pud = pud_offset(p4d, PKMAP_BASE);

arch/um/include/asm/pgtable-4level.h

69

#define p4d_populate(mm, p4d, pud) \

arch/um/include/asm/pgtable-4level.h

70

set_p4d(p4d, __p4d(_PAGE_TABLE + __pa(pud)))

arch/um/include/asm/pgtable-4level.h

89

static inline void p4d_clear (p4d_t *p4d)

arch/um/include/asm/pgtable-4level.h

91

set_p4d(p4d, __p4d(_PAGE_NEEDSYNC));

arch/um/include/asm/pgtable-4level.h

97

#define p4d_page(p4d) phys_to_page(p4d_val(p4d) & PAGE_MASK)

arch/um/include/asm/pgtable-4level.h

98

#define p4d_pgtable(p4d) ((pud_t *) __va(p4d_val(p4d) & PAGE_MASK))

arch/um/kernel/skas/uaccess.c

20

p4d_t *p4d;

arch/um/kernel/skas/uaccess.c

31

p4d = p4d_offset(pgd, addr);

arch/um/kernel/skas/uaccess.c

32

if (!p4d_present(*p4d))

arch/um/kernel/skas/uaccess.c

35

pud = pud_offset(p4d, addr);

arch/um/kernel/tlb.c

114

static inline int update_pud_range(p4d_t *p4d, unsigned long addr,

arch/um/kernel/tlb.c

122

pud = pud_offset(p4d, addr);

arch/um/kernel/tlb.c

141

p4d_t *p4d;

arch/um/kernel/tlb.c

145

p4d = p4d_offset(pgd, addr);

arch/um/kernel/tlb.c

148

if (!p4d_present(*p4d)) {

arch/um/kernel/tlb.c

149

if (p4d_needsync(*p4d)) {

arch/um/kernel/tlb.c

152

p4d_mkuptodate(*p4d);

arch/um/kernel/tlb.c

155

ret = update_pud_range(p4d, addr, next, ops);

arch/um/kernel/tlb.c

156

} while (p4d++, addr = next, ((addr < end) && !ret));

arch/x86/boot/startup/map_kernel.c

130

p4d = (p4dval_t *)rip_rel_ptr(level4_kernel_pgt);

arch/x86/boot/startup/map_kernel.c

131

p4d[MAX_PTRS_PER_P4D - 1] += load_delta;

arch/x86/boot/startup/map_kernel.c

133

pgd[pgd_index(__START_KERNEL_map)] = (pgdval_t)p4d | _PAGE_TABLE;

arch/x86/boot/startup/map_kernel.c

156

p4d = &early_pgts[next_early_pgt++]->pmd;

arch/x86/boot/startup/map_kernel.c

159

pgd[i + 0] = (pgdval_t)p4d + pgtable_flags;

arch/x86/boot/startup/map_kernel.c

160

pgd[i + 1] = (pgdval_t)p4d + pgtable_flags;

arch/x86/boot/startup/map_kernel.c

163

p4d[(i + 0) % PTRS_PER_P4D] = (pgdval_t)pud + pgtable_flags;

arch/x86/boot/startup/map_kernel.c

164

p4d[(i + 1) % PTRS_PER_P4D] = (pgdval_t)pud + pgtable_flags;

arch/x86/boot/startup/map_kernel.c

96

p4dval_t *p4d;

arch/x86/boot/startup/sme.c

114

p4d_t *p4d;

arch/x86/boot/startup/sme.c

120

p4d = ppd->pgtable_area;

arch/x86/boot/startup/sme.c

121

memset(p4d, 0, sizeof(*p4d) * PTRS_PER_P4D);

arch/x86/boot/startup/sme.c

122

ppd->pgtable_area += sizeof(*p4d) * PTRS_PER_P4D;

arch/x86/boot/startup/sme.c

123

set_pgd(pgd, __pgd(PGD_FLAGS | __pa(p4d)));

arch/x86/boot/startup/sme.c

126

p4d = p4d_offset(pgd, ppd->vaddr);

arch/x86/boot/startup/sme.c

127

if (p4d_none(*p4d)) {

arch/x86/boot/startup/sme.c

131

set_p4d(p4d, __p4d(P4D_FLAGS | __pa(pud)));

arch/x86/boot/startup/sme.c

134

pud = pud_offset(p4d, ppd->vaddr);

arch/x86/entry/vsyscall/vsyscall_64.c

368

p4d_t *p4d;

arch/x86/entry/vsyscall/vsyscall_64.c

374

p4d = p4d_offset(pgd, VSYSCALL_ADDR);

arch/x86/entry/vsyscall/vsyscall_64.c

375

set_p4d(p4d, __p4d(p4d_val(*p4d) | _PAGE_USER));

arch/x86/entry/vsyscall/vsyscall_64.c

376

pud = pud_offset(p4d, VSYSCALL_ADDR);

arch/x86/hyperv/hv_crash.c

118

p4d_t *p4d;

arch/x86/hyperv/hv_crash.c

122

p4d = p4d_offset(pgd, trampoline_pa);

arch/x86/hyperv/hv_crash.c

123

native_p4d_clear(p4d);

arch/x86/hyperv/hv_crash.c

229

p4d_t *p4d;

arch/x86/hyperv/hv_crash.c

232

p4d = p4d_offset(pgd, trampoline_pa);

arch/x86/hyperv/hv_crash.c

235

p4d_populate(&init_mm, p4d, (pud_t *)hv_crash_ptpgs[1]);

arch/x86/hyperv/hv_crash.c

236

p4d->p4d = p4d->p4d & ~(_PAGE_NX); /* enable execute */

arch/x86/hyperv/hv_crash.c

509

p4d_t *p4d;

arch/x86/hyperv/hv_crash.c

515

p4d = hv_crash_ptpgs[0] + pgd_index(addr) * sizeof(p4d);

arch/x86/hyperv/hv_crash.c

517

set_p4d(p4d, __p4d(_PAGE_TABLE | pa));

arch/x86/hyperv/hv_crash.c

518

p4d->p4d &= ~(_PAGE_NX); /* enable execute */

arch/x86/include/asm/kexec.h

163

p4d_t *p4d;

arch/x86/include/asm/paravirt.h

414

static inline void set_p4d(p4d_t *p4dp, p4d_t p4d)

arch/x86/include/asm/paravirt.h

416

p4dval_t val = native_p4d_val(p4d);

arch/x86/include/asm/paravirt.h

429

static inline p4dval_t p4d_val(p4d_t p4d)

arch/x86/include/asm/paravirt.h

431

return PVOP_ALT_CALLEE1(p4dval_t, pv_ops, mmu.p4d_val, p4d.p4d,

arch/x86/include/asm/pgalloc.h

111

static inline void p4d_populate(struct mm_struct *mm, p4d_t *p4d, pud_t *pud)

arch/x86/include/asm/pgalloc.h

114

set_p4d(p4d, __p4d(_PAGE_TABLE | __pa(pud)));

arch/x86/include/asm/pgalloc.h

117

static inline void p4d_populate_safe(struct mm_struct *mm, p4d_t *p4d, pud_t *pud)

arch/x86/include/asm/pgalloc.h

120

set_p4d_safe(p4d, __p4d(_PAGE_TABLE | __pa(pud)));

arch/x86/include/asm/pgalloc.h

132

static inline void pgd_populate(struct mm_struct *mm, pgd_t *pgd, p4d_t *p4d)

arch/x86/include/asm/pgalloc.h

136

paravirt_alloc_p4d(mm, __pa(p4d) >> PAGE_SHIFT);

arch/x86/include/asm/pgalloc.h

137

set_pgd(pgd, __pgd(_PAGE_TABLE | __pa(p4d)));

arch/x86/include/asm/pgalloc.h

140

static inline void pgd_populate_safe(struct mm_struct *mm, pgd_t *pgd, p4d_t *p4d)

arch/x86/include/asm/pgalloc.h

144

paravirt_alloc_p4d(mm, __pa(p4d) >> PAGE_SHIFT);

arch/x86/include/asm/pgalloc.h

145

set_pgd_safe(pgd, __pgd(_PAGE_TABLE | __pa(p4d)));

arch/x86/include/asm/pgalloc.h

148

extern void ___p4d_free_tlb(struct mmu_gather *tlb, p4d_t *p4d);

arch/x86/include/asm/pgalloc.h

150

static inline void __p4d_free_tlb(struct mmu_gather *tlb, p4d_t *p4d,

arch/x86/include/asm/pgalloc.h

154

___p4d_free_tlb(tlb, p4d);

arch/x86/include/asm/pgtable-3level.h

56

pud.p4d.pgd = pti_set_user_pgtbl(&pudp->p4d.pgd, pud.p4d.pgd);

arch/x86/include/asm/pgtable.h

1071

static inline int p4d_none(p4d_t p4d)

arch/x86/include/asm/pgtable.h

1073

return (native_p4d_val(p4d) & ~(_PAGE_KNL_ERRATUM_MASK)) == 0;

arch/x86/include/asm/pgtable.h

1076

static inline int p4d_present(p4d_t p4d)

arch/x86/include/asm/pgtable.h

1078

return p4d_flags(p4d) & _PAGE_PRESENT;

arch/x86/include/asm/pgtable.h

1081

static inline pud_t *p4d_pgtable(p4d_t p4d)

arch/x86/include/asm/pgtable.h

1083

return (pud_t *)__va(p4d_val(p4d) & p4d_pfn_mask(p4d));

arch/x86/include/asm/pgtable.h

1090

#define p4d_page(p4d) pfn_to_page(p4d_pfn(p4d))

arch/x86/include/asm/pgtable.h

1092

static inline int p4d_bad(p4d_t p4d)

arch/x86/include/asm/pgtable.h

1099

return (p4d_flags(p4d) & ~ignore_flags) != 0;

arch/x86/include/asm/pgtable.h

1737

#define set_p4d_safe(p4dp, p4d) \

arch/x86/include/asm/pgtable.h

1739

WARN_ON_ONCE(p4d_present(*p4dp) && !p4d_same(*p4dp, p4d)); \

arch/x86/include/asm/pgtable.h

1740

set_p4d(p4dp, p4d); \

arch/x86/include/asm/pgtable.h

278

static inline unsigned long p4d_pfn(p4d_t p4d)

arch/x86/include/asm/pgtable.h

280

return (p4d_val(p4d) & p4d_pfn_mask(p4d)) >> PAGE_SHIFT;

arch/x86/include/asm/pgtable.h

73

# define set_p4d(p4dp, p4d) native_set_p4d(p4dp, p4d)

arch/x86/include/asm/pgtable.h

77

#define p4d_clear(p4d) native_p4d_clear(p4d)

arch/x86/include/asm/pgtable_64.h

138

static inline void native_set_p4d(p4d_t *p4dp, p4d_t p4d)

arch/x86/include/asm/pgtable_64.h

144

WRITE_ONCE(*p4dp, p4d);

arch/x86/include/asm/pgtable_64.h

148

pgd = native_make_pgd(native_p4d_val(p4d));

arch/x86/include/asm/pgtable_64.h

153

static inline void native_p4d_clear(p4d_t *p4d)

arch/x86/include/asm/pgtable_64.h

155

native_set_p4d(p4d, native_make_p4d(0));

arch/x86/include/asm/pgtable_types.h

342

typedef struct { p4dval_t p4d; } p4d_t;

arch/x86/include/asm/pgtable_types.h

349

static inline p4dval_t native_p4d_val(p4d_t p4d)

arch/x86/include/asm/pgtable_types.h

351

return p4d.p4d;

arch/x86/include/asm/pgtable_types.h

361

static inline p4dval_t native_p4d_val(p4d_t p4d)

arch/x86/include/asm/pgtable_types.h

363

return native_pgd_val(p4d.pgd);

arch/x86/include/asm/pgtable_types.h

384

return (pud_t) { .p4d.pgd = native_make_pgd(val) };

arch/x86/include/asm/pgtable_types.h

389

return native_pgd_val(pud.p4d.pgd);

arch/x86/include/asm/pgtable_types.h

408

return (pmd_t) { .pud.p4d.pgd = native_make_pgd(val) };

arch/x86/include/asm/pgtable_types.h

413

return native_pgd_val(pmd.pud.p4d.pgd);

arch/x86/include/asm/pgtable_types.h

417

static inline p4dval_t p4d_pfn_mask(p4d_t p4d)

arch/x86/include/asm/pgtable_types.h

423

static inline p4dval_t p4d_flags_mask(p4d_t p4d)

arch/x86/include/asm/pgtable_types.h

425

return ~p4d_pfn_mask(p4d);

arch/x86/include/asm/pgtable_types.h

428

static inline p4dval_t p4d_flags(p4d_t p4d)

arch/x86/include/asm/pgtable_types.h

430

return native_p4d_val(p4d) & p4d_flags_mask(p4d);

arch/x86/include/asm/xen/page.h

336

#define pud_val_ma(v) ((v).p4d.pgd.pgd)

arch/x86/include/asm/xen/page.h

345

#define p4d_val_ma(x) ((x).p4d)

arch/x86/kernel/espfix_64.c

107

p4d_t *p4d;

arch/x86/kernel/espfix_64.c

115

p4d = p4d_alloc(&init_mm, pgd, ESPFIX_BASE_ADDR);

arch/x86/kernel/espfix_64.c

116

p4d_populate(&init_mm, p4d, espfix_pud_page);

arch/x86/kernel/head64.c

115

p4d = *p4d_p;

arch/x86/kernel/head64.c

117

if (p4d)

arch/x86/kernel/head64.c

118

pud_p = (pudval_t *)((p4d & PTE_PFN_MASK) + __START_KERNEL_map - phys_base);

arch/x86/kernel/head64.c

83

p4dval_t p4d, *p4d_p;

arch/x86/kernel/ldt.c

217

p4d_t *p4d;

arch/x86/kernel/ldt.c

223

p4d = p4d_offset(pgd, va);

arch/x86/kernel/ldt.c

224

if (p4d_none(*p4d))

arch/x86/kernel/ldt.c

227

pud = pud_offset(p4d, va);

arch/x86/kernel/machine_kexec_32.c

83

p4d_t *p4d;

arch/x86/kernel/machine_kexec_32.c

91

p4d = p4d_offset(pgd, vaddr);

arch/x86/kernel/machine_kexec_32.c

92

pud = pud_offset(p4d, vaddr);

arch/x86/kernel/machine_kexec_64.c

153

free_page((unsigned long)image->arch.p4d);

arch/x86/kernel/machine_kexec_64.c

154

image->arch.p4d = NULL;

arch/x86/kernel/machine_kexec_64.c

169

p4d_t *p4d;

arch/x86/kernel/machine_kexec_64.c

183

p4d = (p4d_t *)get_zeroed_page(GFP_KERNEL);

arch/x86/kernel/machine_kexec_64.c

184

if (!p4d)

arch/x86/kernel/machine_kexec_64.c

186

image->arch.p4d = p4d;

arch/x86/kernel/machine_kexec_64.c

187

set_pgd(pgd, __pgd(__pa(p4d) | _KERNPG_TABLE));

arch/x86/kernel/machine_kexec_64.c

189

p4d = p4d_offset(pgd, vaddr);

arch/x86/kernel/machine_kexec_64.c

190

if (!p4d_present(*p4d)) {

arch/x86/kernel/machine_kexec_64.c

195

set_p4d(p4d, __p4d(__pa(pud) | _KERNPG_TABLE));

arch/x86/kernel/machine_kexec_64.c

197

pud = pud_offset(p4d, vaddr);

arch/x86/kernel/tboot.c

117

p4d_t *p4d;

arch/x86/kernel/tboot.c

123

p4d = p4d_alloc(&tboot_mm, pgd, vaddr);

arch/x86/kernel/tboot.c

124

if (!p4d)

arch/x86/kernel/tboot.c

126

pud = pud_alloc(&tboot_mm, p4d, vaddr);

arch/x86/kvm/mmu/mmu.c

3289

p4d_t p4d;

arch/x86/kvm/mmu/mmu.c

3321

p4d = READ_ONCE(*p4d_offset(&pgd, hva));

arch/x86/kvm/mmu/mmu.c

3322

if (p4d_none(p4d) || !p4d_present(p4d))

arch/x86/kvm/mmu/mmu.c

3325

pud = READ_ONCE(*pud_offset(&p4d, hva));

arch/x86/mm/dump_pagetables.c

284

static void effective_prot_p4d(struct ptdump_state *st, p4d_t p4d)

arch/x86/mm/dump_pagetables.c

286

effective_prot(st, 1, p4d_val(p4d));

arch/x86/mm/dump_pagetables.c

406

static void note_page_p4d(struct ptdump_state *pt_st, unsigned long addr, p4d_t p4d)

arch/x86/mm/dump_pagetables.c

408

note_page(pt_st, addr, 1, p4d_val(p4d));

arch/x86/mm/fault.c

1015

p4d = p4d_offset(pgd, address);

arch/x86/mm/fault.c

1016

if (!p4d_present(*p4d))

arch/x86/mm/fault.c

1019

if (p4d_leaf(*p4d))

arch/x86/mm/fault.c

1020

return spurious_kernel_fault_check(error_code, (pte_t *) p4d);

arch/x86/mm/fault.c

1022

pud = pud_offset(p4d, address);

arch/x86/mm/fault.c

185

p4d_t *p4d, *p4d_k;

arch/x86/mm/fault.c

200

p4d = p4d_offset(pgd, address);

arch/x86/mm/fault.c

205

pud = pud_offset(p4d, address);

arch/x86/mm/fault.c

304

p4d_t *p4d;

arch/x86/mm/fault.c

317

p4d = p4d_offset(pgd, address);

arch/x86/mm/fault.c

318

pud = pud_offset(p4d, address);

arch/x86/mm/fault.c

360

p4d_t *p4d;

arch/x86/mm/fault.c

373

p4d = p4d_offset(pgd, address);

arch/x86/mm/fault.c

374

if (bad_address(p4d))

arch/x86/mm/fault.c

377

pr_cont("P4D %lx ", p4d_val(*p4d));

arch/x86/mm/fault.c

378

if (!p4d_present(*p4d) || p4d_leaf(*p4d))

arch/x86/mm/fault.c

381

pud = pud_offset(p4d, address);

arch/x86/mm/fault.c

992

p4d_t *p4d;

arch/x86/mm/ident_map.c

152

p4d_t *p4d = p4d_page + p4d_index(addr);

arch/x86/mm/ident_map.c

156

if (p4d_present(*p4d)) {

arch/x86/mm/ident_map.c

157

pud = pud_offset(p4d, 0);

arch/x86/mm/ident_map.c

172

set_p4d(p4d, __p4d(__pa(pud) | info->kernpg_flag | _PAGE_NOPTISHADOW));

arch/x86/mm/ident_map.c

195

p4d_t *p4d;

arch/x86/mm/ident_map.c

199

p4d = p4d_offset(pgd, 0);

arch/x86/mm/ident_map.c

200

result = ident_p4d_init(info, p4d, addr, next);

arch/x86/mm/ident_map.c

206

p4d = (p4d_t *)info->alloc_pgt_page(info->context);

arch/x86/mm/ident_map.c

207

if (!p4d)

arch/x86/mm/ident_map.c

209

result = ident_p4d_init(info, p4d, addr, next);

arch/x86/mm/ident_map.c

213

set_pgd(pgd, __pgd(__pa(p4d) | info->kernpg_flag | _PAGE_NOPTISHADOW));

arch/x86/mm/ident_map.c

219

pud_t *pud = pud_offset(p4d, 0);

arch/x86/mm/ident_map.c

32

static void free_pud(struct x86_mapping_info *info, p4d_t *p4d)

arch/x86/mm/ident_map.c

34

pud_t *pud = pud_offset(p4d, 0);

arch/x86/mm/ident_map.c

52

p4d_t *p4d = p4d_offset(pgd, 0);

arch/x86/mm/ident_map.c

56

if (!p4d_present(p4d[i]))

arch/x86/mm/ident_map.c

59

free_pud(info, &p4d[i]);

arch/x86/mm/ident_map.c

63

info->free_pgt_page(p4d, info->context);

arch/x86/mm/init_32.c

422

p4d_t *p4d;

arch/x86/mm/init_32.c

442

p4d = p4d_offset(pgd, va);

arch/x86/mm/init_32.c

443

pud = pud_offset(p4d, va);

arch/x86/mm/init_32.c

69

p4d_t *p4d;

arch/x86/mm/init_32.c

77

p4d = p4d_offset(pgd, 0);

arch/x86/mm/init_32.c

78

pud = pud_offset(p4d, 0);

arch/x86/mm/init_32.c

84

p4d = p4d_offset(pgd, 0);

arch/x86/mm/init_32.c

85

pud = pud_offset(p4d, 0);

arch/x86/mm/init_64.c

1087

static void __meminit free_pud_table(pud_t *pud_start, p4d_t *p4d)

arch/x86/mm/init_64.c

1099

free_pagetable(p4d_page(*p4d), 0);

arch/x86/mm/init_64.c

1101

p4d_clear(p4d);

arch/x86/mm/init_64.c

1235

p4d_t *p4d;

arch/x86/mm/init_64.c

1237

p4d = p4d_start + p4d_index(addr);

arch/x86/mm/init_64.c

1238

for (; addr < end; addr = next, p4d++) {

arch/x86/mm/init_64.c

1241

if (!p4d_present(*p4d))

arch/x86/mm/init_64.c

1244

BUILD_BUG_ON(p4d_leaf(*p4d));

arch/x86/mm/init_64.c

1246

pud_base = pud_offset(p4d, 0);

arch/x86/mm/init_64.c

1254

free_pud_table(pud_base, p4d);

arch/x86/mm/init_64.c

1269

p4d_t *p4d;

arch/x86/mm/init_64.c

1278

p4d = p4d_offset(pgd, 0);

arch/x86/mm/init_64.c

1279

remove_p4d_table(p4d, addr, next, altmap, direct);

arch/x86/mm/init_64.c

1338

p4d_t *p4d;

arch/x86/mm/init_64.c

1342

p4d = p4d_alloc(&init_mm, pgd, addr);

arch/x86/mm/init_64.c

1343

if (!p4d)

arch/x86/mm/init_64.c

1360

pud = pud_alloc(&init_mm, p4d, addr);

arch/x86/mm/init_64.c

1602

p4d_t *p4d;

arch/x86/mm/init_64.c

1618

p4d = p4d_offset(pgd, addr);

arch/x86/mm/init_64.c

1619

if (p4d_none(*p4d)) {

arch/x86/mm/init_64.c

1623

get_page_bootmem(section_nr, p4d_page(*p4d), MIX_SECTION_INFO);

arch/x86/mm/init_64.c

1625

pud = pud_offset(p4d, addr);

arch/x86/mm/init_64.c

192

p4d_t *p4d;

arch/x86/mm/init_64.c

196

p4d = p4d_offset(pgd, addr);

arch/x86/mm/init_64.c

201

if (!p4d_none(*p4d_ref) && !p4d_none(*p4d))

arch/x86/mm/init_64.c

202

BUG_ON(p4d_pgtable(*p4d)

arch/x86/mm/init_64.c

205

if (p4d_none(*p4d))

arch/x86/mm/init_64.c

206

set_p4d(p4d, *p4d_ref);

arch/x86/mm/init_64.c

270

p4d_t *p4d = (p4d_t *)spp_getpage();

arch/x86/mm/init_64.c

271

pgd_populate(&init_mm, pgd, p4d);

arch/x86/mm/init_64.c

272

if (p4d != p4d_offset(pgd, 0))

arch/x86/mm/init_64.c

274

p4d, p4d_offset(pgd, 0));

arch/x86/mm/init_64.c

279

static pud_t *fill_pud(p4d_t *p4d, unsigned long vaddr)

arch/x86/mm/init_64.c

281

if (p4d_none(*p4d)) {

arch/x86/mm/init_64.c

283

p4d_populate(&init_mm, p4d, pud);

arch/x86/mm/init_64.c

284

if (pud != pud_offset(p4d, 0))

arch/x86/mm/init_64.c

286

pud, pud_offset(p4d, 0));

arch/x86/mm/init_64.c

288

return pud_offset(p4d, vaddr);

arch/x86/mm/init_64.c

330

p4d_t *p4d = p4d_page + p4d_index(vaddr);

arch/x86/mm/init_64.c

331

pud_t *pud = fill_pud(p4d, vaddr);

arch/x86/mm/init_64.c

364

p4d_t *p4d;

arch/x86/mm/init_64.c

368

p4d = fill_p4d(pgd, vaddr);

arch/x86/mm/init_64.c

369

pud = fill_pud(p4d, vaddr);

arch/x86/mm/init_64.c

388

p4d_t *p4d;

arch/x86/mm/init_64.c

399

p4d = (p4d_t *) spp_getpage();

arch/x86/mm/init_64.c

400

set_pgd(pgd, __pgd(__pa(p4d) | _KERNPG_TABLE |

arch/x86/mm/init_64.c

403

p4d = p4d_offset(pgd, (unsigned long)__va(phys));

arch/x86/mm/init_64.c

404

if (p4d_none(*p4d)) {

arch/x86/mm/init_64.c

406

set_p4d(p4d, __p4d(__pa(pud) | _KERNPG_TABLE |

arch/x86/mm/init_64.c

409

pud = pud_offset(p4d, (unsigned long)__va(phys));

arch/x86/mm/init_64.c

704

p4d_t *p4d = p4d_page + p4d_index(vaddr);

arch/x86/mm/init_64.c

717

set_p4d_init(p4d, __p4d(0), init);

arch/x86/mm/init_64.c

721

if (!p4d_none(*p4d)) {

arch/x86/mm/init_64.c

722

pud = pud_offset(p4d, 0);

arch/x86/mm/init_64.c

73

DEFINE_POPULATE(p4d_populate, p4d, pud, init)

arch/x86/mm/init_64.c

733

p4d_populate_init(&init_mm, p4d, pud, init);

arch/x86/mm/init_64.c

74

DEFINE_POPULATE(pgd_populate, pgd, p4d, init)

arch/x86/mm/init_64.c

756

p4d_t *p4d;

arch/x86/mm/init_64.c

761

p4d = (p4d_t *)pgd_page_vaddr(*pgd);

arch/x86/mm/init_64.c

762

paddr_last = phys_p4d_init(p4d, __pa(vaddr),

arch/x86/mm/init_64.c

769

p4d = alloc_low_page();

arch/x86/mm/init_64.c

770

paddr_last = phys_p4d_init(p4d, __pa(vaddr), __pa(vaddr_end),

arch/x86/mm/init_64.c

775

pgd_populate_init(&init_mm, pgd, p4d, init);

arch/x86/mm/init_64.c

778

(pud_t *) p4d, init);

arch/x86/mm/init_64.c

88

DEFINE_ENTRY(p4d, p4d, init)

arch/x86/mm/ioremap.c

831

p4d_t *p4d = p4d_offset(pgd, addr);

arch/x86/mm/ioremap.c

832

pud_t *pud = pud_offset(p4d, addr);

arch/x86/mm/kasan_init_64.c

102

static void __init kasan_populate_p4d(p4d_t *p4d, unsigned long addr,

arch/x86/mm/kasan_init_64.c

108

if (p4d_none(*p4d)) {

arch/x86/mm/kasan_init_64.c

111

p4d_populate(&init_mm, p4d, p);

arch/x86/mm/kasan_init_64.c

114

pud = pud_offset(p4d, addr);

arch/x86/mm/kasan_init_64.c

126

p4d_t *p4d;

arch/x86/mm/kasan_init_64.c

134

p4d = p4d_offset(pgd, addr);

arch/x86/mm/kasan_init_64.c

137

kasan_populate_p4d(p4d, addr, next, nid);

arch/x86/mm/kasan_init_64.c

138

} while (p4d++, addr = next, addr != end);

arch/x86/mm/kasan_init_64.c

193

unsigned long p4d;

arch/x86/mm/kasan_init_64.c

198

p4d = pgd_val(*pgd) & PTE_PFN_MASK;

arch/x86/mm/kasan_init_64.c

199

p4d += __START_KERNEL_map - phys_base;

arch/x86/mm/kasan_init_64.c

200

return (p4d_t *)p4d + p4d_index(addr);

arch/x86/mm/kasan_init_64.c

208

p4d_t *p4d, p4d_entry;

arch/x86/mm/kasan_init_64.c

217

p4d = early_p4d_offset(pgd, addr);

arch/x86/mm/kasan_init_64.c

221

if (!p4d_none(*p4d))

arch/x86/mm/kasan_init_64.c

226

set_p4d(p4d, p4d_entry);

arch/x86/mm/kasan_init_64.c

227

} while (p4d++, addr = next, addr != end && p4d_none(*p4d));

arch/x86/mm/kasan_init_64.c

248

p4d_t *p4d;

arch/x86/mm/kasan_init_64.c

252

p4d = p4d_offset(pgd, addr);

arch/x86/mm/kasan_init_64.c

256

if (p4d_none(*p4d)) {

arch/x86/mm/kasan_init_64.c

258

p4d_populate(&init_mm, p4d, p);

arch/x86/mm/kasan_init_64.c

260

} while (p4d++, addr = next, addr != end);

arch/x86/mm/kaslr.c

174

p4d_t *p4d_page_tramp, *p4d, *p4d_tramp;

arch/x86/mm/kaslr.c

191

p4d = p4d_offset(pgd, vaddr);

arch/x86/mm/kaslr.c

192

pud = pud_offset(p4d, vaddr);

arch/x86/mm/pat/set_memory.c

1306

p4d_t *p4d = p4d_offset(pgd, addr);

arch/x86/mm/pat/set_memory.c

1307

pud_t *pud = pud_offset(p4d, addr);

arch/x86/mm/pat/set_memory.c

1381

p4d_t *p4d;

arch/x86/mm/pat/set_memory.c

1391

p4d = p4d_offset(pgd, addr);

arch/x86/mm/pat/set_memory.c

1392

if (p4d_none(*p4d))

arch/x86/mm/pat/set_memory.c

1394

pud = pud_offset(p4d, addr);

arch/x86/mm/pat/set_memory.c

1504

static void unmap_pud_range(p4d_t *p4d, unsigned long start, unsigned long end)

arch/x86/mm/pat/set_memory.c

1506

pud_t *pud = pud_offset(p4d, start);

arch/x86/mm/pat/set_memory.c

1664

static int populate_pud(struct cpa_data *cpa, unsigned long start, p4d_t *p4d,

arch/x86/mm/pat/set_memory.c

1686

pud = pud_offset(p4d, start);

arch/x86/mm/pat/set_memory.c

1707

pud = pud_offset(p4d, start);

arch/x86/mm/pat/set_memory.c

1727

pud = pud_offset(p4d, start);

arch/x86/mm/pat/set_memory.c

1750

p4d_t *p4d;

arch/x86/mm/pat/set_memory.c

1761

p4d = p4d_alloc_one(&init_mm, 0);

arch/x86/mm/pat/set_memory.c

1762

if (!p4d)

arch/x86/mm/pat/set_memory.c

1765

set_pgd(pgd_entry, __pgd(__pa(p4d) | _KERNPG_TABLE));

arch/x86/mm/pat/set_memory.c

1771

p4d = p4d_offset(pgd_entry, addr);

arch/x86/mm/pat/set_memory.c

1772

if (p4d_none(*p4d)) {

arch/x86/mm/pat/set_memory.c

1781

set_p4d(p4d, __p4d(__pa(pud) | _KERNPG_TABLE));

arch/x86/mm/pat/set_memory.c

1787

ret = populate_pud(cpa, addr, p4d, pgprot);

arch/x86/mm/pat/set_memory.c

1794

unmap_pud_range(p4d, addr,

arch/x86/mm/pat/set_memory.c

721

p4d_t *p4d;

arch/x86/mm/pat/set_memory.c

736

p4d = p4d_offset(pgd, address);

arch/x86/mm/pat/set_memory.c

737

if (p4d_none(*p4d))

arch/x86/mm/pat/set_memory.c

740

if (p4d_leaf(*p4d) || !p4d_present(*p4d))

arch/x86/mm/pat/set_memory.c

741

return (pte_t *)p4d;

arch/x86/mm/pat/set_memory.c

744

*nx |= p4d_flags(*p4d) & _PAGE_NX;

arch/x86/mm/pat/set_memory.c

745

*rw &= p4d_flags(*p4d) & _PAGE_RW;

arch/x86/mm/pat/set_memory.c

747

pud = pud_offset(p4d, address);

arch/x86/mm/pat/set_memory.c

817

p4d_t *p4d;

arch/x86/mm/pat/set_memory.c

824

p4d = p4d_offset(pgd, address);

arch/x86/mm/pat/set_memory.c

825

if (p4d_none(*p4d) || p4d_leaf(*p4d) || !p4d_present(*p4d))

arch/x86/mm/pat/set_memory.c

828

pud = pud_offset(p4d, address);

arch/x86/mm/pat/set_memory.c

897

p4d_t *p4d;

arch/x86/mm/pat/set_memory.c

902

p4d = p4d_offset(pgd, address);

arch/x86/mm/pat/set_memory.c

903

pud = pud_offset(p4d, address);

arch/x86/mm/pgtable.c

244

p4d_t *p4d;

arch/x86/mm/pgtable.c

248

p4d = p4d_offset(pgd, 0);

arch/x86/mm/pgtable.c

249

pud = pud_offset(p4d, 0);

arch/x86/mm/pgtable.c

49

void ___p4d_free_tlb(struct mmu_gather *tlb, p4d_t *p4d)

arch/x86/mm/pgtable.c

51

paravirt_release_p4d(__pa(p4d) >> PAGE_SHIFT);

arch/x86/mm/pgtable.c

52

tlb_remove_ptdesc(tlb, virt_to_ptdesc(p4d));

arch/x86/mm/pgtable.c

593

int p4d_set_huge(p4d_t *p4d, phys_addr_t addr, pgprot_t prot)

arch/x86/mm/pgtable.c

604

void p4d_clear_huge(p4d_t *p4d)

arch/x86/mm/pgtable_32.c

30

p4d_t *p4d;

arch/x86/mm/pgtable_32.c

40

p4d = p4d_offset(pgd, vaddr);

arch/x86/mm/pgtable_32.c

41

if (p4d_none(*p4d)) {

arch/x86/mm/pgtable_32.c

45

pud = pud_offset(p4d, vaddr);

arch/x86/mm/pti.c

215

p4d_t *p4d;

arch/x86/mm/pti.c

218

p4d = pti_user_pagetable_walk_p4d(address);

arch/x86/mm/pti.c

219

if (!p4d)

arch/x86/mm/pti.c

222

BUILD_BUG_ON(p4d_leaf(*p4d));

arch/x86/mm/pti.c

223

if (p4d_none(*p4d)) {

arch/x86/mm/pti.c

228

set_p4d(p4d, __p4d(_KERNPG_TABLE | __pa(new_pud_page)));

arch/x86/mm/pti.c

231

pud = pud_offset(p4d, address);

arch/x86/mm/pti.c

334

p4d_t *p4d;

arch/x86/mm/pti.c

344

p4d = p4d_offset(pgd, addr);

arch/x86/mm/pti.c

345

if (WARN_ON(p4d_none(*p4d)))

arch/x86/mm/pti.c

348

pud = pud_offset(p4d, addr);

arch/x86/platform/efi/efi_64.c

72

p4d_t *p4d;

arch/x86/platform/efi/efi_64.c

82

p4d = p4d_alloc(&init_mm, pgd, EFI_VA_END);

arch/x86/platform/efi/efi_64.c

83

if (!p4d)

arch/x86/platform/efi/efi_64.c

86

pud = pud_alloc(&init_mm, p4d, EFI_VA_END);

arch/x86/power/hibernate.c

157

p4d_t *p4d;

arch/x86/power/hibernate.c

171

p4d = p4d_offset(pgd, relocated_restore_code);

arch/x86/power/hibernate.c

172

if (p4d_leaf(*p4d)) {

arch/x86/power/hibernate.c

173

set_p4d(p4d, __p4d(p4d_val(*p4d) & ~_PAGE_NX));

arch/x86/power/hibernate.c

176

pud = pud_offset(p4d, relocated_restore_code);

arch/x86/power/hibernate_32.c

32

p4d_t *p4d;

arch/x86/power/hibernate_32.c

42

p4d = p4d_offset(pgd, 0);

arch/x86/power/hibernate_32.c

43

pud = pud_offset(p4d, 0);

arch/x86/power/hibernate_32.c

47

p4d = p4d_offset(pgd, 0);

arch/x86/power/hibernate_32.c

48

pud = pud_offset(p4d, 0);

arch/x86/power/hibernate_64.c

30

p4d_t *p4d = NULL;

arch/x86/power/hibernate_64.c

53

p4d = (p4d_t *)get_safe_page(GFP_ATOMIC);

arch/x86/power/hibernate_64.c

54

if (!p4d)

arch/x86/power/hibernate_64.c

70

if (p4d) {

arch/x86/power/hibernate_64.c

72

pgd_t new_pgd = __pgd(__pa(p4d) | pgprot_val(pgtable_prot));

arch/x86/power/hibernate_64.c

74

set_p4d(p4d + p4d_index(restore_jump_address), new_p4d);

arch/x86/xen/mmu_pv.c

103

p4dval_t xen_p4d_val(p4d_t p4d);

arch/x86/xen/mmu_pv.c

108

p4d_t xen_make_p4d(p4dval_t p4d);

arch/x86/xen/mmu_pv.c

1165

static void __init xen_cleanmfnmap_p4d(p4d_t *p4d, bool unpin)

arch/x86/xen/mmu_pv.c

1171

if (p4d_leaf(*p4d)) {

arch/x86/xen/mmu_pv.c

1172

pa = p4d_val(*p4d) & PHYSICAL_PAGE_MASK;

arch/x86/xen/mmu_pv.c

1177

pud_tbl = pud_offset(p4d, 0);

arch/x86/xen/mmu_pv.c

1183

set_p4d(p4d, __p4d(0));

arch/x86/xen/mmu_pv.c

1194

p4d_t *p4d;

arch/x86/xen/mmu_pv.c

1200

p4d = p4d_offset(pgd, 0);

arch/x86/xen/mmu_pv.c

1201

if (!p4d_none(*p4d))

arch/x86/xen/mmu_pv.c

1202

xen_cleanmfnmap_p4d(p4d, unpin);

arch/x86/xen/mmu_pv.c

595

__visible p4dval_t xen_p4d_val(p4d_t p4d)

arch/x86/xen/mmu_pv.c

597

return pte_mfn_to_pfn(p4d.p4d);

arch/x86/xen/mmu_pv.c

601

__visible p4d_t xen_make_p4d(p4dval_t p4d)

arch/x86/xen/mmu_pv.c

603

p4d = pte_pfn_to_mfn(p4d);

arch/x86/xen/mmu_pv.c

605

return native_make_p4d(p4d);

arch/x86/xen/mmu_pv.c

644

static void xen_p4d_walk(struct mm_struct *mm, p4d_t *p4d,

arch/x86/xen/mmu_pv.c

652

if (p4d_none(*p4d))

arch/x86/xen/mmu_pv.c

655

pud = pud_offset(p4d, 0);

arch/x86/xen/mmu_pv.c

694

p4d_t *p4d;

arch/x86/xen/mmu_pv.c

702

p4d = p4d_offset(&pgd[i], 0);

arch/x86/xen/mmu_pv.c

703

xen_p4d_walk(mm, p4d, func, i == nr - 1, limit);

arch/xtensa/mm/fault.c

36

p4d_t *p4d, *p4d_k;

arch/xtensa/mm/fault.c

52

p4d = p4d_offset(pgd, address);

arch/xtensa/mm/fault.c

54

if (!p4d_present(*p4d) || !p4d_present(*p4d_k))

arch/xtensa/mm/fault.c

57

pud = pud_offset(p4d, address);

arch/xtensa/mm/tlb.c

179

p4d_t *p4d;

arch/xtensa/mm/tlb.c

190

p4d = p4d_offset(pgd, vaddr);

arch/xtensa/mm/tlb.c

191

if (p4d_none_or_clear_bad(p4d))

arch/xtensa/mm/tlb.c

193

pud = pud_offset(p4d, vaddr);

include/asm-generic/pgalloc.h

259

static inline void __p4d_free(struct mm_struct *mm, p4d_t *p4d)

include/asm-generic/pgalloc.h

261

struct ptdesc *ptdesc = virt_to_ptdesc(p4d);

include/asm-generic/pgalloc.h

263

BUG_ON((unsigned long)p4d & (PAGE_SIZE-1));

include/asm-generic/pgalloc.h

268

static inline void p4d_free(struct mm_struct *mm, p4d_t *p4d)

include/asm-generic/pgalloc.h

271

__p4d_free(mm, p4d);

include/asm-generic/pgtable-nop4d.h

25

#define p4d_ERROR(p4d) (pgd_ERROR((p4d).pgd))

include/asm-generic/pgtable-nop4d.h

27

#define pgd_populate(mm, pgd, p4d) do { } while (0)

include/asm-generic/pgtable-nop4d.h

28

#define pgd_populate_safe(mm, pgd, p4d) do { } while (0)

include/asm-generic/pgtable-nopud.h

16

typedef struct { p4d_t p4d; } pud_t;

include/asm-generic/pgtable-nopud.h

28

static inline int p4d_none(p4d_t p4d) { return 0; }

include/asm-generic/pgtable-nopud.h

29

static inline int p4d_bad(p4d_t p4d) { return 0; }

include/asm-generic/pgtable-nopud.h

30

static inline int p4d_present(p4d_t p4d) { return 1; }

include/asm-generic/pgtable-nopud.h

31

static inline void p4d_clear(p4d_t *p4d) { }

include/asm-generic/pgtable-nopud.h

32

#define pud_ERROR(pud) (p4d_ERROR((pud).p4d))

include/asm-generic/pgtable-nopud.h

34

#define p4d_populate(mm, p4d, pud) do { } while (0)

include/asm-generic/pgtable-nopud.h

35

#define p4d_populate_safe(mm, p4d, pud) do { } while (0)

include/asm-generic/pgtable-nopud.h

42

static inline pud_t *pud_offset(p4d_t *p4d, unsigned long address)

include/asm-generic/pgtable-nopud.h

44

return (pud_t *)p4d;

include/asm-generic/pgtable-nopud.h

48

#define pud_val(x) (p4d_val((x).p4d))

include/asm-generic/pgtable-nopud.h

51

#define p4d_page(p4d) (pud_page((pud_t){ p4d }))

include/asm-generic/pgtable-nopud.h

52

#define p4d_pgtable(p4d) ((pud_t *)(pud_pgtable((pud_t){ p4d })))

include/linux/mm.h

3494

static inline int __pud_alloc(struct mm_struct *mm, p4d_t *p4d,

include/linux/mm.h

3503

int __pud_alloc(struct mm_struct *mm, p4d_t *p4d, unsigned long address);

include/linux/mm.h

3592

static inline pud_t *pud_alloc(struct mm_struct *mm, p4d_t *p4d,

include/linux/mm.h

3595

return (unlikely(p4d_none(*p4d)) && __pud_alloc(mm, p4d, address)) ?

include/linux/mm.h

3596

NULL : pud_offset(p4d, address);

include/linux/pagewalk.h

73

int (*p4d_entry)(p4d_t *p4d, unsigned long addr,

include/linux/pgalloc.h

15

#define pgd_populate_kernel(addr, pgd, p4d) \

include/linux/pgalloc.h

17

pgd_populate(&init_mm, pgd, p4d); \

include/linux/pgalloc.h

22

#define p4d_populate_kernel(addr, p4d, pud) \

include/linux/pgalloc.h

24

p4d_populate(&init_mm, p4d, pud); \

include/linux/pgtable.h

133

static inline pud_t *pud_offset(p4d_t *p4d, unsigned long address)

include/linux/pgtable.h

135

return p4d_pgtable(*p4d) + pud_index(address);

include/linux/pgtable.h

1376

#define p4d_access_permitted(p4d, write) \

include/linux/pgtable.h

1377

(p4d_present(p4d) && (!(write) || p4d_write(p4d)))

include/linux/pgtable.h

1550

#define p4d_clear_bad(p4d) do { } while (0)

include/linux/pgtable.h

1556

#define pud_clear_bad(p4d) do { } while (0)

include/linux/pgtable.h

1572

static inline int p4d_none_or_clear_bad(p4d_t *p4d)

include/linux/pgtable.h

1574

if (p4d_none(*p4d))

include/linux/pgtable.h

1576

if (unlikely(p4d_bad(*p4d))) {

include/linux/pgtable.h

1577

p4d_clear_bad(p4d);

include/linux/pgtable.h

2161

int p4d_set_huge(p4d_t *p4d, phys_addr_t addr, pgprot_t prot);

include/linux/pgtable.h

2162

void p4d_clear_huge(p4d_t *p4d);

include/linux/pgtable.h

2164

static inline int p4d_set_huge(p4d_t *p4d, phys_addr_t addr, pgprot_t prot)

include/linux/pgtable.h

2168

static inline void p4d_clear_huge(p4d_t *p4d) { }

include/linux/pgtable.h

2175

int p4d_free_pud_page(p4d_t *p4d, unsigned long addr);

include/linux/pgtable.h

2179

static inline int p4d_set_huge(p4d_t *p4d, phys_addr_t addr, pgprot_t prot)

include/linux/pgtable.h

2191

static inline void p4d_clear_huge(p4d_t *p4d) { }

include/linux/pgtable.h

2200

static inline int p4d_free_pud_page(p4d_t *p4d, unsigned long addr)

include/linux/pgtable.h

2365

#define pud_offset_lockless(p4dp, p4d, address) pud_offset(&(p4d), address)

include/linux/ptdump.h

17

void (*note_page_p4d)(struct ptdump_state *st, unsigned long addr, p4d_t p4d);

include/linux/ptdump.h

23

void (*effective_prot_p4d)(struct ptdump_state *st, p4d_t p4d);

kernel/events/core.c

8486

p4d_t *p4dp, p4d;

kernel/events/core.c

8500

p4d = p4dp_get(p4dp);

kernel/events/core.c

8501

if (!p4d_present(p4d))

kernel/events/core.c

8504

if (p4d_leaf(p4d))

kernel/events/core.c

8505

return p4d_leaf_size(p4d);

kernel/events/core.c

8507

pudp = pud_offset_lockless(p4dp, p4d, addr);

mm/debug_vm_pgtable.c

481

p4d_t p4d;

mm/debug_vm_pgtable.c

484

memset(&p4d, RANDOM_NZVALUE, sizeof(p4d_t));

mm/debug_vm_pgtable.c

485

WARN_ON(!p4d_same(p4d, p4d));

mm/debug_vm_pgtable.c

536

p4d_t p4d = p4dp_get(args->p4dp);

mm/debug_vm_pgtable.c

542

WARN_ON(p4d_none(p4d));

mm/debug_vm_pgtable.c

544

p4d = p4dp_get(args->p4dp);

mm/debug_vm_pgtable.c

545

WARN_ON(!p4d_none(p4d));

mm/debug_vm_pgtable.c

550

p4d_t p4d;

mm/debug_vm_pgtable.c

563

p4d = p4dp_get(args->p4dp);

mm/debug_vm_pgtable.c

564

WARN_ON(p4d_bad(p4d));

mm/gup.c

1035

p4d_t *p4d;

mm/gup.c

1048

p4d = p4d_offset(pgd, address);

mm/gup.c

1049

if (p4d_none(*p4d))

mm/gup.c

1051

pud = pud_offset(p4d, address);

mm/gup.c

3043

static int gup_fast_pud_range(p4d_t *p4dp, p4d_t p4d, unsigned long addr,

mm/gup.c

3050

pudp = pud_offset_lockless(p4dp, p4d, addr);

mm/gup.c

3078

p4d_t p4d = p4dp_get(p4dp);

mm/gup.c

3081

if (!p4d_present(p4d))

mm/gup.c

3083

BUILD_BUG_ON(p4d_leaf(p4d));

mm/gup.c

3084

if (!gup_fast_pud_range(p4dp, p4d, addr, next, flags,

mm/gup.c

975

p4d_t *p4dp, p4d;

mm/gup.c

978

p4d = p4dp_get(p4dp);

mm/gup.c

979

BUILD_BUG_ON(p4d_leaf(p4d));

mm/gup.c

981

if (!p4d_present(p4d) || p4d_bad(p4d))

mm/hugetlb.c

6911

p4d_t *p4d = p4d_offset(pgd, addr);

mm/hugetlb.c

6912

pud_t *pud = pud_offset(p4d, addr);

mm/hugetlb.c

7015

p4d_t *p4d;

mm/hugetlb.c

7020

p4d = p4d_alloc(mm, pgd, addr);

mm/hugetlb.c

7021

if (!p4d)

mm/hugetlb.c

7023

pud = pud_alloc(mm, p4d, addr);

mm/hugetlb.c

7058

p4d_t *p4d;

mm/hugetlb.c

7065

p4d = p4d_offset(pgd, addr);

mm/hugetlb.c

7066

if (!p4d_present(*p4d))

mm/hugetlb.c

7069

pud = pud_offset(p4d, addr);

mm/kasan/init.c

144

static int __ref zero_pud_populate(p4d_t *p4d, unsigned long addr,

mm/kasan/init.c

147

pud_t *pud = pud_offset(p4d, addr);

mm/kasan/init.c

185

p4d_t *p4d = p4d_offset(pgd, addr);

mm/kasan/init.c

194

p4d_populate_kernel(addr, p4d,

mm/kasan/init.c

196

pud = pud_offset(p4d, addr);

mm/kasan/init.c

205

if (p4d_none(*p4d)) {

mm/kasan/init.c

209

p = pud_alloc(&init_mm, p4d, addr);

mm/kasan/init.c

215

p4d_populate_kernel(addr, p4d, p);

mm/kasan/init.c

218

zero_pud_populate(p4d, addr, next);

mm/kasan/init.c

219

} while (p4d++, addr = next, addr != end);

mm/kasan/init.c

242

p4d_t *p4d;

mm/kasan/init.c

256

p4d = p4d_offset(pgd, addr);

mm/kasan/init.c

257

p4d_populate_kernel(addr, p4d,

mm/kasan/init.c

259

pud = pud_offset(p4d, addr);

mm/kasan/init.c

314

static void kasan_free_pud(pud_t *pud_start, p4d_t *p4d)

mm/kasan/init.c

326

p4d_clear(p4d);

mm/kasan/init.c

331

p4d_t *p4d;

mm/kasan/init.c

335

p4d = p4d_start + i;

mm/kasan/init.c

336

if (!p4d_none(*p4d))

mm/kasan/init.c

419

static void kasan_remove_p4d_table(p4d_t *p4d, unsigned long addr,

mm/kasan/init.c

424

for (; addr < end; addr = next, p4d++) {

mm/kasan/init.c

429

if (!p4d_present(*p4d))

mm/kasan/init.c

432

if (kasan_pud_table(*p4d)) {

mm/kasan/init.c

435

p4d_clear(p4d);

mm/kasan/init.c

439

pud = pud_offset(p4d, addr);

mm/kasan/init.c

441

kasan_free_pud(pud_offset(p4d, 0), p4d);

mm/kasan/init.c

45

static inline bool kasan_pud_table(p4d_t p4d)

mm/kasan/init.c

458

p4d_t *p4d;

mm/kasan/init.c

47

return p4d_page(p4d) == virt_to_page(lm_alias(kasan_early_shadow_pud));

mm/kasan/init.c

474

p4d = p4d_offset(pgd, addr);

mm/kasan/init.c

475

kasan_remove_p4d_table(p4d, addr, next);

mm/kasan/init.c

50

static inline bool kasan_pud_table(p4d_t p4d)

mm/kasan/shadow.c

189

p4d_t *p4d;

mm/kasan/shadow.c

196

p4d = p4d_offset(pgd, addr);

mm/kasan/shadow.c

197

if (p4d_none(*p4d))

mm/kasan/shadow.c

199

pud = pud_offset(p4d, addr);

mm/memory-failure.c

330

p4d_t *p4d;

mm/memory-failure.c

340

p4d = p4d_offset(pgd, address);

mm/memory-failure.c

341

if (!p4d_present(*p4d))

mm/memory-failure.c

343

pud = pud_offset(p4d, address);

mm/memory.c

2029

struct vm_area_struct *vma, p4d_t *p4d,

mm/memory.c

2036

pud = pud_offset(p4d, addr);

mm/memory.c

2061

p4d_t *p4d;

mm/memory.c

2064

p4d = p4d_offset(pgd, addr);

mm/memory.c

2067

if (p4d_none_or_clear_bad(p4d))

mm/memory.c

2069

next = zap_pud_range(tlb, vma, p4d, addr, next, details);

mm/memory.c

2070

} while (p4d++, addr = next, addr != end);

mm/memory.c

219

static inline void free_pud_range(struct mmu_gather *tlb, p4d_t *p4d,

mm/memory.c

2274

p4d_t *p4d;

mm/memory.c

2279

p4d = p4d_alloc(mm, pgd, addr);

mm/memory.c

228

pud = pud_offset(p4d, addr);

mm/memory.c

2280

if (!p4d)

mm/memory.c

2282

pud = pud_alloc(mm, p4d, addr);

mm/memory.c

247

pud = pud_offset(p4d, start);

mm/memory.c

248

p4d_clear(p4d);

mm/memory.c

257

p4d_t *p4d;

mm/memory.c

262

p4d = p4d_offset(pgd, addr);

mm/memory.c

265

if (p4d_none_or_clear_bad(p4d))

mm/memory.c

267

free_pud_range(tlb, p4d, addr, next, floor, ceiling);

mm/memory.c

268

} while (p4d++, addr = next, addr != end);

mm/memory.c

281

p4d = p4d_offset(pgd, start);

mm/memory.c

283

p4d_free_tlb(tlb, p4d, start);

mm/memory.c

2960

static inline int remap_pud_range(struct mm_struct *mm, p4d_t *p4d,

mm/memory.c

2969

pud = pud_alloc(mm, p4d, addr);

mm/memory.c

2986

p4d_t *p4d;

mm/memory.c

2991

p4d = p4d_alloc(mm, pgd, addr);

mm/memory.c

2992

if (!p4d)

mm/memory.c

2996

err = remap_pud_range(mm, p4d, addr, next,

mm/memory.c

3000

} while (p4d++, addr = next, addr != end);

mm/memory.c

3391

static int apply_to_pud_range(struct mm_struct *mm, p4d_t *p4d,

mm/memory.c

3401

pud = pud_alloc_track(mm, p4d, addr, mask);

mm/memory.c

3405

pud = pud_offset(p4d, addr);

mm/memory.c

3432

p4d_t *p4d;

mm/memory.c

3437

p4d = p4d_alloc_track(mm, pgd, addr, mask);

mm/memory.c

3438

if (!p4d)

mm/memory.c

3441

p4d = p4d_offset(pgd, addr);

mm/memory.c

3445

if (p4d_none(*p4d) && !create)

mm/memory.c

3447

if (WARN_ON_ONCE(p4d_leaf(*p4d)))

mm/memory.c

3449

if (!p4d_none(*p4d) && WARN_ON_ONCE(p4d_bad(*p4d))) {

mm/memory.c

3452

p4d_clear_bad(p4d);

mm/memory.c

3454

err = apply_to_pud_range(mm, p4d, addr, next,

mm/memory.c

3458

} while (p4d++, addr = next, addr != end);

mm/memory.c

525

p4d_t p4d, *p4dp;

mm/memory.c

543

p4d = p4dp_get(p4dp);

mm/memory.c

544

p4dv = p4d_val(p4d);

mm/memory.c

546

if (!p4d_present(p4d) || p4d_leaf(p4d)) {

mm/memory.c

6431

p4d_t *p4d;

mm/memory.c

6435

p4d = p4d_alloc(mm, pgd, address);

mm/memory.c

6436

if (!p4d)

mm/memory.c

6439

vmf.pud = pud_alloc(mm, p4d, address);

mm/memory.c

6746

int __pud_alloc(struct mm_struct *mm, p4d_t *p4d, unsigned long address)

mm/memory.c

6753

if (!p4d_present(*p4d)) {

mm/memory.c

6756

p4d_populate(mm, p4d, new);

mm/memory.c

6856

p4d_t *p4dp, p4d;

mm/memory.c

6874

p4d = p4dp_get(p4dp);

mm/memory.c

6875

if (p4d_none(p4d) || unlikely(p4d_bad(p4d)))

mm/mprotect.c

552

struct vm_area_struct *vma, p4d_t *p4d, unsigned long addr,

mm/mprotect.c

562

pudp = pud_offset(p4d, addr);

mm/mprotect.c

614

p4d_t *p4d;

mm/mprotect.c

618

p4d = p4d_offset(pgd, addr);

mm/mprotect.c

621

ret = change_prepare(vma, p4d, pud, addr, cp_flags);

mm/mprotect.c

624

if (p4d_none_or_clear_bad(p4d))

mm/mprotect.c

626

pages += change_pud_range(tlb, vma, p4d, addr, next, newprot,

mm/mprotect.c

628

} while (p4d++, addr = next, addr != end);

mm/mprotect.c

647

ret = change_prepare(vma, pgd, p4d, addr, cp_flags);

mm/mremap.c

115

p4d_t *p4d;

mm/mremap.c

118

p4d = p4d_alloc(mm, pgd, addr);

mm/mremap.c

119

if (!p4d)

mm/mremap.c

122

return pud_alloc(mm, p4d, addr);

mm/mremap.c

78

p4d_t *p4d;

mm/mremap.c

85

p4d = p4d_offset(pgd, addr);

mm/mremap.c

86

if (p4d_none_or_clear_bad(p4d))

mm/mremap.c

89

pud = pud_offset(p4d, addr);

mm/page_vma_mapped.c

188

p4d_t *p4d;

mm/page_vma_mapped.c

227

p4d = p4d_offset(pgd, pvmw->address);

mm/page_vma_mapped.c

228

if (!p4d_present(*p4d)) {

mm/page_vma_mapped.c

232

pud = pud_offset(p4d, pvmw->address);

mm/pagewalk.c

185

static int walk_pud_range(p4d_t *p4d, unsigned long addr, unsigned long end,

mm/pagewalk.c

196

pud = pud_offset(p4d, addr);

mm/pagewalk.c

253

p4d_t *p4d;

mm/pagewalk.c

261

p4d = p4d_offset(pgd, addr);

mm/pagewalk.c

264

if (p4d_none_or_clear_bad(p4d)) {

mm/pagewalk.c

266

err = __pud_alloc(walk->mm, p4d, addr);

mm/pagewalk.c

275

err = ops->p4d_entry(p4d, addr, next, walk);

mm/pagewalk.c

280

err = walk_pud_range(p4d, addr, next, walk);

mm/pagewalk.c

283

} while (p4d++, addr = next, addr != end);

mm/percpu.c

3148

p4d_t *p4d;

mm/percpu.c

3153

p4d = memblock_alloc_or_panic(P4D_TABLE_SIZE, P4D_TABLE_SIZE);

mm/percpu.c

3154

pgd_populate_kernel(addr, pgd, p4d);

mm/percpu.c

3157

p4d = p4d_offset(pgd, addr);

mm/percpu.c

3158

if (p4d_none(*p4d)) {

mm/percpu.c

3160

p4d_populate_kernel(addr, p4d, pud);

mm/percpu.c

3163

pud = pud_offset(p4d, addr);

mm/pgalloc-track.h

19

static inline pud_t *pud_alloc_track(struct mm_struct *mm, p4d_t *p4d,

mm/pgalloc-track.h

23

if (unlikely(p4d_none(*p4d))) {

mm/pgalloc-track.h

24

if (__pud_alloc(mm, p4d, address))

mm/pgalloc-track.h

29

return pud_offset(p4d, address);

mm/pgtable-generic.c

34

void p4d_clear_bad(p4d_t *p4d)

mm/pgtable-generic.c

36

p4d_ERROR(*p4d);

mm/pgtable-generic.c

37

p4d_clear(p4d);

mm/ptdump.c

53

static int ptdump_p4d_entry(p4d_t *p4d, unsigned long addr,

mm/ptdump.c

57

p4d_t val = p4dp_get(p4d);

mm/rmap.c

886

p4d_t *p4d;

mm/rmap.c

894

p4d = p4d_offset(pgd, address);

mm/rmap.c

895

if (!p4d_present(*p4d))

mm/rmap.c

898

pud = pud_offset(p4d, address);

mm/sparse-vmemmap.c

206

static pud_t * __meminit vmemmap_pud_populate(p4d_t *p4d, unsigned long addr, int node)

mm/sparse-vmemmap.c

208

pud_t *pud = pud_offset(p4d, addr);

mm/sparse-vmemmap.c

221

p4d_t *p4d = p4d_offset(pgd, addr);

mm/sparse-vmemmap.c

222

if (p4d_none(*p4d)) {

mm/sparse-vmemmap.c

227

p4d_populate_kernel(addr, p4d, p);

mm/sparse-vmemmap.c

229

return p4d;

mm/sparse-vmemmap.c

250

p4d_t *p4d;

mm/sparse-vmemmap.c

258

p4d = vmemmap_p4d_populate(pgd, addr, node);

mm/sparse-vmemmap.c

259

if (!p4d)

mm/sparse-vmemmap.c

261

pud = vmemmap_pud_populate(p4d, addr, node);

mm/sparse-vmemmap.c

408

p4d_t *p4d;

mm/sparse-vmemmap.c

419

p4d = vmemmap_p4d_populate(pgd, addr, node);

mm/sparse-vmemmap.c

420

if (!p4d)

mm/sparse-vmemmap.c

423

pud = vmemmap_pud_populate(p4d, addr, node);

mm/swapfile.c

2602

static inline int unuse_pud_range(struct vm_area_struct *vma, p4d_t *p4d,

mm/swapfile.c

2610

pud = pud_offset(p4d, addr);

mm/swapfile.c

2626

p4d_t *p4d;

mm/swapfile.c

2630

p4d = p4d_offset(pgd, addr);

mm/swapfile.c

2633

if (p4d_none_or_clear_bad(p4d))

mm/swapfile.c

2635

ret = unuse_pud_range(vma, p4d, addr, next, type);

mm/swapfile.c

2638

} while (p4d++, addr = next, addr != end);

mm/userfaultfd.c

2591

p4d_t *p4d;

mm/userfaultfd.c

2603

p4d = p4d_offset(pgd, address);

mm/userfaultfd.c

2604

if (!p4d_present(*p4d))

mm/userfaultfd.c

2606

pud = pud_offset(p4d, address);

mm/userfaultfd.c

288

p4d_t *p4d;

mm/userfaultfd.c

292

p4d = p4d_alloc(mm, pgd, address);

mm/userfaultfd.c

293

if (!p4d)

mm/userfaultfd.c

295

pud = pud_alloc(mm, p4d, address);

mm/vmalloc.c

219

static int vmap_pud_range(p4d_t *p4d, unsigned long addr, unsigned long end,

mm/vmalloc.c

227

pud = pud_alloc_track(&init_mm, p4d, addr, mask);

mm/vmalloc.c

246

static int vmap_try_huge_p4d(p4d_t *p4d, unsigned long addr, unsigned long end,

mm/vmalloc.c

265

if (p4d_present(*p4d) && !p4d_free_pud_page(p4d, addr))

mm/vmalloc.c

268

return p4d_set_huge(p4d, phys_addr, prot);

mm/vmalloc.c

275

p4d_t *p4d;

mm/vmalloc.c

279

p4d = p4d_alloc_track(&init_mm, pgd, addr, mask);

mm/vmalloc.c

280

if (!p4d)

mm/vmalloc.c

285

if (vmap_try_huge_p4d(p4d, addr, next, phys_addr, prot,

mm/vmalloc.c

291

err = vmap_pud_range(p4d, addr, next, phys_addr, prot, max_page_shift, mask);

mm/vmalloc.c

294

} while (p4d++, phys_addr += (next - addr), addr = next, addr != end);

mm/vmalloc.c

424

static void vunmap_pud_range(p4d_t *p4d, unsigned long addr, unsigned long end,

mm/vmalloc.c

431

pud = pud_offset(p4d, addr);

mm/vmalloc.c

452

p4d_t *p4d;

mm/vmalloc.c

455

p4d = p4d_offset(pgd, addr);

mm/vmalloc.c

459

p4d_clear_huge(p4d);

mm/vmalloc.c

460

if (p4d_bad(*p4d))

mm/vmalloc.c

463

if (p4d_none_or_clear_bad(p4d))

mm/vmalloc.c

465

vunmap_pud_range(p4d, addr, next, mask);

mm/vmalloc.c

466

} while (p4d++, addr = next, addr != end);

mm/vmalloc.c

587

static int vmap_pages_pud_range(p4d_t *p4d, unsigned long addr,

mm/vmalloc.c

594

pud = pud_alloc_track(&init_mm, p4d, addr, mask);

mm/vmalloc.c

609

p4d_t *p4d;

mm/vmalloc.c

612

p4d = p4d_alloc_track(&init_mm, pgd, addr, mask);

mm/vmalloc.c

613

if (!p4d)

mm/vmalloc.c

617

if (vmap_pages_pud_range(p4d, addr, next, prot, pages, nr, mask))

mm/vmalloc.c

619

} while (p4d++, addr = next, addr != end);

mm/vmalloc.c

804

p4d_t *p4d;

mm/vmalloc.c

822

p4d = p4d_offset(pgd, addr);

mm/vmalloc.c

823

if (p4d_none(*p4d))

mm/vmalloc.c

825

if (p4d_leaf(*p4d))

mm/vmalloc.c

826

return p4d_page(*p4d) + ((addr & ~P4D_MASK) >> PAGE_SHIFT);

mm/vmalloc.c

827

if (WARN_ON_ONCE(p4d_bad(*p4d)))

mm/vmalloc.c

830

pud = pud_offset(p4d, addr);

mm/vmscan.c

3714

static int walk_pud_range(p4d_t *p4d, unsigned long start, unsigned long end,

mm/vmscan.c

3723

VM_WARN_ON_ONCE(p4d_leaf(*p4d));

mm/vmscan.c

3725

pud = pud_offset(p4d, start & P4D_MASK);

tools/testing/selftests/vfio/vfio_dma_mapping_test.c

170

printf("P4D: 0x%016lx\n", mapping.p4d);

tools/testing/selftests/vfio/vfio_dma_mapping_test.c

20

u64 p4d;

tools/testing/selftests/vfio/vfio_dma_mapping_test.c

69

parse_next_value(&rest, &mapping->p4d);