[linux-2.6-block.git] / arch / powerpc / mm / hugetlbpage-radix.c

// SPDX-License-Identifier: GPL-2.0
#include <linux/mm.h>
#include <linux/hugetlb.h>
#include <linux/security.h>
#include <asm/pgtable.h>
#include <asm/pgalloc.h>
#include <asm/cacheflush.h>
#include <asm/machdep.h>
#include <asm/mman.h>
#include <asm/tlb.h>

void radix__flush_hugetlb_page(struct vm_area_struct *vma, unsigned long vmaddr)
{
	int psize;
	struct hstate *hstate = hstate_file(vma->vm_file);

	psize = hstate_get_psize(hstate);
	radix__flush_tlb_page_psize(vma->vm_mm, vmaddr, psize);
}

void radix__local_flush_hugetlb_page(struct vm_area_struct *vma, unsigned long vmaddr)
{
	int psize;
	struct hstate *hstate = hstate_file(vma->vm_file);

	psize = hstate_get_psize(hstate);
	radix__local_flush_tlb_page_psize(vma->vm_mm, vmaddr, psize);
}

void radix__flush_hugetlb_tlb_range(struct vm_area_struct *vma, unsigned long start,
				   unsigned long end)
{
	int psize;
	struct hstate *hstate = hstate_file(vma->vm_file);

	psize = hstate_get_psize(hstate);
	radix__flush_tlb_range_psize(vma->vm_mm, start, end, psize);
}

/*
 * A vairant of hugetlb_get_unmapped_area doing topdown search
 * FIXME!! should we do as x86 does or non hugetlb area does ?
 * ie, use topdown or not based on mmap_is_legacy check ?
 */
unsigned long
radix__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;
	struct hstate *h = hstate_file(file);
	int fixed = (flags & MAP_FIXED);
	unsigned long high_limit;
	struct vm_unmapped_area_info info;

	high_limit = DEFAULT_MAP_WINDOW;
	if (addr >= high_limit || (fixed && (addr + len > high_limit)))
		high_limit = TASK_SIZE;

	if (len & ~huge_page_mask(h))
		return -EINVAL;
	if (len > high_limit)
		return -ENOMEM;

	if (fixed) {
		if (addr > high_limit - len)
			return -ENOMEM;
		if (prepare_hugepage_range(file, addr, len))
			return -EINVAL;
		return addr;
	}

	if (addr) {
		addr = ALIGN(addr, huge_page_size(h));
		vma = find_vma(mm, addr);
		if (high_limit - len >= addr && addr >= mmap_min_addr &&
		    (!vma || addr + len <= vm_start_gap(vma)))
			return addr;
	}
	/*
	 * We are always doing an topdown search here. Slice code
	 * does that too.
	 */
	info.flags = VM_UNMAPPED_AREA_TOPDOWN;
	info.length = len;
	info.low_limit = max(PAGE_SIZE, mmap_min_addr);
	info.high_limit = mm->mmap_base + (high_limit - DEFAULT_MAP_WINDOW);
	info.align_mask = PAGE_MASK & ~huge_page_mask(h);
	info.align_offset = 0;

	return vm_unmapped_area(&info);
}

