# This is a BitKeeper generated diff -Nru style patch. # # ChangeSet # 2004/08/18 14:50:10-07:00 benh@kernel.crashing.org # [PPC]: Use new set_pte() w/mm+address args. # # Signed-off-by: Benjamin Herrenschmidt # Signed-off-by: David S. Miller # # mm/highmem.c # 2004/08/18 14:49:26-07:00 benh@kernel.crashing.org +4 -2 # [PPC]: Use new set_pte() w/mm+address args. # # include/asm-ppc64/pgtable.h # 2004/08/18 14:49:26-07:00 benh@kernel.crashing.org +43 -30 # [PPC]: Use new set_pte() w/mm+address args. # # include/asm-ppc64/pgalloc.h # 2004/08/18 14:49:26-07:00 benh@kernel.crashing.org +6 -22 # [PPC]: Use new set_pte() w/mm+address args. # # include/asm-ppc/pgtable.h # 2004/08/18 14:49:26-07:00 benh@kernel.crashing.org +35 -34 # [PPC]: Use new set_pte() w/mm+address args. # # include/asm-ppc/highmem.h # 2004/08/18 14:49:26-07:00 benh@kernel.crashing.org +2 -2 # [PPC]: Use new set_pte() w/mm+address args. # # arch/ppc64/mm/tlb.c # 2004/08/18 14:49:26-07:00 benh@kernel.crashing.org +2 -9 # [PPC]: Use new set_pte() w/mm+address args. # # arch/ppc64/mm/init.c # 2004/08/18 14:49:26-07:00 benh@kernel.crashing.org +8 -8 # [PPC]: Use new set_pte() w/mm+address args. # # arch/ppc/mm/tlb.c # 2004/08/18 14:49:26-07:00 benh@kernel.crashing.org +0 -20 # [PPC]: Use new set_pte() w/mm+address args. # # arch/ppc/mm/pgtable.c # 2004/08/18 14:49:26-07:00 benh@kernel.crashing.org +4 -14 # [PPC]: Use new set_pte() w/mm+address args. # # arch/ppc/mm/init.c # 2004/08/18 14:49:26-07:00 benh@kernel.crashing.org +0 -13 # [PPC]: Use new set_pte() w/mm+address args. # diff -Nru a/arch/ppc/mm/init.c b/arch/ppc/mm/init.c --- a/arch/ppc/mm/init.c 2004-08-18 15:33:21 -07:00 +++ b/arch/ppc/mm/init.c 2004-08-18 15:33:21 -07:00 @@ -484,19 +484,6 @@ if (agp_special_page) printk(KERN_INFO "AGP special page: 0x%08lx\n", agp_special_page); #endif - - /* Make sure all our pagetable pages have page->mapping - and page->index set correctly. */ - for (addr = KERNELBASE; addr != 0; addr += PGDIR_SIZE) { - struct page *pg; - pmd_t *pmd = pmd_offset(pgd_offset_k(addr), addr); - if (pmd_present(*pmd)) { - pg = pmd_page(*pmd); - pg->mapping = (void *) &init_mm; - pg->index = addr; - } - } - mem_init_done = 1; } diff -Nru a/arch/ppc/mm/pgtable.c b/arch/ppc/mm/pgtable.c --- a/arch/ppc/mm/pgtable.c 2004-08-18 15:33:21 -07:00 +++ b/arch/ppc/mm/pgtable.c 2004-08-18 15:33:21 -07:00 @@ -100,14 +100,9 @@ extern int mem_init_done; extern void *early_get_page(void); - if (mem_init_done) { + if (mem_init_done) pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT); - if (pte) { - struct page *ptepage = virt_to_page(pte); - ptepage->mapping = (void *) mm; - ptepage->index = address & PMD_MASK; - } - } else + else pte = (pte_t *)early_get_page(); if (pte) clear_page(pte); @@ -125,11 +120,8 @@ #endif ptepage = alloc_pages(flags, 0); - if (ptepage) { - ptepage->mapping = (void *) mm; - ptepage->index = address & PMD_MASK; + if (ptepage) clear_highpage(ptepage); - } return ptepage; } @@ -138,7 +130,6 @@ #ifdef CONFIG_SMP hash_page_sync(); #endif - virt_to_page(pte)->mapping = NULL; free_page((unsigned long)pte); } @@ -147,7 +138,6 @@ #ifdef CONFIG_SMP hash_page_sync(); #endif - ptepage->mapping = NULL; __free_page(ptepage); } @@ -285,7 +275,7 @@ pg = pte_alloc_kernel(&init_mm, pd, va); if (pg != 0) { err = 0; - set_pte(pg, pfn_pte(pa >> PAGE_SHIFT, __pgprot(flags))); + set_pte(&init_mm, va, pg, pfn_pte(pa >> PAGE_SHIFT, __pgprot(flags))); if (mem_init_done) flush_HPTE(0, va, pmd_val(*pd)); } diff -Nru a/arch/ppc/mm/tlb.c b/arch/ppc/mm/tlb.c --- a/arch/ppc/mm/tlb.c 2004-08-18 15:33:21 -07:00 +++ b/arch/ppc/mm/tlb.c 2004-08-18 15:33:21 -07:00 @@ -47,26 +47,6 @@ } /* - * Called by ptep_test_and_clear_young() - */ -void flush_hash_one_pte(pte_t *ptep) -{ - struct page *ptepage; - struct mm_struct *mm; - unsigned long ptephys; - unsigned long addr; - - if (Hash == 0) - return; - - ptepage = virt_to_page(ptep); - mm = (struct mm_struct *) ptepage->mapping; - ptephys = __pa(ptep) & PAGE_MASK; - addr = ptepage->index + (((unsigned long)ptep & ~PAGE_MASK) << 9); - flush_hash_pages(mm->context, addr, ptephys, 1); -} - -/* * Called by ptep_set_access_flags, must flush on CPUs for which the * DSI handler can't just "fixup" the TLB on a write fault */ diff -Nru a/arch/ppc64/mm/init.c b/arch/ppc64/mm/init.c --- a/arch/ppc64/mm/init.c 2004-08-18 15:33:21 -07:00 +++ b/arch/ppc64/mm/init.c 2004-08-18 15:33:21 -07:00 @@ -155,7 +155,7 @@ ptep = pte_alloc_kernel(&ioremap_mm, pmdp, ea); pa = abs_to_phys(pa); - set_pte(ptep, pfn_pte(pa >> PAGE_SHIFT, __pgprot(flags))); + set_pte(&ioremap_mm, ea, ptep, pfn_pte(pa >> PAGE_SHIFT, __pgprot(flags))); spin_unlock(&ioremap_mm.page_table_lock); } else { unsigned long va, vpn, hash, hpteg; @@ -287,8 +287,8 @@ return 0; } -static void unmap_im_area_pte(pmd_t *pmd, unsigned long address, - unsigned long size) +static void unmap_im_area_pte(struct mm_struct *mm, pmd_t *pmd, unsigned long address, + unsigned long size) { unsigned long end; pte_t *pte; @@ -309,7 +309,7 @@ do { pte_t page; - page = ptep_get_and_clear(pte); + page = ptep_get_and_clear(mm, address, pte); address += PAGE_SIZE; pte++; if (pte_none(page)) @@ -320,8 +320,8 @@ } while (address < end); } -static void unmap_im_area_pmd(pgd_t *dir, unsigned long address, - unsigned long size) +static void unmap_im_area_pmd(struct mm_struct *mm, pgd_t *dir, unsigned long address, + unsigned long size) { unsigned long end; pmd_t *pmd; @@ -341,7 +341,7 @@ end = PGDIR_SIZE; do { - unmap_im_area_pte(pmd, address, end - address); + unmap_im_area_pte(mm, pmd, address, end - address); address = (address + PMD_SIZE) & PMD_MASK; pmd++; } while (address < end); @@ -382,7 +382,7 @@ dir = pgd_offset_i(address); flush_cache_vunmap(address, end); do { - unmap_im_area_pmd(dir, address, end - address); + unmap_im_area_pmd(mm, dir, address, end - address); address = (address + PGDIR_SIZE) & PGDIR_MASK; dir++; } while (address && (address < end)); diff -Nru a/arch/ppc64/mm/tlb.c b/arch/ppc64/mm/tlb.c --- a/arch/ppc64/mm/tlb.c 2004-08-18 15:33:21 -07:00 +++ b/arch/ppc64/mm/tlb.c 2004-08-18 15:33:21 -07:00 @@ -74,19 +74,12 @@ * change the existing HPTE to read-only rather than removing it * (if we remove it we should clear the _PTE_HPTEFLAGS bits). */ -void hpte_update(pte_t *ptep, unsigned long pte, int wrprot) +void hpte_update(struct mm_struct *mm, unsigned long addr, unsigned long pte, + int wrprot) { - struct page *ptepage; - struct mm_struct *mm; - unsigned long addr; int i; unsigned long context = 0; struct ppc64_tlb_batch *batch = &__get_cpu_var(ppc64_tlb_batch); - - ptepage = virt_to_page(ptep); - mm = (struct mm_struct *) ptepage->mapping; - addr = ptepage->index + - (((unsigned long)ptep & ~PAGE_MASK) * PTRS_PER_PTE); if (REGION_ID(addr) == USER_REGION_ID) context = mm->context.id; diff -Nru a/include/asm-ppc/highmem.h b/include/asm-ppc/highmem.h --- a/include/asm-ppc/highmem.h 2004-08-18 15:33:21 -07:00 +++ b/include/asm-ppc/highmem.h 2004-08-18 15:33:21 -07:00 @@ -90,7 +90,7 @@ #ifdef HIGHMEM_DEBUG BUG_ON(!pte_none(*(kmap_pte+idx))); #endif - set_pte(kmap_pte+idx, mk_pte(page, kmap_prot)); + set_pte(&init_mm, vaddr, kmap_pte+idx, mk_pte(page, kmap_prot)); flush_tlb_page(NULL, vaddr); return (void*) vaddr; @@ -114,7 +114,7 @@ * force other mappings to Oops if they'll try to access * this pte without first remap it */ - pte_clear(kmap_pte+idx); + pte_clear(&init_mm, vaddr, kmap_pte+idx); flush_tlb_page(NULL, vaddr); #endif dec_preempt_count(); diff -Nru a/include/asm-ppc/pgtable.h b/include/asm-ppc/pgtable.h --- a/include/asm-ppc/pgtable.h 2004-08-18 15:33:21 -07:00 +++ b/include/asm-ppc/pgtable.h 2004-08-18 15:33:21 -07:00 @@ -445,7 +445,7 @@ #define pte_none(pte) ((pte_val(pte) & ~_PTE_NONE_MASK) == 0) #define pte_present(pte) (pte_val(pte) & _PAGE_PRESENT) -#define pte_clear(ptep) do { set_pte((ptep), __pte(0)); } while (0) +#define pte_clear(mm,addr,ptep) do { set_pte((mm), (addr), (ptep), __pte(0)); } while (0) #define pmd_none(pmd) (!pmd_val(pmd)) #define pmd_bad(pmd) (pmd_val(pmd) & _PMD_BAD) @@ -509,6 +509,17 @@ } /* + * When flushing the tlb entry for a page, we also need to flush the hash + * table entry. flush_hash_pages is assembler (for speed) in hashtable.S. + */ +extern int flush_hash_pages(unsigned context, unsigned long va, + unsigned long pmdval, int count); + +/* Add an HPTE to the hash table */ +extern void add_hash_page(unsigned context, unsigned long va, + unsigned long pmdval); + +/* * Atomic PTE updates. * * pte_update clears and sets bit atomically, and returns @@ -539,7 +550,8 @@ * On machines which use an MMU hash table we avoid changing the * _PAGE_HASHPTE bit. */ -static inline void set_pte(pte_t *ptep, pte_t pte) +static inline void set_pte(struct mm_struct *mm, unsigned long addr, + pte_t *ptep, pte_t pte) { #if _PAGE_HASHPTE != 0 pte_update(ptep, ~_PAGE_HASHPTE, pte_val(pte) & ~_PAGE_HASHPTE); @@ -548,43 +560,48 @@ #endif } -extern void flush_hash_one_pte(pte_t *ptep); - /* * 2.6 calles this without flushing the TLB entry, this is wrong * for our hash-based implementation, we fix that up here */ -static inline int ptep_test_and_clear_young(pte_t *ptep) +#define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_YOUNG +static inline int __ptep_test_and_clear_young(unsigned context, unsigned long addr, + pte_t *ptep) { unsigned long old; old = (pte_update(ptep, _PAGE_ACCESSED, 0) & _PAGE_ACCESSED); #if _PAGE_HASHPTE != 0 - if (old & _PAGE_HASHPTE) - flush_hash_one_pte(ptep); + if (old & _PAGE_HASHPTE) { + unsigned long ptephys = __pa(ptep) & PAGE_MASK; + flush_hash_pages(context, addr, ptephys, 1); + } #endif return old != 0; } +#define ptep_test_and_clear_young(__vma, __addr, __ptep) \ + __ptep_test_and_clear_young((__vma)->vm_mm->context, __addr, __ptep) -static inline int ptep_test_and_clear_dirty(pte_t *ptep) +#define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_DIRTY +static inline int ptep_test_and_clear_dirty(struct vm_area_struct *vma, + unsigned long addr, pte_t *ptep) { return (pte_update(ptep, (_PAGE_DIRTY | _PAGE_HWWRITE), 0) & _PAGE_DIRTY) != 0; } -static inline pte_t ptep_get_and_clear(pte_t *ptep) +#define __HAVE_ARCH_PTEP_GET_AND_CLEAR +static inline pte_t ptep_get_and_clear(struct mm_struct *mm, unsigned long addr, + pte_t *ptep) { return __pte(pte_update(ptep, ~_PAGE_HASHPTE, 0)); } -static inline void ptep_set_wrprotect(pte_t *ptep) +#define __HAVE_ARCH_PTEP_SET_WRPROTECT +static inline void ptep_set_wrprotect(struct mm_struct *mm, unsigned long addr, + pte_t *ptep) { pte_update(ptep, (_PAGE_RW | _PAGE_HWWRITE), 0); } -static inline void ptep_mkdirty(pte_t *ptep) -{ - pte_update(ptep, 0, _PAGE_DIRTY); -} - #define __HAVE_ARCH_PTEP_SET_ACCESS_FLAGS static inline void __ptep_set_access_flags(pte_t *ptep, pte_t entry, int dirty) { @@ -604,6 +621,7 @@ */ #define pgprot_noncached(prot) (__pgprot(pgprot_val(prot) | _PAGE_NO_CACHE | _PAGE_GUARDED)) +#define __HAVE_ARCH_PTE_SAME #define pte_same(A,B) (((pte_val(A) ^ pte_val(B)) & ~_PAGE_HASHPTE) == 0) /* @@ -656,17 +674,6 @@ extern void paging_init(void); /* - * When flushing the tlb entry for a page, we also need to flush the hash - * table entry. flush_hash_pages is assembler (for speed) in hashtable.S. - */ -extern int flush_hash_pages(unsigned context, unsigned long va, - unsigned long pmdval, int count); - -/* Add an HPTE to the hash table */ -extern void add_hash_page(unsigned context, unsigned long va, - unsigned long pmdval); - -/* * Encode and decode a swap entry. * Note that the bits we use in a PTE for representing a swap entry * must not include the _PAGE_PRESENT bit, the _PAGE_FILE bit, or the @@ -723,15 +730,9 @@ extern int get_pteptr(struct mm_struct *mm, unsigned long addr, pte_t **ptep); -#endif /* !__ASSEMBLY__ */ - -#define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_YOUNG -#define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_DIRTY -#define __HAVE_ARCH_PTEP_GET_AND_CLEAR -#define __HAVE_ARCH_PTEP_SET_WRPROTECT -#define __HAVE_ARCH_PTEP_MKDIRTY -#define __HAVE_ARCH_PTE_SAME #include + +#endif /* !__ASSEMBLY__ */ #endif /* _PPC_PGTABLE_H */ #endif /* __KERNEL__ */ diff -Nru a/include/asm-ppc64/pgalloc.h b/include/asm-ppc64/pgalloc.h --- a/include/asm-ppc64/pgalloc.h 2004-08-18 15:33:21 -07:00 +++ b/include/asm-ppc64/pgalloc.h 2004-08-18 15:33:21 -07:00 @@ -47,42 +47,26 @@ #define pmd_populate(mm, pmd, pte_page) \ pmd_populate_kernel(mm, pmd, page_address(pte_page)) -static inline pte_t * -pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address) +static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address) { - pte_t *pte; - pte = kmem_cache_alloc(zero_cache, GFP_KERNEL|__GFP_REPEAT); - if (pte) { - struct page *ptepage = virt_to_page(pte); - ptepage->mapping = (void *) mm; - ptepage->index = address & PMD_MASK; - } - return pte; + return kmem_cache_alloc(zero_cache, GFP_KERNEL|__GFP_REPEAT); } -static inline struct page * -pte_alloc_one(struct mm_struct *mm, unsigned long address) +static inline struct page *pte_alloc_one(struct mm_struct *mm, unsigned long address) { - pte_t *pte; - pte = kmem_cache_alloc(zero_cache, GFP_KERNEL|__GFP_REPEAT); - if (pte) { - struct page *ptepage = virt_to_page(pte); - ptepage->mapping = (void *) mm; - ptepage->index = address & PMD_MASK; - return ptepage; - } + pte_t *pte = kmem_cache_alloc(zero_cache, GFP_KERNEL|__GFP_REPEAT); + if (pte) + return virt_to_page(pte); return NULL; } static inline void pte_free_kernel(pte_t *pte) { - virt_to_page(pte)->mapping = NULL; kmem_cache_free(zero_cache, pte); } static inline void pte_free(struct page *ptepage) { - ptepage->mapping = NULL; kmem_cache_free(zero_cache, page_address(ptepage)); } diff -Nru a/include/asm-ppc64/pgtable.h b/include/asm-ppc64/pgtable.h --- a/include/asm-ppc64/pgtable.h 2004-08-18 15:33:21 -07:00 +++ b/include/asm-ppc64/pgtable.h 2004-08-18 15:33:21 -07:00 @@ -310,9 +310,10 @@ * batch, doesn't actually triggers the hash flush immediately, * you need to call flush_tlb_pending() to do that. */ -extern void hpte_update(pte_t *ptep, unsigned long pte, int wrprot); +extern void hpte_update(struct mm_struct *mm, unsigned long addr, unsigned long pte, + int wrprot); -static inline int ptep_test_and_clear_young(pte_t *ptep) +static inline int __ptep_test_and_clear_young(struct mm_struct *mm, unsigned long addr, pte_t *ptep) { unsigned long old; @@ -320,18 +321,26 @@ return 0; old = pte_update(ptep, _PAGE_ACCESSED); if (old & _PAGE_HASHPTE) { - hpte_update(ptep, old, 0); + hpte_update(mm, addr, old, 0); flush_tlb_pending(); } return (old & _PAGE_ACCESSED) != 0; } +#define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_YOUNG +#define ptep_test_and_clear_young(__vma, __addr, __ptep) \ +({ \ + int __r; \ + __r = __ptep_test_and_clear_young((__vma)->vm_mm, __addr, __ptep); \ + __r; \ +}) + /* * On RW/DIRTY bit transitions we can avoid flushing the hpte. For the * moment we always flush but we need to fix hpte_update and test if the * optimisation is worth it. */ -static inline int ptep_test_and_clear_dirty(pte_t *ptep) +static inline int __ptep_test_and_clear_dirty(struct mm_struct *mm, unsigned long addr, pte_t *ptep) { unsigned long old; @@ -339,11 +348,19 @@ return 0; old = pte_update(ptep, _PAGE_DIRTY); if (old & _PAGE_HASHPTE) - hpte_update(ptep, old, 0); + hpte_update(mm, addr, old, 0); return (old & _PAGE_DIRTY) != 0; } +#define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_DIRTY +#define ptep_test_and_clear_dirty(__vma, __addr, __ptep) \ +({ \ + int __r; \ + __r = __ptep_test_and_clear_dirty((__vma)->vm_mm, __addr, __ptep); \ + __r; \ +}) -static inline void ptep_set_wrprotect(pte_t *ptep) +#define __HAVE_ARCH_PTEP_SET_WRPROTECT +static inline void ptep_set_wrprotect(struct mm_struct *mm, unsigned long addr, pte_t *ptep) { unsigned long old; @@ -351,7 +368,7 @@ return; old = pte_update(ptep, _PAGE_RW); if (old & _PAGE_HASHPTE) - hpte_update(ptep, old, 0); + hpte_update(mm, addr, old, 0); } /* @@ -363,44 +380,45 @@ * these functions and force a tlb flush unconditionally */ #define __HAVE_ARCH_PTEP_CLEAR_YOUNG_FLUSH -#define ptep_clear_flush_young(__vma, __address, __ptep) \ -({ \ - int __young = ptep_test_and_clear_young(__ptep); \ - __young; \ +#define ptep_clear_flush_young(__vma, __address, __ptep) \ +({ \ + int __young = __ptep_test_and_clear_young((__vma)->vm_mm, __address, __ptep); \ + __young; \ }) #define __HAVE_ARCH_PTEP_CLEAR_DIRTY_FLUSH -#define ptep_clear_flush_dirty(__vma, __address, __ptep) \ -({ \ - int __dirty = ptep_test_and_clear_dirty(__ptep); \ - flush_tlb_page(__vma, __address); \ - __dirty; \ +#define ptep_clear_flush_dirty(__vma, __address, __ptep) \ +({ \ + int __dirty = __ptep_test_and_clear_dirty((__vma)->vm_mm, __address, __ptep); \ + flush_tlb_page(__vma, __address); \ + __dirty; \ }) -static inline pte_t ptep_get_and_clear(pte_t *ptep) +#define __HAVE_ARCH_PTEP_GET_AND_CLEAR +static inline pte_t ptep_get_and_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep) { unsigned long old = pte_update(ptep, ~0UL); if (old & _PAGE_HASHPTE) - hpte_update(ptep, old, 0); + hpte_update(mm, addr, old, 0); return __pte(old); } -static inline void pte_clear(pte_t * ptep) +static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t * ptep) { unsigned long old = pte_update(ptep, ~0UL); if (old & _PAGE_HASHPTE) - hpte_update(ptep, old, 0); + hpte_update(mm, addr, old, 0); } /* * set_pte stores a linux PTE into the linux page table. */ -static inline void set_pte(pte_t *ptep, pte_t pte) +static inline void set_pte(struct mm_struct *mm, unsigned long addr, pte_t *ptep, pte_t pte) { if (pte_present(*ptep)) { - pte_clear(ptep); + pte_clear(mm, addr, ptep); flush_tlb_pending(); } *ptep = __pte(pte_val(pte)) & ~_PAGE_HPTEFLAGS; @@ -438,6 +456,7 @@ */ #define pgprot_noncached(prot) (__pgprot(pgprot_val(prot) | _PAGE_NO_CACHE | _PAGE_GUARDED)) +#define __HAVE_ARCH_PTE_SAME #define pte_same(A,B) (((pte_val(A) ^ pte_val(B)) & ~_PAGE_HPTEFLAGS) == 0) extern unsigned long ioremap_bot, ioremap_base; @@ -538,14 +557,8 @@ return pt; } -#endif /* __ASSEMBLY__ */ - -#define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_YOUNG -#define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_DIRTY -#define __HAVE_ARCH_PTEP_GET_AND_CLEAR -#define __HAVE_ARCH_PTEP_SET_WRPROTECT -#define __HAVE_ARCH_PTEP_MKDIRTY -#define __HAVE_ARCH_PTE_SAME #include + +#endif /* __ASSEMBLY__ */ #endif /* _PPC64_PGTABLE_H */ diff -Nru a/mm/highmem.c b/mm/highmem.c --- a/mm/highmem.c 2004-08-18 15:33:21 -07:00 +++ b/mm/highmem.c 2004-08-18 15:33:21 -07:00 @@ -90,7 +90,8 @@ * So no dangers, even with speculative execution. */ page = pte_page(pkmap_page_table[i]); - pte_clear(&pkmap_page_table[i]); + pte_clear(&init_mm, (unsigned long)page_address(page), + &pkmap_page_table[i]); set_page_address(page, NULL); } @@ -138,7 +139,8 @@ } } vaddr = PKMAP_ADDR(last_pkmap_nr); - set_pte(&(pkmap_page_table[last_pkmap_nr]), mk_pte(page, kmap_prot)); + set_pte(&init_mm, vaddr, + &(pkmap_page_table[last_pkmap_nr]), mk_pte(page, kmap_prot)); pkmap_count[last_pkmap_nr] = 1; set_page_address(page, (void *)vaddr);