Commit e7f260a2 authored by venkatesh.pallipadi@intel.com's avatar venkatesh.pallipadi@intel.com Committed by Ingo Molnar
Browse files

x86: PAT use reserve free memtype in mmap of /dev/mem 



Use reserve_memtype and free_memtype wrappers for /dev/mem mmaps. The memtype
is slightly complicated here, given that we have to support existing X mappings.
We fallback on UC_MINUS for that.

Signed-off-by: default avatarVenkatesh Pallipadi <venkatesh.pallipadi@intel.com>
Signed-off-by: default avatarSuresh Siddha <suresh.b.siddha@intel.com>
Signed-off-by: default avatarIngo Molnar <mingo@elte.hu>
parent f0970c13

arch/x86/mm/pat.c

+118 −10
Original line number Diff line number Diff line
@@ -11,6 +11,7 @@ 
#include <linux/kernel.h>

#include <linux/gfp.h>

#include <linux/fs.h>

#include <linux/bootmem.h>



#include <asm/msr.h>

#include <asm/tlbflush.h>
@@ -21,6 +22,7 @@ 
#include <asm/cacheflush.h>

#include <asm/fcntl.h>

#include <asm/mtrr.h>

#include <asm/io.h>



int pat_wc_enabled = 1;
@@ -190,6 +192,21 @@ static int pat_x_mtrr_type(u64 start, u64 end, unsigned long prot, 
	return 0;

}



/*

 * req_type typically has one of the:

 * - _PAGE_CACHE_WB

 * - _PAGE_CACHE_WC

 * - _PAGE_CACHE_UC_MINUS

 * - _PAGE_CACHE_UC

 *

 * req_type will have a special case value '-1', when requester want to inherit

 * the memory type from mtrr (if WB), existing PAT, defaulting to UC_MINUS.

 *

 * If ret_type is NULL, function will return an error if it cannot reserve the

 * region with req_type. If ret_type is non-null, function will return

 * available type in ret_type in case of no error. In case of any error

 * it will return a negative return value.

 */

int reserve_memtype(u64 start, u64 end, unsigned long req_type,

			unsigned long *ret_type)

