Merge branch 'akpm' (patches from Andrew)

The CMA debugfs interface is useful to retrieve basic information out of the

different CMA areas and to test allocation/release in each of the areas.

Each CMA zone represents a directory under <debugfs>/cma/, indexed by the

kernel's CMA index. So the first CMA zone would be:

	<debugfs>/cma/cma-0

The structure of the files created under that directory is as follows:

 - [RO] base_pfn: The base PFN (Page Frame Number) of the zone.

 - [RO] count: Amount of memory in the CMA area.

 - [RO] order_per_bit: Order of pages represented by one bit.

 - [RO] bitmap: The bitmap of page states in the zone.

 - [WO] alloc: Allocate N pages from that CMA area. For example:

	echo 5 > <debugfs>/cma/cma-2/alloc

would try to allocate 5 pages from the cma-2 area.

 - [WO] free: Free N pages from that CMA area, similar to the above.

			seconds.  Use this parameter to check at some

			other rate.  0 disables periodic checking.

	memtest=	[KNL,X86] Enable memtest

	memtest=	[KNL,X86,ARM] Enable memtest

			Format: <integer>

			default : 0 <disable>

			Specifies the number of memtest passes to be

	nmi_watchdog=	[KNL,BUGS=X86] Debugging features for SMP kernels

			Format: [panic,][nopanic,][num]

			Valid num: 0

			Valid num: 0 or 1

			0 - turn nmi_watchdog off

			1 - turn nmi_watchdog on

			When panic is specified, panic when an NMI watchdog

			timeout occurs (or 'nopanic' to override the opposite

			default).

			register save and restore. The kernel will only save

			legacy floating-point registers on task switch.

	nohugeiomap	[KNL,x86] Disable kernel huge I/O mappings.

	noxsave		[BUGS=X86] Disables x86 extended register state save

			and restore using xsave. The kernel will fallback to

			enabling legacy floating-point and sse state.

	nousb		[USB] Disable the USB subsystem

	nowatchdog	[KNL] Disable the lockup detector (NMI watchdog).

	nowatchdog	[KNL] Disable both lockup detectors, i.e.

                        soft-lockup and NMI watchdog (hard-lockup).

	nowb		[ARM]

- shmmax                      [ sysv ipc ]

- shmmni

- softlockup_all_cpu_backtrace

- soft_watchdog

- stop-a                      [ SPARC only ]

- sysrq                       ==> Documentation/sysrq.txt

- sysctl_writes_strict

- tainted

- threads-max

- unknown_nmi_panic

- watchdog

- watchdog_thresh

- version

nmi_watchdog:

Enables/Disables the NMI watchdog on x86 systems. When the value is

non-zero the NMI watchdog is enabled and will continuously test all

online cpus to determine whether or not they are still functioning

properly. Currently, passing "nmi_watchdog=" parameter at boot time is

required for this function to work.

This parameter can be used to control the NMI watchdog

(i.e. the hard lockup detector) on x86 systems.

If LAPIC NMI watchdog method is in use (nmi_watchdog=2 kernel

parameter), the NMI watchdog shares registers with oprofile. By

disabling the NMI watchdog, oprofile may have more registers to

utilize.

   0 - disable the hard lockup detector

   1 - enable the hard lockup detector

The hard lockup detector monitors each CPU for its ability to respond to

timer interrupts. The mechanism utilizes CPU performance counter registers

that are programmed to generate Non-Maskable Interrupts (NMIs) periodically

while a CPU is busy. Hence, the alternative name 'NMI watchdog'.

The NMI watchdog is disabled by default if the kernel is running as a guest

in a KVM virtual machine. This default can be overridden by adding

   nmi_watchdog=1

to the guest kernel command line (see Documentation/kernel-parameters.txt).

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

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

soft_watchdog

This parameter can be used to control the soft lockup detector.

   0 - disable the soft lockup detector

   1 - enable the soft lockup detector

The soft lockup detector monitors CPUs for threads that are hogging the CPUs

without rescheduling voluntarily, and thus prevent the 'watchdog/N' threads

from running. The mechanism depends on the CPUs ability to respond to timer

interrupts which are needed for the 'watchdog/N' threads to be woken up by

the watchdog timer function, otherwise the NMI watchdog - if enabled - can

detect a hard lockup condition.

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

tainted:

Non-zero if the kernel has been tainted.  Numeric values, which

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