void radix__huge_ptep_modify_prot_commit(struct vm_area_struct *vma,
					 unsigned long addr, pte_t *ptep,
					 pte_t old_pte, pte_t pte)
{
	struct mm_struct *mm = vma->vm_mm;

	/*
	 * To avoid NMMU hang while relaxing access we need to flush the tlb before
	 * we set the new value.
	 */
	if (is_pte_rw_upgrade(pte_val(old_pte), pte_val(pte)) &&
	    (atomic_read(&mm->context.copros) > 0))
		radix__flush_hugetlb_page(vma, addr);

	set_huge_pte_at(vma->vm_mm, addr, ptep, pte);
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
48483760 AK	2	#include <linux/mm.h>
48483760 AK	3	#include <linux/hugetlb.h>
5330367f	4	#include <linux/security.h>
48483760 AK	5	#include <asm/pgtable.h>
	6	#include <asm/pgalloc.h>
	7	#include <asm/cacheflush.h>
	8	#include <asm/machdep.h>
	9	#include <asm/mman.h>
fbfa26d8	10	#include <asm/tlb.h>
48483760 AK	11
	12	void radix__flush_hugetlb_page(struct vm_area_struct *vma, unsigned long vmaddr)
	13	{
fbfa26d8	14	int psize;
48483760 AK	15	struct hstate *hstate = hstate_file(vma->vm_file);
48483760 AK	16
fbfa26d8 AK	17	psize = hstate_get_psize(hstate);
fbfa26d8 AK	18	radix__flush_tlb_page_psize(vma->vm_mm, vmaddr, psize);
48483760 AK	19	}
	20
	21	void radix__local_flush_hugetlb_page(struct vm_area_struct *vma, unsigned long vmaddr)
	22	{
fbfa26d8	23	int psize;
48483760 AK	24	struct hstate *hstate = hstate_file(vma->vm_file);
48483760 AK	25
fbfa26d8 AK	26	psize = hstate_get_psize(hstate);
fbfa26d8 AK	27	radix__local_flush_tlb_page_psize(vma->vm_mm, vmaddr, psize);
48483760 AK	28	}
48483760 AK	29
5491ae7b AK	30	void radix__flush_hugetlb_tlb_range(struct vm_area_struct *vma, unsigned long start,
	31	unsigned long end)
	32	{
	33	int psize;
	34	struct hstate *hstate = hstate_file(vma->vm_file);
	35
	36	psize = hstate_get_psize(hstate);
	37	radix__flush_tlb_range_psize(vma->vm_mm, start, end, psize);
	38	}
	39
48483760 AK	40	/*
	41	* A vairant of hugetlb_get_unmapped_area doing topdown search
	42	* FIXME!! should we do as x86 does or non hugetlb area does ?
	43	* ie, use topdown or not based on mmap_is_legacy check ?
	44	*/
	45	unsigned long
	46	radix__hugetlb_get_unmapped_area(struct file *file, unsigned long addr,
	47	unsigned long len, unsigned long pgoff,
	48	unsigned long flags)
	49	{
	50	struct mm_struct *mm = current->mm;
	51	struct vm_area_struct *vma;
	52	struct hstate *h = hstate_file(file);
85e3f1ad NP	53	int fixed = (flags & MAP_FIXED);
85e3f1ad NP	54	unsigned long high_limit;
48483760 AK	55	struct vm_unmapped_area_info info;
48483760 AK	56
85e3f1ad NP	57	high_limit = DEFAULT_MAP_WINDOW;
	58	if (addr >= high_limit \|\| (fixed && (addr + len > high_limit)))
	59	high_limit = TASK_SIZE;
f4ea6dcb	60
48483760 AK	61	if (len & ~huge_page_mask(h))
48483760 AK	62	return -EINVAL;
85e3f1ad	63	if (len > high_limit)
48483760 AK	64	return -ENOMEM;
48483760 AK	65
85e3f1ad NP	66	if (fixed) {
	67	if (addr > high_limit - len)
	68	return -ENOMEM;
48483760 AK	69	if (prepare_hugepage_range(file, addr, len))
	70	return -EINVAL;
	71	return addr;
	72	}
	73
	74	if (addr) {
	75	addr = ALIGN(addr, huge_page_size(h));
	76	vma = find_vma(mm, addr);
5330367f	77	if (high_limit - len >= addr && addr >= mmap_min_addr &&
1be7107f	78	(!vma \|\| addr + len <= vm_start_gap(vma)))
48483760 AK	79	return addr;
	80	}
	81	/*
	82	* We are always doing an topdown search here. Slice code
	83	* does that too.
	84	*/
	85	info.flags = VM_UNMAPPED_AREA_TOPDOWN;
	86	info.length = len;
5330367f	87	info.low_limit = max(PAGE_SIZE, mmap_min_addr);
85e3f1ad	88	info.high_limit = mm->mmap_base + (high_limit - DEFAULT_MAP_WINDOW);
48483760 AK	89	info.align_mask = PAGE_MASK & ~huge_page_mask(h);
48483760 AK	90	info.align_offset = 0;
f4ea6dcb	91
48483760 AK	92	return vm_unmapped_area(&info);
48483760 AK	93	}
8ef5cbde AK	94
	95	void radix__huge_ptep_modify_prot_commit(struct vm_area_struct *vma,
	96	unsigned long addr, pte_t *ptep,
	97	pte_t old_pte, pte_t pte)
	98	{
	99	struct mm_struct *mm = vma->vm_mm;
	100
	101	/*
	102	* To avoid NMMU hang while relaxing access we need to flush the tlb before
	103	* we set the new value.
	104	*/
	105	if (is_pte_rw_upgrade(pte_val(old_pte), pte_val(pte)) &&
	106	(atomic_read(&mm->context.copros) > 0))
	107	radix__flush_hugetlb_page(vma, addr);
	108
	109	set_huge_pte_at(vma->vm_mm, addr, ptep, pte);
	110	}