Merge git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-2.6-nommu

FURTHER NOTES ON NO-MMU MMAP

============================

 (*) A request for a private mapping of less than a page in size may not return

     a page-aligned buffer. This is because the kernel calls kmalloc() to

     allocate the buffer, not get_free_page().

 (*) A request for a private mapping of a file may return a buffer that is not

     page-aligned.  This is because XIP may take place, and the data may not be

     paged aligned in the backing store.

 (*) A list of all the mappings on the system is visible through /proc/maps in

     no-MMU mode.

 (*) A request for an anonymous mapping will always be page aligned.  If

     possible the size of the request should be a power of two otherwise some

     of the space may be wasted as the kernel must allocate a power-of-2

     granule but will only discard the excess if appropriately configured as

     this has an effect on fragmentation.

 (*) A list of all the private copy and anonymous mappings on the system is

     visible through /proc/maps in no-MMU mode.

 (*) A list of all the mappings in use by a process is visible through

     /proc/<pid>/maps in no-MMU mode.

Provision of shared mappings on block device files is exactly the same as for

character devices. If there isn't a real device underneath, then the driver

should allocate sufficient contiguous memory to honour any supported mapping.

=================================

ADJUSTING PAGE TRIMMING BEHAVIOUR

=================================

NOMMU mmap automatically rounds up to the nearest power-of-2 number of pages

when performing an allocation.  This can have adverse effects on memory

fragmentation, and as such, is left configurable.  The default behaviour is to

aggressively trim allocations and discard any excess pages back in to the page

allocator.  In order to retain finer-grained control over fragmentation, this

behaviour can either be disabled completely, or bumped up to a higher page

watermark where trimming begins.

Page trimming behaviour is configurable via the sysctl `vm.nr_trim_pages'.

- numa_zonelist_order

- nr_hugepages

- nr_overcommit_hugepages

- nr_trim_pages		(only if CONFIG_MMU=n)

==============================================================

nr_hugepages + nr_overcommit_hugepages.

See Documentation/vm/hugetlbpage.txt

==============================================================

nr_trim_pages

This is available only on NOMMU kernels.

This value adjusts the excess page trimming behaviour of power-of-2 aligned

NOMMU mmap allocations.

A value of 0 disables trimming of allocations entirely, while a value of 1

trims excess pages aggressively. Any value >= 1 acts as the watermark where

trimming of allocations is initiated.

The default value is 1.

See Documentation/nommu-mmap.txt for more information.

 *  modified for 2.6 by Hyok S. Choi <hyok.choi@samsung.com>

 */

typedef struct {

	struct vm_list_struct	*vmlist;

	unsigned long		end_brk;

} mm_context_t;

 * the amount of RAM found at boot time.)  I would imagine that get_vm_area()

 * would have to initialise this each time prior to calling vm_region_alloc().

 */

struct vm_region {

struct arm_vm_region {

	struct list_head	vm_list;

	unsigned long		vm_start;

	unsigned long		vm_end;

	int			vm_active;

};

static struct vm_region consistent_head = {

static struct arm_vm_region consistent_head = {

	.vm_list	= LIST_HEAD_INIT(consistent_head.vm_list),

	.vm_start	= CONSISTENT_BASE,

	.vm_end		= CONSISTENT_END,

};

static struct vm_region *

vm_region_alloc(struct vm_region *head, size_t size, gfp_t gfp)

static struct arm_vm_region *

arm_vm_region_alloc(struct arm_vm_region *head, size_t size, gfp_t gfp)

{

	unsigned long addr = head->vm_start, end = head->vm_end - size;

	unsigned long flags;

	struct vm_region *c, *new;

	struct arm_vm_region *c, *new;

	new = kmalloc(sizeof(struct vm_region), gfp);

	new = kmalloc(sizeof(struct arm_vm_region), gfp);

	if (!new)

		goto out;

	return NULL;

}

static struct vm_region *vm_region_find(struct vm_region *head, unsigned long addr)

static struct arm_vm_region *arm_vm_region_find(struct arm_vm_region *head, unsigned long addr)

{

	struct vm_region *c;

	struct arm_vm_region *c;

	list_for_each_entry(c, &head->vm_list, vm_list) {

		if (c->vm_active && c->vm_start == addr)

	    pgprot_t prot)

{

	struct page *page;

	struct vm_region *c;

	struct arm_vm_region *c;

	unsigned long order;

	u64 mask = ISA_DMA_THRESHOLD, limit;

	/*

	 * Allocate a virtual address in the consistent mapping region.

	 */

	c = vm_region_alloc(&consistent_head, size,

	c = arm_vm_region_alloc(&consistent_head, size,

			    gfp & ~(__GFP_DMA | __GFP_HIGHMEM));

	if (c) {

		pte_t *pte;

		    void *cpu_addr, dma_addr_t dma_addr, size_t size)

{

	unsigned long flags, user_size, kern_size;

	struct vm_region *c;

	struct arm_vm_region *c;

	int ret = -ENXIO;

	user_size = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;

	spin_lock_irqsave(&consistent_lock, flags);

	c = vm_region_find(&consistent_head, (unsigned long)cpu_addr);

	c = arm_vm_region_find(&consistent_head, (unsigned long)cpu_addr);

	spin_unlock_irqrestore(&consistent_lock, flags);

	if (c) {

 */

void dma_free_coherent(struct device *dev, size_t size, void *cpu_addr, dma_addr_t handle)

{

	struct vm_region *c;

	struct arm_vm_region *c;

	unsigned long flags, addr;

	pte_t *ptep;

	int idx;

	size = PAGE_ALIGN(size);

	spin_lock_irqsave(&consistent_lock, flags);

	c = vm_region_find(&consistent_head, (unsigned long)cpu_addr);

	c = arm_vm_region_find(&consistent_head, (unsigned long)cpu_addr);

	if (!c)

		goto no_area;

};

typedef struct {

	struct vm_list_struct *vmlist;

	unsigned long end_brk;

	unsigned long stack_start;