watchdog:

This parameter can be used to disable or enable the soft lockup detector

_and_ the NMI watchdog (i.e. the hard lockup detector) at the same time.

   0 - disable both lockup detectors

   1 - enable both lockup detectors

The soft lockup detector and the NMI watchdog can also be disabled or

enabled individually, using the soft_watchdog and nmi_watchdog parameters.

If the watchdog parameter is read, for example by executing

   cat /proc/sys/kernel/watchdog

the output of this command (0 or 1) shows the logical OR of soft_watchdog

and nmi_watchdog.

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

watchdog_thresh:

This value can be used to control the frequency of hrtimer and NMI

A cleancache "backend" that provides transcendent memory registers itself

to the kernel's cleancache "frontend" by calling cleancache_register_ops,

passing a pointer to a cleancache_ops structure with funcs set appropriately.

Note that cleancache_register_ops returns the previous settings so that

chaining can be performed if desired. The functions provided must conform to

certain semantics as follows:

The functions provided must conform to certain semantics as follows:

Most important, cleancache is "ephemeral".  Pages which are copied into

cleancache have an indefinite lifetime which is completely unknowable

below, mlock_fixup() will attempt to merge the VMA with its neighbors or split

off a subset of the VMA if the range does not cover the entire VMA.  Once the

VMA has been merged or split or neither, mlock_fixup() will call

__mlock_vma_pages_range() to fault in the pages via get_user_pages() and to

populate_vma_page_range() to fault in the pages via get_user_pages() and to

mark the pages as mlocked via mlock_vma_page().

Note that the VMA being mlocked might be mapped with PROT_NONE.  In this case,

Also note that a page returned by get_user_pages() could be truncated or

migrated out from under us, while we're trying to mlock it.  To detect this,

__mlock_vma_pages_range() checks page_mapping() after acquiring the page lock.

populate_vma_page_range() checks page_mapping() after acquiring the page lock.

If the page is still associated with its mapping, we'll go ahead and call

mlock_vma_page().  If the mapping is gone, we just unlock the page and move on.

In the worst case, this will result in a page mapped in a VM_LOCKED VMA

If the VMA is VM_LOCKED, mlock_fixup() again attempts to merge or split off the

specified range.  The range is then munlocked via the function

__mlock_vma_pages_range() - the same function used to mlock a VMA range -

populate_vma_page_range() - the same function used to mlock a VMA range -

passing a flag to indicate that munlock() is being performed.

Because the VMA access protections could have been changed to PROT_NONE after

fetching the pages - all of which should be resident as a result of previous

mlocking.

For munlock(), __mlock_vma_pages_range() unlocks individual pages by calling

For munlock(), populate_vma_page_range() unlocks individual pages by calling

munlock_vma_page().  munlock_vma_page() unconditionally clears the PG_mlocked

flag using TestClearPageMlocked().  As with mlock_vma_page(),

munlock_vma_page() use the Test*PageMlocked() function to handle the case where

To mlock a range of memory under the unevictable/mlock infrastructure, the

mmap() handler and task address space expansion functions call

mlock_vma_pages_range() specifying the vma and the address range to mlock.

mlock_vma_pages_range() filters VMAs like mlock_fixup(), as described above in

"Filtering Special VMAs".  It will clear the VM_LOCKED flag, which will have

already been set by the caller, in filtered VMAs.  Thus these VMA's need not be

visited for munlock when the region is unmapped.

For "normal" VMAs, mlock_vma_pages_range() calls __mlock_vma_pages_range() to

fault/allocate the pages and mlock them.  Again, like mlock_fixup(),

mlock_vma_pages_range() downgrades the mmap semaphore to read mode before

attempting to fault/allocate and mlock the pages and "upgrades" the semaphore

back to write mode before returning.

The callers of mlock_vma_pages_range() will have already added the memory range

populate_vma_page_range() specifying the vma and the address range to mlock.

The callers of populate_vma_page_range() will have already added the memory range

to be mlocked to the task's "locked_vm".  To account for filtered VMAs,

mlock_vma_pages_range() returns the number of pages NOT mlocked.  All of the

populate_vma_page_range() returns the number of pages NOT mlocked.  All of the

callers then subtract a non-negative return value from the task's locked_vm.  A

negative return value represent an error - for example, from get_user_pages()

attempting to fault in a VMA with PROT_NONE access.  In this case, we leave the