Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f6b83f07 authored by David S. Miller's avatar David S. Miller
Browse files

[SPARC64]: Fix 2 bugs in huge page support. 



1) huge_pte_offset() did not check the page table hierarchy
   elements as being empty correctly, resulting in an OOPS

2) Need platform specific hugetlb_get_unmapped_area() to handle
   the top-down vs. bottom-up address space allocation strategies.

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 467418f3

arch/sparc64/mm/hugetlbpage.c

+175 −4
Original line number Diff line number Diff line 
/*

 * SPARC64 Huge TLB page support.

 *

 * Copyright (C) 2002, 2003 David S. Miller (davem@redhat.com)

 * Copyright (C) 2002, 2003, 2006 David S. Miller (davem@davemloft.net)

 */



#include <linux/config.h>
@@ -22,6 +22,175 @@ 
#include <asm/cacheflush.h>

#include <asm/mmu_context.h>



/* Slightly simplified from the non-hugepage variant because by

 * definition we don't have to worry about any page coloring stuff

 */

#define VA_EXCLUDE_START (0x0000080000000000UL - (1UL << 32UL))

#define VA_EXCLUDE_END   (0xfffff80000000000UL + (1UL << 32UL))



static unsigned long hugetlb_get_unmapped_area_bottomup(struct file *filp,

							unsigned long addr,

							unsigned long len,

							unsigned long pgoff,

							unsigned long flags)

{

	struct mm_struct *mm = current->mm;

	struct vm_area_struct * vma;

	unsigned long task_size = TASK_SIZE;

	unsigned long start_addr;



	if (test_thread_flag(TIF_32BIT))

		task_size = STACK_TOP32;

	if (unlikely(len >= VA_EXCLUDE_START))

		return -ENOMEM;



	if (len > mm->cached_hole_size) {

	        start_addr = addr = mm->free_area_cache;

	} else {

	        start_addr = addr = TASK_UNMAPPED_BASE;

	        mm->cached_hole_size = 0;

	}



	task_size -= len;



full_search:

	addr = ALIGN(addr, HPAGE_SIZE);



	for (vma = find_vma(mm, addr); ; vma = vma->vm_next) {

		/* At this point:  (!vma || addr < vma->vm_end). */

		if (addr < VA_EXCLUDE_START &&

		    (addr + len) >= VA_EXCLUDE_START) {

			addr = VA_EXCLUDE_END;

			vma = find_vma(mm, VA_EXCLUDE_END);

		}

		if (unlikely(task_size < addr)) {

			if (start_addr != TASK_UNMAPPED_BASE) {

				start_addr = addr = TASK_UNMAPPED_BASE;

				mm->cached_hole_size = 0;

				goto full_search;

			}

			return -ENOMEM;

		}

		if (likely(!vma || addr + len <= vma->vm_start)) {

			/*

			 * Remember the place where we stopped the search:

			 */

			mm->free_area_cache = addr + len;

			return addr;

		}

		if (addr + mm->cached_hole_size < vma->vm_start)

		        mm->cached_hole_size = vma->vm_start - addr;



		addr = ALIGN(vma->vm_end, HPAGE_SIZE);

	}

}



static unsigned long

hugetlb_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0,

				  const unsigned long len,

				  const unsigned long pgoff,

				  const unsigned long flags)

