1#ifndef _ASM_X86_PGTABLE_H
2#define _ASM_X86_PGTABLE_H
3
4#include <asm/page.h>
5#include <asm/e820.h>
6
7#include <asm/pgtable_types.h>
8
9
10
11
12#define pgprot_noncached(prot) \
13 ((boot_cpu_data.x86 > 3) \
14 ? (__pgprot(pgprot_val(prot) | _PAGE_CACHE_UC_MINUS)) \
15 : (prot))
16
17#ifndef __ASSEMBLY__
18
19#include <asm/x86_init.h>
20
21
22
23
24
25extern unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)];
26#define ZERO_PAGE(vaddr) (virt_to_page(empty_zero_page))
27
28extern spinlock_t pgd_lock;
29extern struct list_head pgd_list;
30
31extern struct mm_struct *pgd_page_get_mm(struct page *page);
32
33#ifdef CONFIG_PARAVIRT
34#include <asm/paravirt.h>
35#else
36#define set_pte(ptep, pte) native_set_pte(ptep, pte)
37#define set_pte_at(mm, addr, ptep, pte) native_set_pte_at(mm, addr, ptep, pte)
38#define set_pmd_at(mm, addr, pmdp, pmd) native_set_pmd_at(mm, addr, pmdp, pmd)
39
40#define set_pte_atomic(ptep, pte) \
41 native_set_pte_atomic(ptep, pte)
42
43#define set_pmd(pmdp, pmd) native_set_pmd(pmdp, pmd)
44
45#ifndef __PAGETABLE_PUD_FOLDED
46#define set_pgd(pgdp, pgd) native_set_pgd(pgdp, pgd)
47#define pgd_clear(pgd) native_pgd_clear(pgd)
48#endif
49
50#ifndef set_pud
51# define set_pud(pudp, pud) native_set_pud(pudp, pud)
52#endif
53
54#ifndef __PAGETABLE_PMD_FOLDED
55#define pud_clear(pud) native_pud_clear(pud)
56#endif
57
58#define pte_clear(mm, addr, ptep) native_pte_clear(mm, addr, ptep)
59#define pmd_clear(pmd) native_pmd_clear(pmd)
60
61#define pte_update(mm, addr, ptep) do { } while (0)
62#define pte_update_defer(mm, addr, ptep) do { } while (0)
63#define pmd_update(mm, addr, ptep) do { } while (0)
64#define pmd_update_defer(mm, addr, ptep) do { } while (0)
65
66#define pgd_val(x) native_pgd_val(x)
67#define __pgd(x) native_make_pgd(x)
68
69#ifndef __PAGETABLE_PUD_FOLDED
70#define pud_val(x) native_pud_val(x)
71#define __pud(x) native_make_pud(x)
72#endif
73
74#ifndef __PAGETABLE_PMD_FOLDED
75#define pmd_val(x) native_pmd_val(x)
76#define __pmd(x) native_make_pmd(x)
77#endif
78
79#define pte_val(x) native_pte_val(x)
80#define __pte(x) native_make_pte(x)
81
82#define arch_end_context_switch(prev) do {} while(0)
83
84#endif
85
86
87
88
89
90static inline int pte_dirty(pte_t pte)
91{
92 return pte_flags(pte) & _PAGE_DIRTY;
93}
94
95static inline int pte_young(pte_t pte)
96{
97 return pte_flags(pte) & _PAGE_ACCESSED;
98}
99
100static inline int pmd_young(pmd_t pmd)
101{
102 return pmd_flags(pmd) & _PAGE_ACCESSED;
103}
104
105static inline int pte_write(pte_t pte)
106{
107 return pte_flags(pte) & _PAGE_RW;
108}
109
110static inline int pte_file(pte_t pte)
111{
112 return pte_flags(pte) & _PAGE_FILE;
113}
114
115static inline int pte_huge(pte_t pte)
116{
117 return pte_flags(pte) & _PAGE_PSE;
118}
119
120static inline int pte_global(pte_t pte)
121{
122 return pte_flags(pte) & _PAGE_GLOBAL;
123}
124
125static inline int pte_exec(pte_t pte)
126{
127 return !(pte_flags(pte) & _PAGE_NX);
128}
129
130static inline int pte_special(pte_t pte)
131{
132 return pte_flags(pte) & _PAGE_SPECIAL;
133}
134
135static inline unsigned long pte_pfn(pte_t pte)
136{
137 return (pte_val(pte) & PTE_PFN_MASK) >> PAGE_SHIFT;
138}
139
140static inline unsigned long pmd_pfn(pmd_t pmd)
141{
142 return (pmd_val(pmd) & PTE_PFN_MASK) >> PAGE_SHIFT;
143}
144
145static inline unsigned long pud_pfn(pud_t pud)
146{
147 return (pud_val(pud) & PTE_PFN_MASK) >> PAGE_SHIFT;
148}
149
150#define pte_page(pte) pfn_to_page(pte_pfn(pte))
151
152static inline int pmd_large(pmd_t pte)
153{
154 return pmd_flags(pte) & _PAGE_PSE;
155}
156
157#ifdef CONFIG_TRANSPARENT_HUGEPAGE
158static inline int pmd_trans_splitting(pmd_t pmd)
159{
160 return pmd_val(pmd) & _PAGE_SPLITTING;
161}
162
163static inline int pmd_trans_huge(pmd_t pmd)
164{
165 return pmd_val(pmd) & _PAGE_PSE;
166}
167
168static inline int has_transparent_hugepage(void)
169{
170 return cpu_has_pse;
171}
172#endif
173
174static inline pte_t pte_set_flags(pte_t pte, pteval_t set)
175{
176 pteval_t v = native_pte_val(pte);
177
178 return native_make_pte(v | set);
179}
180
181static inline pte_t pte_clear_flags(pte_t pte, pteval_t clear)
182{
183 pteval_t v = native_pte_val(pte);
184
185 return native_make_pte(v & ~clear);
186}
187
188static inline pte_t pte_mkclean(pte_t pte)
189{
190 return pte_clear_flags(pte, _PAGE_DIRTY);
191}
192
193static inline pte_t pte_mkold(pte_t pte)
194{
195 return pte_clear_flags(pte, _PAGE_ACCESSED);
196}
197
198static inline pte_t pte_wrprotect(pte_t pte)
199{
200 return pte_clear_flags(pte, _PAGE_RW);
201}
202
203static inline pte_t pte_mkexec(pte_t pte)
204{
205 return pte_clear_flags(pte, _PAGE_NX);
206}
207
208static inline pte_t pte_mkdirty(pte_t pte)
209{
210 return pte_set_flags(pte, _PAGE_DIRTY | _PAGE_SOFT_DIRTY);
211}
212
213static inline pte_t pte_mkyoung(pte_t pte)
214{
215 return pte_set_flags(pte, _PAGE_ACCESSED);
216}
217
218static inline pte_t pte_mkwrite(pte_t pte)
219{
220 return pte_set_flags(pte, _PAGE_RW);
221}
222
223static inline pte_t pte_mkhuge(pte_t pte)
224{
225 return pte_set_flags(pte, _PAGE_PSE);
226}
227
228static inline pte_t pte_clrhuge(pte_t pte)
229{
230 return pte_clear_flags(pte, _PAGE_PSE);
231}
232
233static inline pte_t pte_mkglobal(pte_t pte)
234{
235 return pte_set_flags(pte, _PAGE_GLOBAL);
236}
237
238static inline pte_t pte_clrglobal(pte_t pte)
239{
240 return pte_clear_flags(pte, _PAGE_GLOBAL);
241}
242
243static inline pte_t pte_mkspecial(pte_t pte)
244{
245 return pte_set_flags(pte, _PAGE_SPECIAL);
246}
247
248static inline pmd_t pmd_set_flags(pmd_t pmd, pmdval_t set)
249{
250 pmdval_t v = native_pmd_val(pmd);
251
252 return __pmd(v | set);
253}
254
255static inline pmd_t pmd_clear_flags(pmd_t pmd, pmdval_t clear)
256{
257 pmdval_t v = native_pmd_val(pmd);
258
259 return __pmd(v & ~clear);
260}
261
262static inline pmd_t pmd_mkold(pmd_t pmd)
263{
264 return pmd_clear_flags(pmd, _PAGE_ACCESSED);
265}
266
267static inline pmd_t pmd_wrprotect(pmd_t pmd)
268{
269 return pmd_clear_flags(pmd, _PAGE_RW);
270}
271
272static inline pmd_t pmd_mkdirty(pmd_t pmd)
273{
274 return pmd_set_flags(pmd, _PAGE_DIRTY | _PAGE_SOFT_DIRTY);
275}
276
277static inline pmd_t pmd_mkhuge(pmd_t pmd)
278{
279 return pmd_set_flags(pmd, _PAGE_PSE);
280}
281
282static inline pmd_t pmd_mkyoung(pmd_t pmd)
283{
284 return pmd_set_flags(pmd, _PAGE_ACCESSED);
285}
286
287static inline pmd_t pmd_mkwrite(pmd_t pmd)
288{
289 return pmd_set_flags(pmd, _PAGE_RW);
290}
291
292static inline pmd_t pmd_mknotpresent(pmd_t pmd)
293{
294 return pmd_clear_flags(pmd, _PAGE_PRESENT);
295}
296
297static inline int pte_soft_dirty(pte_t pte)
298{
299 return pte_flags(pte) & _PAGE_SOFT_DIRTY;
300}
301
302static inline int pmd_soft_dirty(pmd_t pmd)
303{
304 return pmd_flags(pmd) & _PAGE_SOFT_DIRTY;
305}
306
307static inline pte_t pte_mksoft_dirty(pte_t pte)
308{
309 return pte_set_flags(pte, _PAGE_SOFT_DIRTY);
310}
311
312static inline pmd_t pmd_mksoft_dirty(pmd_t pmd)
313{
314 return pmd_set_flags(pmd, _PAGE_SOFT_DIRTY);
315}
316
317static inline pte_t pte_swp_mksoft_dirty(pte_t pte)
318{
319 return pte_set_flags(pte, _PAGE_SWP_SOFT_DIRTY);
320}
321
322static inline int pte_swp_soft_dirty(pte_t pte)
323{
324 return pte_flags(pte) & _PAGE_SWP_SOFT_DIRTY;
325}
326
327static inline pte_t pte_swp_clear_soft_dirty(pte_t pte)
328{
329 return pte_clear_flags(pte, _PAGE_SWP_SOFT_DIRTY);
330}
331
332static inline pte_t pte_file_clear_soft_dirty(pte_t pte)
333{
334 return pte_clear_flags(pte, _PAGE_SOFT_DIRTY);
335}
336
337static inline pte_t pte_file_mksoft_dirty(pte_t pte)
338{
339 return pte_set_flags(pte, _PAGE_SOFT_DIRTY);
340}
341
342static inline int pte_file_soft_dirty(pte_t pte)
343{
344 return pte_flags(pte) & _PAGE_SOFT_DIRTY;
345}
346
347
348
349
350
351static inline pgprotval_t massage_pgprot(pgprot_t pgprot)
352{
353 pgprotval_t protval = pgprot_val(pgprot);
354
355 if (protval & _PAGE_PRESENT)
356 protval &= __supported_pte_mask;
357
358 return protval;
359}
360
361static inline pte_t pfn_pte(unsigned long page_nr, pgprot_t pgprot)
362{
363 return __pte(((phys_addr_t)page_nr << PAGE_SHIFT) |
364 massage_pgprot(pgprot));
365}
366
367static inline pmd_t pfn_pmd(unsigned long page_nr, pgprot_t pgprot)
368{
369 return __pmd(((phys_addr_t)page_nr << PAGE_SHIFT) |
370 massage_pgprot(pgprot));
371}
372
373static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
374{
375 pteval_t val = pte_val(pte);
376
377
378
379
380
381 val &= _PAGE_CHG_MASK;
382 val |= massage_pgprot(newprot) & ~_PAGE_CHG_MASK;
383
384 return __pte(val);
385}
386
387static inline pmd_t pmd_modify(pmd_t pmd, pgprot_t newprot)
388{
389 pmdval_t val = pmd_val(pmd);
390
391 val &= _HPAGE_CHG_MASK;
392 val |= massage_pgprot(newprot) & ~_HPAGE_CHG_MASK;
393
394 return __pmd(val);
395}
396
397
398#define pgprot_modify pgprot_modify
399static inline pgprot_t pgprot_modify(pgprot_t oldprot, pgprot_t newprot)
400{
401 pgprotval_t preservebits = pgprot_val(oldprot) & _PAGE_CHG_MASK;
402 pgprotval_t addbits = pgprot_val(newprot);
403 return __pgprot(preservebits | addbits);
404}
405
406#define pte_pgprot(x) __pgprot(pte_flags(x) & PTE_FLAGS_MASK)
407
408#define canon_pgprot(p) __pgprot(massage_pgprot(p))
409
410static inline int is_new_memtype_allowed(u64 paddr, unsigned long size,
411 unsigned long flags,
412 unsigned long new_flags)
413{
414
415
416
417 if (x86_platform.is_untracked_pat_range(paddr, paddr + size))
418 return 1;
419
420
421
422
423
424
425
426 if ((flags == _PAGE_CACHE_UC_MINUS &&
427 new_flags == _PAGE_CACHE_WB) ||
428 (flags == _PAGE_CACHE_WC &&
429 new_flags == _PAGE_CACHE_WB)) {
430 return 0;
431 }
432
433 return 1;
434}
435
436pmd_t *populate_extra_pmd(unsigned long vaddr);
437pte_t *populate_extra_pte(unsigned long vaddr);
438#endif
439
440#ifdef CONFIG_X86_32
441# include <asm/pgtable_32.h>
442#else
443# include <asm/pgtable_64.h>
444#endif
445
446#ifndef __ASSEMBLY__
447#include <linux/mm_types.h>
448#include <linux/log2.h>
449
450static inline int pte_none(pte_t pte)
451{
452 return !pte.pte;
453}
454
455#define __HAVE_ARCH_PTE_SAME
456static inline int pte_same(pte_t a, pte_t b)
457{
458 return a.pte == b.pte;
459}
460
461static inline int pte_present(pte_t a)
462{
463 return pte_flags(a) & (_PAGE_PRESENT | _PAGE_PROTNONE |
464 _PAGE_NUMA);
465}
466
467#define pte_accessible pte_accessible
468static inline int pte_accessible(pte_t a)
469{
470 return pte_flags(a) & _PAGE_PRESENT;
471}
472
473static inline int pte_hidden(pte_t pte)
474{
475 return pte_flags(pte) & _PAGE_HIDDEN;
476}
477
478static inline int pmd_present(pmd_t pmd)
479{
480
481
482
483
484
485
486 return pmd_flags(pmd) & (_PAGE_PRESENT | _PAGE_PROTNONE | _PAGE_PSE |
487 _PAGE_NUMA);
488}
489
490static inline int pmd_none(pmd_t pmd)
491{
492
493
494 return (unsigned long)native_pmd_val(pmd) == 0;
495}
496
497static inline unsigned long pmd_page_vaddr(pmd_t pmd)
498{
499 return (unsigned long)__va(pmd_val(pmd) & PTE_PFN_MASK);
500}
501
502
503
504
505
506#define pmd_page(pmd) pfn_to_page((pmd_val(pmd) & PTE_PFN_MASK) >> PAGE_SHIFT)
507
508
509
510
511
512
513
514static inline unsigned long pmd_index(unsigned long address)
515{
516 return (address >> PMD_SHIFT) & (PTRS_PER_PMD - 1);
517}
518
519
520
521
522
523
524
525
526#define mk_pte(page, pgprot) pfn_pte(page_to_pfn(page), (pgprot))
527
528
529
530
531
532
533
534static inline unsigned long pte_index(unsigned long address)
535{
536 return (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
537}
538
539static inline pte_t *pte_offset_kernel(pmd_t *pmd, unsigned long address)
540{
541 return (pte_t *)pmd_page_vaddr(*pmd) + pte_index(address);
542}
543
544static inline int pmd_bad(pmd_t pmd)
545{
546#ifdef CONFIG_NUMA_BALANCING
547
548 if ((pmd_flags(pmd) & (_PAGE_NUMA|_PAGE_PRESENT)) == _PAGE_NUMA)
549 return 0;
550#endif
551 return (pmd_flags(pmd) & ~_PAGE_USER) != _KERNPG_TABLE;
552}
553
554static inline unsigned long pages_to_mb(unsigned long npg)
555{
556 return npg >> (20 - PAGE_SHIFT);
557}
558
559#if PAGETABLE_LEVELS > 2
560static inline int pud_none(pud_t pud)
561{
562 return native_pud_val(pud) == 0;
563}
564
565static inline int pud_present(pud_t pud)
566{
567 return pud_flags(pud) & _PAGE_PRESENT;
568}
569
570static inline unsigned long pud_page_vaddr(pud_t pud)
571{
572 return (unsigned long)__va((unsigned long)pud_val(pud) & PTE_PFN_MASK);
573}
574
575
576
577
578
579#define pud_page(pud) pfn_to_page(pud_val(pud) >> PAGE_SHIFT)
580
581
582static inline pmd_t *pmd_offset(pud_t *pud, unsigned long address)
583{
584 return (pmd_t *)pud_page_vaddr(*pud) + pmd_index(address);
585}
586
587static inline int pud_large(pud_t pud)
588{
589 return (pud_val(pud) & (_PAGE_PSE | _PAGE_PRESENT)) ==
590 (_PAGE_PSE | _PAGE_PRESENT);
591}
592
593static inline int pud_bad(pud_t pud)
594{
595 return (pud_flags(pud) & ~(_KERNPG_TABLE | _PAGE_USER)) != 0;
596}
597#else
598static inline int pud_large(pud_t pud)
599{
600 return 0;
601}
602#endif
603
604#if PAGETABLE_LEVELS > 3
605static inline int pgd_present(pgd_t pgd)
606{
607 return pgd_flags(pgd) & _PAGE_PRESENT;
608}
609
610static inline unsigned long pgd_page_vaddr(pgd_t pgd)
611{
612 return (unsigned long)__va((unsigned long)pgd_val(pgd) & PTE_PFN_MASK);
613}
614
615
616
617
618
619#define pgd_page(pgd) pfn_to_page(pgd_val(pgd) >> PAGE_SHIFT)
620
621
622static inline unsigned long pud_index(unsigned long address)
623{
624 return (address >> PUD_SHIFT) & (PTRS_PER_PUD - 1);
625}
626
627static inline pud_t *pud_offset(pgd_t *pgd, unsigned long address)
628{
629 return (pud_t *)pgd_page_vaddr(*pgd) + pud_index(address);
630}
631
632static inline int pgd_bad(pgd_t pgd)
633{
634 return (pgd_flags(pgd) & ~_PAGE_USER) != _KERNPG_TABLE;
635}
636
637static inline int pgd_none(pgd_t pgd)
638{
639 return !native_pgd_val(pgd);
640}
641#endif
642
643#endif
644
645
646
647
648
649
650
651#define pgd_index(address) (((address) >> PGDIR_SHIFT) & (PTRS_PER_PGD - 1))
652
653
654
655
656
657#define pgd_offset(mm, address) ((mm)->pgd + pgd_index((address)))
658
659
660
661
662#define pgd_offset_k(address) pgd_offset(&init_mm, (address))
663
664
665#define KERNEL_PGD_BOUNDARY pgd_index(PAGE_OFFSET)
666#define KERNEL_PGD_PTRS (PTRS_PER_PGD - KERNEL_PGD_BOUNDARY)
667
668#ifndef __ASSEMBLY__
669
670extern int direct_gbpages;
671void init_mem_mapping(void);
672void early_alloc_pgt_buf(void);
673
674
675static inline pte_t native_local_ptep_get_and_clear(pte_t *ptep)
676{
677 pte_t res = *ptep;
678
679
680 native_pte_clear(NULL, 0, ptep);
681 return res;
682}
683
684static inline pmd_t native_local_pmdp_get_and_clear(pmd_t *pmdp)
685{
686 pmd_t res = *pmdp;
687
688 native_pmd_clear(pmdp);
689 return res;
690}
691
692static inline void native_set_pte_at(struct mm_struct *mm, unsigned long addr,
693 pte_t *ptep , pte_t pte)
694{
695 native_set_pte(ptep, pte);
696}
697
698static inline void native_set_pmd_at(struct mm_struct *mm, unsigned long addr,
699 pmd_t *pmdp , pmd_t pmd)
700{
701 native_set_pmd(pmdp, pmd);
702}
703
704#ifndef CONFIG_PARAVIRT
705
706
707
708
709
710
711
712
713
714
715
716
717
718#define pte_update(mm, addr, ptep) do { } while (0)
719#define pte_update_defer(mm, addr, ptep) do { } while (0)
720#endif
721
722
723
724
725
726
727
728
729struct vm_area_struct;
730
731#define __HAVE_ARCH_PTEP_SET_ACCESS_FLAGS
732extern int ptep_set_access_flags(struct vm_area_struct *vma,
733 unsigned long address, pte_t *ptep,
734 pte_t entry, int dirty);
735
736#define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_YOUNG
737extern int ptep_test_and_clear_young(struct vm_area_struct *vma,
738 unsigned long addr, pte_t *ptep);
739
740#define __HAVE_ARCH_PTEP_CLEAR_YOUNG_FLUSH
741extern int ptep_clear_flush_young(struct vm_area_struct *vma,
742 unsigned long address, pte_t *ptep);
743
744#define __HAVE_ARCH_PTEP_GET_AND_CLEAR
745static inline pte_t ptep_get_and_clear(struct mm_struct *mm, unsigned long addr,
746 pte_t *ptep)
747{
748 pte_t pte = native_ptep_get_and_clear(ptep);
749 pte_update(mm, addr, ptep);
750 return pte;
751}
752
753#define __HAVE_ARCH_PTEP_GET_AND_CLEAR_FULL
754static inline pte_t ptep_get_and_clear_full(struct mm_struct *mm,
755 unsigned long addr, pte_t *ptep,
756 int full)
757{
758 pte_t pte;
759 if (full) {
760
761
762
763
764 pte = native_local_ptep_get_and_clear(ptep);
765 } else {
766 pte = ptep_get_and_clear(mm, addr, ptep);
767 }
768 return pte;
769}
770
771#define __HAVE_ARCH_PTEP_SET_WRPROTECT
772static inline void ptep_set_wrprotect(struct mm_struct *mm,
773 unsigned long addr, pte_t *ptep)
774{
775 clear_bit(_PAGE_BIT_RW, (unsigned long *)&ptep->pte);
776 pte_update(mm, addr, ptep);
777}
778
779#define flush_tlb_fix_spurious_fault(vma, address) do { } while (0)
780
781#define mk_pmd(page, pgprot) pfn_pmd(page_to_pfn(page), (pgprot))
782
783#define __HAVE_ARCH_PMDP_SET_ACCESS_FLAGS
784extern int pmdp_set_access_flags(struct vm_area_struct *vma,
785 unsigned long address, pmd_t *pmdp,
786 pmd_t entry, int dirty);
787
788#define __HAVE_ARCH_PMDP_TEST_AND_CLEAR_YOUNG
789extern int pmdp_test_and_clear_young(struct vm_area_struct *vma,
790 unsigned long addr, pmd_t *pmdp);
791
792#define __HAVE_ARCH_PMDP_CLEAR_YOUNG_FLUSH
793extern int pmdp_clear_flush_young(struct vm_area_struct *vma,
794 unsigned long address, pmd_t *pmdp);
795
796
797#define __HAVE_ARCH_PMDP_SPLITTING_FLUSH
798extern void pmdp_splitting_flush(struct vm_area_struct *vma,
799 unsigned long addr, pmd_t *pmdp);
800
801#define __HAVE_ARCH_PMD_WRITE
802static inline int pmd_write(pmd_t pmd)
803{
804 return pmd_flags(pmd) & _PAGE_RW;
805}
806
807#define __HAVE_ARCH_PMDP_GET_AND_CLEAR
808static inline pmd_t pmdp_get_and_clear(struct mm_struct *mm, unsigned long addr,
809 pmd_t *pmdp)
810{
811 pmd_t pmd = native_pmdp_get_and_clear(pmdp);
812 pmd_update(mm, addr, pmdp);
813 return pmd;
814}
815
816#define __HAVE_ARCH_PMDP_SET_WRPROTECT
817static inline void pmdp_set_wrprotect(struct mm_struct *mm,
818 unsigned long addr, pmd_t *pmdp)
819{
820 clear_bit(_PAGE_BIT_RW, (unsigned long *)pmdp);
821 pmd_update(mm, addr, pmdp);
822}
823
824
825
826
827
828
829
830
831
832
833
834static inline void clone_pgd_range(pgd_t *dst, pgd_t *src, int count)
835{
836 memcpy(dst, src, count * sizeof(pgd_t));
837}
838
839#define PTE_SHIFT ilog2(PTRS_PER_PTE)
840static inline int page_level_shift(enum pg_level level)
841{
842 return (PAGE_SHIFT - PTE_SHIFT) + level * PTE_SHIFT;
843}
844static inline unsigned long page_level_size(enum pg_level level)
845{
846 return 1UL << page_level_shift(level);
847}
848static inline unsigned long page_level_mask(enum pg_level level)
849{
850 return ~(page_level_size(level) - 1);
851}
852
853
854
855
856
857static inline void update_mmu_cache(struct vm_area_struct *vma,
858 unsigned long addr, pte_t *ptep)
859{
860}
861static inline void update_mmu_cache_pmd(struct vm_area_struct *vma,
862 unsigned long addr, pmd_t *pmd)
863{
864}
865
866#include <asm-generic/pgtable.h>
867#endif
868
869#endif
870