Merge branch 'master'

	page table operations such as what happens during

	fork, and exec.

	Platform developers note that generic code will always

	invoke this interface without mm->page_table_lock held.

3) void flush_tlb_range(struct vm_area_struct *vma,

			unsigned long start, unsigned long end)

	call flush_tlb_page (see below) for each entry which may be

	modified.

	Platform developers note that generic code will always

	invoke this interface with mm->page_table_lock held.

4) void flush_tlb_page(struct vm_area_struct *vma, unsigned long addr)

	This time we need to remove the PAGE_SIZE sized translation

	This is used primarily during fault processing.

	Platform developers note that generic code will always

	invoke this interface with mm->page_table_lock held.

5) void flush_tlb_pgtables(struct mm_struct *mm,

			   unsigned long start, unsigned long end)

	stifb=		[HW]

			Format: bpp:<bpp1>[:<bpp2>[:<bpp3>...]]

	stram_swap=	[HW,M68k]

	swiotlb=	[IA-64] Number of I/O TLB slabs

	switches=	[HW,M68k]

    can be performed in optimal order. Not all SCSI devices support

    tagged queuing (:-().

4.6 switches=

4.5 switches=

-------------

Syntax: switches=<list of switches>

earlier initialization ("ov_"-less) takes precedence. But the

switching-off on reset still happens in this case.

4.5) stram_swap=

----------------

Syntax: stram_swap=<do_swap>[,<max_swap>]

  This option is available only if the kernel has been compiled with

CONFIG_STRAM_SWAP enabled. Normally, the kernel then determines

dynamically whether to actually use ST-RAM as swap space. (Currently,

the fraction of ST-RAM must be less or equal 1/3 of total memory to

enable this swapping.) You can override the kernel's decision by

specifying this option. 1 for <do_swap> means always enable the swap,

even if you have less alternate RAM. 0 stands for never swap to

ST-RAM, even if it's small enough compared to the rest of memory.

  If ST-RAM swapping is enabled, the kernel usually uses all free

ST-RAM as swap "device". If the kernel resides in ST-RAM, the region

allocated by it is obviously never used for swapping :-) You can also

limit this amount by specifying the second parameter, <max_swap>, if

you want to use parts of ST-RAM as normal system memory. <max_swap> is

in kBytes and the number should be a multiple of 4 (otherwise: rounded

down).

5) Options for Amiga Only:

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

	show_free_areas();

	printk("Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));

	for_each_online_node(nid) {

		unsigned long flags;

		pgdat_resize_lock(NODE_DATA(nid), &flags);

		i = node_spanned_pages(nid);

		while (i-- > 0) {

			struct page *page = nid_page_nr(nid, i);

			else

				shared += page_count(page) - 1;

		}

		pgdat_resize_unlock(NODE_DATA(nid), &flags);

	}

	printk("%ld pages of RAM\n",total);

	printk("%ld free pages\n",free);

#include <asm/pgalloc.h>

#include <asm/cacheflush.h>

/* called with the page_table_lock held */

static inline void 

remap_area_pte(pte_t * pte, unsigned long address, unsigned long size, 

	       unsigned long phys_addr, unsigned long flags)

	} while (address && (address < end));

}

/* called with the page_table_lock held */

static inline int 

remap_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size, 

	       unsigned long phys_addr, unsigned long flags)

	if (address >= end)

		BUG();

	do {

		pte_t * pte = pte_alloc_kernel(&init_mm, pmd, address);

		pte_t * pte = pte_alloc_kernel(pmd, address);

		if (!pte)

			return -ENOMEM;

		remap_area_pte(pte, address, end - address, 

	flush_cache_all();

	if (address >= end)

		BUG();

	spin_lock(&init_mm.page_table_lock);

	do {

		pmd_t *pmd;

		pmd = pmd_alloc(&init_mm, dir, address);

		address = (address + PGDIR_SIZE) & PGDIR_MASK;

		dir++;

	} while (address && (address < end));

	spin_unlock(&init_mm.page_table_lock);

	return error;

}