{

	struct vm_area_struct *vma;

	struct mm_struct *mm = current->mm;

	unsigned long addr = addr0;



	/* This should only ever run for 32-bit processes.  */

	BUG_ON(!test_thread_flag(TIF_32BIT));



	/* check if free_area_cache is useful for us */

	if (len <= mm->cached_hole_size) {

 	        mm->cached_hole_size = 0;

 		mm->free_area_cache = mm->mmap_base;

 	}



	/* either no address requested or can't fit in requested address hole */

	addr = mm->free_area_cache & HPAGE_MASK;



	/* make sure it can fit in the remaining address space */

	if (likely(addr > len)) {

		vma = find_vma(mm, addr-len);

		if (!vma || addr <= vma->vm_start) {

			/* remember the address as a hint for next time */

			return (mm->free_area_cache = addr-len);

		}

	}



	if (unlikely(mm->mmap_base < len))

		goto bottomup;



	addr = (mm->mmap_base-len) & HPAGE_MASK;



	do {

		/*

		 * Lookup failure means no vma is above this address,

		 * else if new region fits below vma->vm_start,

		 * return with success:

		 */

		vma = find_vma(mm, addr);

		if (likely(!vma || addr+len <= vma->vm_start)) {

			/* remember the address as a hint for next time */

			return (mm->free_area_cache = addr);

		}



 		/* remember the largest hole we saw so far */

 		if (addr + mm->cached_hole_size < vma->vm_start)

 		        mm->cached_hole_size = vma->vm_start - addr;



		/* try just below the current vma->vm_start */

		addr = (vma->vm_start-len) & HPAGE_MASK;

	} while (likely(len < vma->vm_start));



bottomup:

	/*

	 * A failed mmap() very likely causes application failure,

	 * so fall back to the bottom-up function here. This scenario

	 * can happen with large stack limits and large mmap()

	 * allocations.

	 */

	mm->cached_hole_size = ~0UL;

  	mm->free_area_cache = TASK_UNMAPPED_BASE;

	addr = arch_get_unmapped_area(filp, addr0, len, pgoff, flags);

	/*

	 * Restore the topdown base:

	 */

	mm->free_area_cache = mm->mmap_base;

	mm->cached_hole_size = ~0UL;



	return addr;

}



unsigned long

hugetlb_get_unmapped_area(struct file *file, unsigned long addr,

		unsigned long len, unsigned long pgoff, unsigned long flags)

{

	struct mm_struct *mm = current->mm;

	struct vm_area_struct *vma;

	unsigned long task_size = TASK_SIZE;



	if (test_thread_flag(TIF_32BIT))

		task_size = STACK_TOP32;



	if (len & ~HPAGE_MASK)

		return -EINVAL;

	if (len > task_size)

		return -ENOMEM;



	if (addr) {

		addr = ALIGN(addr, HPAGE_SIZE);

		vma = find_vma(mm, addr);

		if (task_size - len >= addr &&

		    (!vma || addr + len <= vma->vm_start))

			return addr;

	}

	if (mm->get_unmapped_area == arch_get_unmapped_area)

		return hugetlb_get_unmapped_area_bottomup(file, addr, len,

				pgoff, flags);

	else

		return hugetlb_get_unmapped_area_topdown(file, addr, len,

				pgoff, flags);

}



pte_t *huge_pte_alloc(struct mm_struct *mm, unsigned long addr)

{

	pgd_t *pgd;
@@ -48,12 +217,14 @@ pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr) 
	pmd_t *pmd;

	pte_t *pte = NULL;



	addr &= HPAGE_MASK;



	pgd = pgd_offset(mm, addr);

	if (pgd) {

	if (!pgd_none(*pgd)) {

		pud = pud_offset(pgd, addr);

		if (pud) {

		if (!pud_none(*pud)) {

			pmd = pmd_offset(pud, addr);

			if (pmd)

			if (!pmd_none(*pmd))

				pte = pte_offset_map(pmd, addr);

		}

	}

include/asm-sparc64/page.h

+1 −0
Original line number Diff line number Diff line
@@ -104,6 +104,7 @@ typedef unsigned long pgprot_t; 
#define HUGETLB_PAGE_ORDER	(HPAGE_SHIFT - PAGE_SHIFT)

#define ARCH_HAS_SETCLEAR_HUGE_PTE

#define ARCH_HAS_HUGETLB_PREFAULT_HOOK

#define HAVE_ARCH_HUGETLB_UNMAPPED_AREA

#endif



#define TASK_UNMAPPED_BASE	(test_thread_flag(TIF_32BIT) ? \