{
@@ -200,9 +217,14 @@ int reserve_memtype(u64 start, u64 end, unsigned long req_type, 


	/* Only track when pat_wc_enabled */

	if (!pat_wc_enabled) {

		if (ret_type)

		/* This is identical to page table setting without PAT */

		if (ret_type) {

			if (req_type == -1) {

				*ret_type = _PAGE_CACHE_WB;

			} else {

				*ret_type = req_type;



			}

		}

		return 0;

	}
@@ -214,8 +236,29 @@ int reserve_memtype(u64 start, u64 end, unsigned long req_type, 
		return 0;

	}



	if (req_type == -1) {

		/*

		 * Special case where caller wants to inherit from mtrr or

		 * existing pat mapping, defaulting to UC_MINUS in case of

		 * no match.

		 */

		u8 mtrr_type = mtrr_type_lookup(start, end);

		if (mtrr_type == 0xFE) { /* MTRR match error */

			err = -1;

		}



		if (mtrr_type == MTRR_TYPE_WRBACK) {

			req_type = _PAGE_CACHE_WB;

			actual_type = _PAGE_CACHE_WB;

		} else {

			req_type = _PAGE_CACHE_UC_MINUS;

			actual_type = _PAGE_CACHE_UC_MINUS;

		}

	} else {

		req_type &= _PAGE_CACHE_MASK;

		err = pat_x_mtrr_type(start, end, req_type, &actual_type);

	}



	if (err) {

		if (ret_type)

			*ret_type = actual_type;
@@ -420,7 +463,14 @@ int free_memtype(u64 start, u64 end) 
}





/* /dev/mem interface. Use the previous mapping */

/*

 * /dev/mem mmap interface. The memtype used for mapping varies:

 * - Use UC for mappings with O_SYNC flag

 * - Without O_SYNC flag, if there is any conflict in reserve_memtype,

 *   inherit the memtype from existing mapping.

 * - Else use UC_MINUS memtype (for backward compatibility with existing

 *   X drivers.

 */

pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,

				unsigned long size, pgprot_t vma_prot)

{
@@ -430,10 +480,13 @@ pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn, 
int phys_mem_access_prot_allowed(struct file *file, unsigned long pfn,

				unsigned long size, pgprot_t *vma_prot)

{

	u64 offset = ((u64) pfn) << PAGE_SHIFT;

	unsigned long flags = _PAGE_CACHE_UC_MINUS;

	unsigned long ret_flags;

	int retval;



	if (file->f_flags & O_SYNC) {

		*vma_prot = pgprot_noncached(*vma_prot);

		return 1;

		flags = _PAGE_CACHE_UC;

	}



#ifdef CONFIG_X86_32
@@ -451,10 +504,65 @@ int phys_mem_access_prot_allowed(struct file *file, unsigned long pfn, 
		test_bit(X86_FEATURE_CYRIX_ARR, boot_cpu_data.x86_capability) ||

		test_bit(X86_FEATURE_CENTAUR_MCR, boot_cpu_data.x86_capability)) &&

	   (pfn << PAGE_SHIFT) >= __pa(high_memory)) {

		*vma_prot = pgprot_noncached(*vma_prot);

		return 1;

		flags = _PAGE_CACHE_UC;

	}

#endif



	/*

	 * With O_SYNC, we can only take UC mapping. Fail if we cannot.

	 * Without O_SYNC, we want to get

	 * - WB for WB-able memory and no other conflicting mappings

	 * - UC_MINUS for non-WB-able memory with no other conflicting mappings

	 * - Inherit from confliting mappings otherwise

	 */

	if (flags != _PAGE_CACHE_UC_MINUS) {

		retval = reserve_memtype(offset, offset + size, flags, NULL);

	} else {

		retval = reserve_memtype(offset, offset + size, -1, &ret_flags);

	}



	if (retval < 0)

		return 0;



	flags = ret_flags;



	if (pfn <= max_pfn_mapped &&

            ioremap_change_attr((unsigned long)__va(offset), size, flags) < 0) {

		free_memtype(offset, offset + size);

		printk(KERN_DEBUG

		"%s:%d /dev/mem ioremap_change_attr failed %s for %Lx-%Lx\n",

			current->comm, current->pid,

			cattr_name(flags),

			offset, offset + size);

		return 0;

	}



	*vma_prot = __pgprot((pgprot_val(*vma_prot) & ~_PAGE_CACHE_MASK) |

			     flags);

	return 1;

}



void map_devmem(unsigned long pfn, unsigned long size, pgprot_t vma_prot)

{

	u64 addr = (u64)pfn << PAGE_SHIFT;

	unsigned long flags;

	unsigned long want_flags = (pgprot_val(vma_prot) & _PAGE_CACHE_MASK);



	reserve_memtype(addr, addr + size, want_flags, &flags);

	if (flags != want_flags) {

		printk(KERN_DEBUG

		"%s:%d /dev/mem expected mapping type %s for %Lx-%Lx, got %s\n",

			current->comm, current->pid,

			cattr_name(want_flags),

			addr, addr + size,

			cattr_name(flags));

	}

}



void unmap_devmem(unsigned long pfn, unsigned long size, pgprot_t vma_prot)

{

	u64 addr = (u64)pfn << PAGE_SHIFT;



	free_memtype(addr, addr + size);

}

drivers/char/mem.c

+34 −1
Original line number Diff line number Diff line
@@ -300,6 +300,35 @@ static inline int private_mapping_ok(struct vm_area_struct *vma) 
}

#endif



void __attribute__((weak))

map_devmem(unsigned long pfn, unsigned long len, pgprot_t prot)

{

	/* nothing. architectures can override. */

}



void __attribute__((weak))

unmap_devmem(unsigned long pfn, unsigned long len, pgprot_t prot)

{

	/* nothing. architectures can override. */

}



static void mmap_mem_open(struct vm_area_struct *vma)

{

	map_devmem(vma->vm_pgoff,  vma->vm_end - vma->vm_start,

			vma->vm_page_prot);

}



static void mmap_mem_close(struct vm_area_struct *vma)

{

	unmap_devmem(vma->vm_pgoff,  vma->vm_end - vma->vm_start,

			vma->vm_page_prot);

}



static struct vm_operations_struct mmap_mem_ops = {

	.open  = mmap_mem_open,

	.close = mmap_mem_close

};



static int mmap_mem(struct file * file, struct vm_area_struct * vma)

{

	size_t size = vma->vm_end - vma->vm_start;
@@ -321,13 +350,17 @@ static int mmap_mem(struct file * file, struct vm_area_struct * vma) 
						 size,

						 vma->vm_page_prot);



	vma->vm_ops = &mmap_mem_ops;



	/* Remap-pfn-range will mark the range VM_IO and VM_RESERVED */

	if (remap_pfn_range(vma,

			    vma->vm_start,

			    vma->vm_pgoff,

			    size,

			    vma->vm_page_prot))

			    vma->vm_page_prot)) {

		unmap_devmem(vma->vm_pgoff, size, vma->vm_page_prot);

		return -EAGAIN;

	}

	return 0;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE