38 files changed, 1389 insertions, 351 deletions

diff --git a/Documentation/ABI/testing/sysfs-devices-power b/Documentation/ABI/testing/sysfs-devices-power
new file mode 100644
index 000000000000..6123c523bfd7
--- /dev/null
+++ b/Documentation/ABI/testing/sysfs-devices-power
@@ -0,0 +1,79 @@
+What:           /sys/devices/.../power/
+Date:           January 2009
+Contact:        Rafael J. Wysocki <rjw@sisk.pl>
+Description:
+                The /sys/devices/.../power directory contains attributes
+                allowing the user space to check and modify some power
+                management related properties of given device.
+
+What:           /sys/devices/.../power/wakeup
+Date:           January 2009
+Contact:        Rafael J. Wysocki <rjw@sisk.pl>
+Description:
+                The /sys/devices/.../power/wakeup attribute allows the user
+                space to check if the device is enabled to wake up the system
+                from sleep states, such as the memory sleep state (suspend to
+                RAM) and hibernation (suspend to disk), and to enable or disable
+                it to do that as desired.
+
+                Some devices support "wakeup" events, which are hardware signals
+                used to activate the system from a sleep state.  Such devices
+                have one of the following two values for the sysfs power/wakeup
+                file:
+
+                + "enabled\n" to issue the events;
+                + "disabled\n" not to do so;
+
+                In that cases the user space can change the setting represented
+                by the contents of this file by writing either "enabled", or
+                "disabled" to it.
+
+                For the devices that are not capable of generating system wakeup
+                events this file contains "\n".  In that cases the user space
+                cannot modify the contents of this file and the device cannot be
+                enabled to wake up the system.
+
+What:           /sys/devices/.../power/control
+Date:           January 2009
+Contact:        Rafael J. Wysocki <rjw@sisk.pl>
+Description:
+                The /sys/devices/.../power/control attribute allows the user
+                space to control the run-time power management of the device.
+
+                All devices have one of the following two values for the
+                power/control file:
+
+                + "auto\n" to allow the device to be power managed at run time;
+                + "on\n" to prevent the device from being power managed;
+
+                The default for all devices is "auto", which means that they may
+                be subject to automatic power management, depending on their
+                drivers.  Changing this attribute to "on" prevents the driver
+                from power managing the device at run time.  Doing that while
+                the device is suspended causes it to be woken up.
+
+What:           /sys/devices/.../power/async
+Date:           January 2009
+Contact:        Rafael J. Wysocki <rjw@sisk.pl>
+Description:
+                The /sys/devices/.../async attribute allows the user space to
+                enable or diasble the device's suspend and resume callbacks to
+                be executed asynchronously (ie. in separate threads, in parallel
+                with the main suspend/resume thread) during system-wide power
+                transitions (eg. suspend to RAM, hibernation).
+
+                All devices have one of the following two values for the
+                power/async file:
+
+                + "enabled\n" to permit the asynchronous suspend/resume;
+                + "disabled\n" to forbid it;
+
+                The value of this attribute may be changed by writing either
+                "enabled", or "disabled" to it.
+
+                It generally is unsafe to permit the asynchronous suspend/resume
+                of a device unless it is certain that all of the PM dependencies
+                of the device are known to the PM core.  However, for some
+                devices this attribute is set to "enabled" by bus type code or
+                device drivers and in that cases it should be safe to leave the
+                default value.
diff --git a/Documentation/ABI/testing/sysfs-power b/Documentation/ABI/testing/sysfs-power
index dcff4d0623ad..d6a801f45b48 100644
--- a/Documentation/ABI/testing/sysfs-power
+++ b/Documentation/ABI/testing/sysfs-power
@@ -101,3 +101,16 @@ Description:
 
                 CAUTION: Using it will cause your machine's real-time (CMOS)
                 clock to be set to a random invalid time after a resume.
+
+What:           /sys/power/pm_async
+Date:           January 2009
+Contact:        Rafael J. Wysocki <rjw@sisk.pl>
+Description:
+                The /sys/power/pm_async file controls the switch allowing the
+                user space to enable or disable asynchronous suspend and resume
+                of devices.  If enabled, this feature will cause some device
+                drivers' suspend and resume callbacks to be executed in parallel
+                with each other and with the main suspend thread.  It is enabled
+                if this file contains "1", which is the default.  It may be
+                disabled by writing "0" to this file, in which case all devices
+                will be suspended and resumed synchronously.
diff --git a/Documentation/DocBook/v4l/io.xml b/Documentation/DocBook/v4l/io.xml
index f92f24323b2a..e870330cbf77 100644
--- a/Documentation/DocBook/v4l/io.xml
+++ b/Documentation/DocBook/v4l/io.xml
@@ -589,7 +589,8 @@ number of a video input as in &v4l2-input; field
             <entry></entry>
             <entry>A place holder for future extensions and custom
 (driver defined) buffer types
-<constant>V4L2_BUF_TYPE_PRIVATE</constant> and higher.</entry>
+<constant>V4L2_BUF_TYPE_PRIVATE</constant> and higher. Applications
+should set this to 0.</entry>
           </row>
         </tbody>
       </tgroup>
diff --git a/Documentation/DocBook/v4l/vidioc-qbuf.xml b/Documentation/DocBook/v4l/vidioc-qbuf.xml
index 187081778154..b843bd7b3897 100644
--- a/Documentation/DocBook/v4l/vidioc-qbuf.xml
+++ b/Documentation/DocBook/v4l/vidioc-qbuf.xml
@@ -54,12 +54,10 @@ to enqueue an empty (capturing) or filled (output) buffer in the
 driver's incoming queue. The semantics depend on the selected I/O
 method.</para>
 
-    <para>To enqueue a <link linkend="mmap">memory mapped</link>
-buffer applications set the <structfield>type</structfield> field of a
-&v4l2-buffer; to the same buffer type as previously &v4l2-format;
-<structfield>type</structfield> and &v4l2-requestbuffers;
-<structfield>type</structfield>, the <structfield>memory</structfield>
-field to <constant>V4L2_MEMORY_MMAP</constant> and the
+    <para>To enqueue a buffer applications set the <structfield>type</structfield>
+field of a &v4l2-buffer; to the same buffer type as was previously used
+with &v4l2-format; <structfield>type</structfield> and &v4l2-requestbuffers;
+<structfield>type</structfield>. Applications must also set the
 <structfield>index</structfield> field. Valid index numbers range from
 zero to the number of buffers allocated with &VIDIOC-REQBUFS;
 (&v4l2-requestbuffers; <structfield>count</structfield>) minus one. The
@@ -70,8 +68,19 @@ intended for output (<structfield>type</structfield> is
 <constant>V4L2_BUF_TYPE_VBI_OUTPUT</constant>) applications must also
 initialize the <structfield>bytesused</structfield>,
 <structfield>field</structfield> and
-<structfield>timestamp</structfield> fields. See <xref
-        linkend="buffer" /> for details. When
+<structfield>timestamp</structfield> fields, see <xref
+linkend="buffer" /> for details.
+Applications must also set <structfield>flags</structfield> to 0. If a driver
+supports capturing from specific video inputs and you want to specify a video
+input, then <structfield>flags</structfield> should be set to
+<constant>V4L2_BUF_FLAG_INPUT</constant> and the field
+<structfield>input</structfield> must be initialized to the desired input.
+The <structfield>reserved</structfield> field must be set to 0.
+</para>
+
+    <para>To enqueue a <link linkend="mmap">memory mapped</link>
+buffer applications set the <structfield>memory</structfield>
+field to <constant>V4L2_MEMORY_MMAP</constant>. When
 <constant>VIDIOC_QBUF</constant> is called with a pointer to this
 structure the driver sets the
 <constant>V4L2_BUF_FLAG_MAPPED</constant> and
@@ -81,14 +90,10 @@ structure the driver sets the
 &EINVAL;.</para>
 
     <para>To enqueue a <link linkend="userp">user pointer</link>
-buffer applications set the <structfield>type</structfield> field of a
-&v4l2-buffer; to the same buffer type as previously &v4l2-format;
-<structfield>type</structfield> and &v4l2-requestbuffers;
-<structfield>type</structfield>, the <structfield>memory</structfield>
-field to <constant>V4L2_MEMORY_USERPTR</constant> and the
+buffer applications set the <structfield>memory</structfield>
+field to <constant>V4L2_MEMORY_USERPTR</constant>, the
 <structfield>m.userptr</structfield> field to the address of the
-buffer and <structfield>length</structfield> to its size. When the
-buffer is intended for output additional fields must be set as above.
+buffer and <structfield>length</structfield> to its size.
 When <constant>VIDIOC_QBUF</constant> is called with a pointer to this
 structure the driver sets the <constant>V4L2_BUF_FLAG_QUEUED</constant>
 flag and clears the <constant>V4L2_BUF_FLAG_MAPPED</constant> and
@@ -96,13 +101,14 @@ flag and clears the <constant>V4L2_BUF_FLAG_MAPPED</constant> and
 <structfield>flags</structfield> field, or it returns an error code.
 This ioctl locks the memory pages of the buffer in physical memory,
 they cannot be swapped out to disk. Buffers remain locked until
-dequeued, until the &VIDIOC-STREAMOFF; or &VIDIOC-REQBUFS; ioctl are
+dequeued, until the &VIDIOC-STREAMOFF; or &VIDIOC-REQBUFS; ioctl is
 called, or until the device is closed.</para>
 
     <para>Applications call the <constant>VIDIOC_DQBUF</constant>
 ioctl to dequeue a filled (capturing) or displayed (output) buffer
 from the driver's outgoing queue. They just set the
-<structfield>type</structfield> and <structfield>memory</structfield>
+<structfield>type</structfield>, <structfield>memory</structfield>
+and <structfield>reserved</structfield>
 fields of a &v4l2-buffer; as above, when <constant>VIDIOC_DQBUF</constant>
 is called with a pointer to this structure the driver fills the
 remaining fields or returns an error code.</para>
diff --git a/Documentation/DocBook/v4l/vidioc-querybuf.xml b/Documentation/DocBook/v4l/vidioc-querybuf.xml
index d834993e6191..e649805a4908 100644
--- a/Documentation/DocBook/v4l/vidioc-querybuf.xml
+++ b/Documentation/DocBook/v4l/vidioc-querybuf.xml
@@ -54,12 +54,13 @@ buffer at any time after buffers have been allocated with the
 &VIDIOC-REQBUFS; ioctl.</para>
 
     <para>Applications set the <structfield>type</structfield> field
-    of a &v4l2-buffer; to the same buffer type as previously
+    of a &v4l2-buffer; to the same buffer type as was previously used with
 &v4l2-format; <structfield>type</structfield> and &v4l2-requestbuffers;
 <structfield>type</structfield>, and the <structfield>index</structfield>
     field. Valid index numbers range from zero
 to the number of buffers allocated with &VIDIOC-REQBUFS;
     (&v4l2-requestbuffers; <structfield>count</structfield>) minus one.
+The <structfield>reserved</structfield> field should to set to 0.
 After calling <constant>VIDIOC_QUERYBUF</constant> with a pointer to
     this structure drivers return an error code or fill the rest of
 the structure.</para>
@@ -68,8 +69,8 @@ the structure.</para>
 <constant>V4L2_BUF_FLAG_MAPPED</constant>,
 <constant>V4L2_BUF_FLAG_QUEUED</constant> and
 <constant>V4L2_BUF_FLAG_DONE</constant> flags will be valid. The
-<structfield>memory</structfield> field will be set to
-<constant>V4L2_MEMORY_MMAP</constant>, the <structfield>m.offset</structfield>
+<structfield>memory</structfield> field will be set to the current
+I/O method, the <structfield>m.offset</structfield>
 contains the offset of the buffer from the start of the device memory,
 the <structfield>length</structfield> field its size. The driver may
 or may not set the remaining fields and flags, they are meaningless in
diff --git a/Documentation/DocBook/v4l/vidioc-reqbufs.xml b/Documentation/DocBook/v4l/vidioc-reqbufs.xml
index bab38084454f..1c0816372074 100644
--- a/Documentation/DocBook/v4l/vidioc-reqbufs.xml
+++ b/Documentation/DocBook/v4l/vidioc-reqbufs.xml
@@ -54,23 +54,23 @@ I/O. Memory mapped buffers are located in device memory and must be
 allocated with this ioctl before they can be mapped into the
 application's address space. User buffers are allocated by
 applications themselves, and this ioctl is merely used to switch the
-driver into user pointer I/O mode.</para>
+driver into user pointer I/O mode and to setup some internal structures.</para>
 
-    <para>To allocate device buffers applications initialize three
-fields of a <structname>v4l2_requestbuffers</structname> structure.
+    <para>To allocate device buffers applications initialize all
+fields of the <structname>v4l2_requestbuffers</structname> structure.
 They set the <structfield>type</structfield> field to the respective
 stream or buffer type, the <structfield>count</structfield> field to
-the desired number of buffers, and <structfield>memory</structfield>
-must be set to <constant>V4L2_MEMORY_MMAP</constant>. When the ioctl
-is called with a pointer to this structure the driver attempts to
-allocate the requested number of buffers and stores the actual number
+the desired number of buffers, <structfield>memory</structfield>
+must be set to the requested I/O method and the reserved array
+must be zeroed. When the ioctl
+is called with a pointer to this structure the driver will attempt to allocate
+the requested number of buffers and it stores the actual number
 allocated in the <structfield>count</structfield> field. It can be
 smaller than the number requested, even zero, when the driver runs out
-of free memory. A larger number is possible when the driver requires
-more buffers to function correctly.<footnote>
-        <para>For example video output requires at least two buffers,
+of free memory. A larger number is also possible when the driver requires
+more buffers to function correctly. For example video output requires at least two buffers,
 one displayed and one filled by the application.</para>
-        </footnote> When memory mapping I/O is not supported the ioctl
+    <para>When the I/O method is not supported the ioctl
 returns an &EINVAL;.</para>
 
     <para>Applications can call <constant>VIDIOC_REQBUFS</constant>
@@ -81,14 +81,6 @@ in progress, an implicit &VIDIOC-STREAMOFF;. <!-- mhs: I see no
 reason why munmap()ping one or even all buffers must imply
 streamoff.--></para>
 
-    <para>To negotiate user pointer I/O, applications initialize only
-the <structfield>type</structfield> field and set
-<structfield>memory</structfield> to
-<constant>V4L2_MEMORY_USERPTR</constant>. When the ioctl is called
-with a pointer to this structure the driver prepares for user pointer
-I/O, when this I/O method is not supported the ioctl returns an
-&EINVAL;.</para>
-
     <table pgwide="1" frame="none" id="v4l2-requestbuffers">
       <title>struct <structname>v4l2_requestbuffers</structname></title>
       <tgroup cols="3">
@@ -97,9 +89,7 @@ I/O, when this I/O method is not supported the ioctl returns an
           <row>
             <entry>__u32</entry>
             <entry><structfield>count</structfield></entry>
-            <entry>The number of buffers requested or granted. This
-field is only used when <structfield>memory</structfield> is set to
-<constant>V4L2_MEMORY_MMAP</constant>.</entry>
+            <entry>The number of buffers requested or granted.</entry>
           </row>
           <row>
             <entry>&v4l2-buf-type;</entry>
@@ -120,7 +110,7 @@ as the &v4l2-format; <structfield>type</structfield> field. See <xref
             <entry><structfield>reserved</structfield>[2]</entry>
             <entry>A place holder for future extensions and custom
 (driver defined) buffer types <constant>V4L2_BUF_TYPE_PRIVATE</constant> and
-higher.</entry>
+higher. This array should be zeroed by applications.</entry>
           </row>
         </tbody>
       </tgroup>
diff --git a/Documentation/RCU/00-INDEX b/Documentation/RCU/00-INDEX
index 9bb62f7b89c3..71b6f500ddb9 100644
--- a/Documentation/RCU/00-INDEX
+++ b/Documentation/RCU/00-INDEX
@@ -6,16 +6,22 @@ checklist.txt
         - Review Checklist for RCU Patches
 listRCU.txt
         - Using RCU to Protect Read-Mostly Linked Lists
+lockdep.txt
+        - RCU and lockdep checking
 NMI-RCU.txt
         - Using RCU to Protect Dynamic NMI Handlers
+rcubarrier.txt
+        - RCU and Unloadable Modules
+rculist_nulls.txt
+        - RCU list primitives for use with SLAB_DESTROY_BY_RCU
 rcuref.txt
         - Reference-count design for elements of lists/arrays protected by RCU
 rcu.txt
         - RCU Concepts
-rcubarrier.txt
-        - Unloading modules that use RCU callbacks
 RTFP.txt
         - List of RCU papers (bibliography) going back to 1980.
+stallwarn.txt
+        - RCU CPU stall warnings (CONFIG_RCU_CPU_STALL_DETECTOR)
 torture.txt
         - RCU Torture Test Operation (CONFIG_RCU_TORTURE_TEST)
 trace.txt
diff --git a/Documentation/RCU/RTFP.txt b/Documentation/RCU/RTFP.txt
index d2b85237c76e..5aea459e3dd6 100644
--- a/Documentation/RCU/RTFP.txt
+++ b/Documentation/RCU/RTFP.txt
@@ -25,10 +25,10 @@ to be referencing the data structure.  However, this mechanism was not
 optimized for modern computer systems, which is not surprising given
 that these overheads were not so expensive in the mid-80s.  Nonetheless,
 passive serialization appears to be the first deferred-destruction
-mechanism to be used in production.  Furthermore, the relevant patent has
-lapsed, so this approach may be used in non-GPL software, if desired.
-(In contrast, use of RCU is permitted only in software licensed under
-GPL.  Sorry!!!)
+mechanism to be used in production.  Furthermore, the relevant patent
+has lapsed, so this approach may be used in non-GPL software, if desired.
+(In contrast, implementation of RCU is permitted only in software licensed
+under either GPL or LGPL.  Sorry!!!)
 
 In 1990, Pugh [Pugh90] noted that explicitly tracking which threads
 were reading a given data structure permitted deferred free to operate
@@ -150,6 +150,18 @@ preemptible RCU [PaulEMcKenney2007PreemptibleRCU], and the three-part
 LWN "What is RCU?" series [PaulEMcKenney2007WhatIsRCUFundamentally,
 PaulEMcKenney2008WhatIsRCUUsage, and PaulEMcKenney2008WhatIsRCUAPI].
 
+2008 saw a journal paper on real-time RCU [DinakarGuniguntala2008IBMSysJ],
+a history of how Linux changed RCU more than RCU changed Linux
+[PaulEMcKenney2008RCUOSR], and a design overview of hierarchical RCU
+[PaulEMcKenney2008HierarchicalRCU].
+
+2009 introduced user-level RCU algorithms [PaulEMcKenney2009MaliciousURCU],
+which Mathieu Desnoyers is now maintaining [MathieuDesnoyers2009URCU]
+[MathieuDesnoyersPhD].  TINY_RCU [PaulEMcKenney2009BloatWatchRCU] made
+its appearance, as did expedited RCU [PaulEMcKenney2009expeditedRCU].
+The problem of resizeable RCU-protected hash tables may now be on a path
+to a solution [JoshTriplett2009RPHash].
+
 Bibtex Entries
 
 @article{Kung80
@@ -730,6 +742,11 @@ Revised:
 "
 }
 
+#
+#       "What is RCU?" LWN series.
+#
+########################################################################
+
 @article{DinakarGuniguntala2008IBMSysJ
 ,author="D. Guniguntala and P. E. McKenney and J. Triplett and J. Walpole"
 ,title="The read-copy-update mechanism for supporting real-time applications on shared-memory multiprocessor systems with {Linux}"
@@ -820,3 +837,39 @@ Revised:
         Uniprocessor assumptions allow simplified RCU implementation.
 "
 }
+
+@unpublished{PaulEMcKenney2009expeditedRCU
+,Author="Paul E. McKenney"
+,Title="[{PATCH} -tip 0/3] expedited 'big hammer' {RCU} grace periods"
+,month="June"
+,day="25"
+,year="2009"
+,note="Available:
+\url{http://lkml.org/lkml/2009/6/25/306}
+[Viewed August 16, 2009]"
+,annotation="
+        First posting of expedited RCU to be accepted into -tip.
+"
+}
+
+@unpublished{JoshTriplett2009RPHash
+,Author="Josh Triplett"
+,Title="Scalable concurrent hash tables via relativistic programming"
+,month="September"
+,year="2009"
+,note="Linux Plumbers Conference presentation"
+,annotation="
+        RP fun with hash tables.
+"
+}
+
+@phdthesis{MathieuDesnoyersPhD
+, title  = "Low-Impact Operating System Tracing"
+, author = "Mathieu Desnoyers"
+, school = "Ecole Polytechnique de Montr\'{e}al"
+, month  = "December"
+, year   = 2009
+,note="Available:
+\url{http://www.lttng.org/pub/thesis/desnoyers-dissertation-2009-12.pdf}
+[Viewed December 9, 2009]"
+}
diff --git a/Documentation/RCU/checklist.txt b/Documentation/RCU/checklist.txt
index 51525a30e8b4..cbc180f90194 100644
--- a/Documentation/RCU/checklist.txt
+++ b/Documentation/RCU/checklist.txt
@@ -8,13 +8,12 @@ would cause.  This list is based on experiences reviewing such patches
 over a rather long period of time, but improvements are always welcome!
 
 0.      Is RCU being applied to a read-mostly situation?  If the data
-        structure is updated more than about 10% of the time, then
-        you should strongly consider some other approach, unless
-        detailed performance measurements show that RCU is nonetheless
-        the right tool for the job.  Yes, you might think of RCU
-        as simply cutting overhead off of the readers and imposing it
-        on the writers.  That is exactly why normal uses of RCU will
-        do much more reading than updating.
+        structure is updated more than about 10% of the time, then you
+        should strongly consider some other approach, unless detailed
+        performance measurements show that RCU is nonetheless the right
+        tool for the job.  Yes, RCU does reduce read-side overhead by
+        increasing write-side overhead, which is exactly why normal uses
+        of RCU will do much more reading than updating.
 
         Another exception is where performance is not an issue, and RCU
         provides a simpler implementation.  An example of this situation
@@ -35,13 +34,13 @@ over a rather long period of time, but improvements are always welcome!
 
         If you choose #b, be prepared to describe how you have handled
         memory barriers on weakly ordered machines (pretty much all of
-        them -- even x86 allows reads to be reordered), and be prepared
-        to explain why this added complexity is worthwhile.  If you
-        choose #c, be prepared to explain how this single task does not
-        become a major bottleneck on big multiprocessor machines (for
-        example, if the task is updating information relating to itself
-        that other tasks can read, there by definition can be no
-        bottleneck).
+        them -- even x86 allows later loads to be reordered to precede
+        earlier stores), and be prepared to explain why this added
+        complexity is worthwhile.  If you choose #c, be prepared to
+        explain how this single task does not become a major bottleneck on
+        big multiprocessor machines (for example, if the task is updating
+        information relating to itself that other tasks can read, there
+        by definition can be no bottleneck).
 
 2.      Do the RCU read-side critical sections make proper use of
         rcu_read_lock() and friends?  These primitives are needed
@@ -51,8 +50,10 @@ over a rather long period of time, but improvements are always welcome!
         actuarial risk of your kernel.
 
         As a rough rule of thumb, any dereference of an RCU-protected
-        pointer must be covered by rcu_read_lock() or rcu_read_lock_bh()
-        or by the appropriate update-side lock.
+        pointer must be covered by rcu_read_lock(), rcu_read_lock_bh(),
+        rcu_read_lock_sched(), or by the appropriate update-side lock.
+        Disabling of preemption can serve as rcu_read_lock_sched(), but
+        is less readable.
 
 3.      Does the update code tolerate concurrent accesses?
 
@@ -62,25 +63,27 @@ over a rather long period of time, but improvements are always welcome!
         of ways to handle this concurrency, depending on the situation:
 
         a.      Use the RCU variants of the list and hlist update
-                primitives to add, remove, and replace elements on an
-                RCU-protected list.  Alternatively, use the RCU-protected
-                trees that have been added to the Linux kernel.
+                primitives to add, remove, and replace elements on
+                an RCU-protected list.  Alternatively, use the other
+                RCU-protected data structures that have been added to
+                the Linux kernel.
 
                 This is almost always the best approach.
 
         b.      Proceed as in (a) above, but also maintain per-element
                 locks (that are acquired by both readers and writers)
                 that guard per-element state.  Of course, fields that
-                the readers refrain from accessing can be guarded by the
-                update-side lock.
+                the readers refrain from accessing can be guarded by
+                some other lock acquired only by updaters, if desired.
 
                 This works quite well, also.
 
         c.      Make updates appear atomic to readers.  For example,
-                pointer updates to properly aligned fields will appear
-                atomic, as will individual atomic primitives.  Operations
-                performed under a lock and sequences of multiple atomic
-                primitives will -not- appear to be atomic.
+                pointer updates to properly aligned fields will
+                appear atomic, as will individual atomic primitives.
+                Sequences of perations performed under a lock will -not-
+                appear to be atomic to RCU readers, nor will sequences
+                of multiple atomic primitives.
 
                 This can work, but is starting to get a bit tricky.
 
@@ -98,9 +101,9 @@ over a rather long period of time, but improvements are always welcome!
                 a new structure containing updated values.
 
 4.      Weakly ordered CPUs pose special challenges.  Almost all CPUs
-        are weakly ordered -- even i386 CPUs allow reads to be reordered.
-        RCU code must take all of the following measures to prevent
-        memory-corruption problems:
+        are weakly ordered -- even x86 CPUs allow later loads to be
+        reordered to precede earlier stores.  RCU code must take all of
+        the following measures to prevent memory-corruption problems:
 
         a.      Readers must maintain proper ordering of their memory
                 accesses.  The rcu_dereference() primitive ensures that
@@ -113,14 +116,25 @@ over a rather long period of time, but improvements are always welcome!
                 The rcu_dereference() primitive is also an excellent
                 documentation aid, letting the person reading the code
                 know exactly which pointers are protected by RCU.
-
-                The rcu_dereference() primitive is used by the various
-                "_rcu()" list-traversal primitives, such as the
-                list_for_each_entry_rcu().  Note that it is perfectly
-                legal (if redundant) for update-side code to use
-                rcu_dereference() and the "_rcu()" list-traversal
-                primitives.  This is particularly useful in code
-                that is common to readers and updaters.
+                Please note that compilers can also reorder code, and
+                they are becoming increasingly aggressive about doing
+                just that.  The rcu_dereference() primitive therefore
+                also prevents destructive compiler optimizations.
+
+                The rcu_dereference() primitive is used by the
+                various "_rcu()" list-traversal primitives, such
+                as the list_for_each_entry_rcu().  Note that it is
+                perfectly legal (if redundant) for update-side code to
+                use rcu_dereference() and the "_rcu()" list-traversal
+                primitives.  This is particularly useful in code that
+                is common to readers and updaters.  However, lockdep
+                will complain if you access rcu_dereference() outside
+                of an RCU read-side critical section.  See lockdep.txt
+                to learn what to do about this.
+
+                Of course, neither rcu_dereference() nor the "_rcu()"
+                list-traversal primitives can substitute for a good
+                concurrency design coordinating among multiple updaters.
 
         b.      If the list macros are being used, the list_add_tail_rcu()
                 and list_add_rcu() primitives must be used in order
@@ -135,11 +149,14 @@ over a rather long period of time, but improvements are always welcome!
                 readers.  Similarly, if the hlist macros are being used,
                 the hlist_del_rcu() primitive is required.
 
-                The list_replace_rcu() primitive may be used to
-                replace an old structure with a new one in an
-                RCU-protected list.
+                The list_replace_rcu() and hlist_replace_rcu() primitives
+                may be used to replace an old structure with a new one
+                in their respective types of RCU-protected lists.
+
+        d.      Rules similar to (4b) and (4c) apply to the "hlist_nulls"
+                type of RCU-protected linked lists.
 
-        d.      Updates must ensure that initialization of a given
+        e.      Updates must ensure that initialization of a given
                 structure happens before pointers to that structure are
                 publicized.  Use the rcu_assign_pointer() primitive
                 when publicizing a pointer to a structure that can
@@ -151,16 +168,31 @@ over a rather long period of time, but improvements are always welcome!
         it cannot block.
 
 6.      Since synchronize_rcu() can block, it cannot be called from
-        any sort of irq context.  Ditto for synchronize_sched() and
-        synchronize_srcu().
-
-7.      If the updater uses call_rcu(), then the corresponding readers
-        must use rcu_read_lock() and rcu_read_unlock().  If the updater
-        uses call_rcu_bh(), then the corresponding readers must use
-        rcu_read_lock_bh() and rcu_read_unlock_bh().  If the updater
-        uses call_rcu_sched(), then the corresponding readers must
-        disable preemption.  Mixing things up will result in confusion
-        and broken kernels.
+        any sort of irq context.  The same rule applies for
+        synchronize_rcu_bh(), synchronize_sched(), synchronize_srcu(),
+        synchronize_rcu_expedited(), synchronize_rcu_bh_expedited(),
+        synchronize_sched_expedite(), and synchronize_srcu_expedited().
+
+        The expedited forms of these primitives have the same semantics
+        as the non-expedited forms, but expediting is both expensive
+        and unfriendly to real-time workloads.  Use of the expedited
+        primitives should be restricted to rare configuration-change
+        operations that would not normally be undertaken while a real-time
+        workload is running.
+
+7.      If the updater uses call_rcu() or synchronize_rcu(), then the
+        corresponding readers must use rcu_read_lock() and
+        rcu_read_unlock().  If the updater uses call_rcu_bh() or
+        synchronize_rcu_bh(), then the corresponding readers must
+        use rcu_read_lock_bh() and rcu_read_unlock_bh().  If the
+        updater uses call_rcu_sched() or synchronize_sched(), then
+        the corresponding readers must disable preemption, possibly
+        by calling rcu_read_lock_sched() and rcu_read_unlock_sched().
+        If the updater uses synchronize_srcu(), the the corresponding
+        readers must use srcu_read_lock() and srcu_read_unlock(),
+        and with the same srcu_struct.  The rules for the expedited
+        primitives are the same as for their non-expedited counterparts.
+        Mixing things up will result in confusion and broken kernels.
 
         One exception to this rule: rcu_read_lock() and rcu_read_unlock()
         may be substituted for rcu_read_lock_bh() and rcu_read_unlock_bh()
@@ -212,6 +244,8 @@ over a rather long period of time, but improvements are always welcome!
         e.      Periodically invoke synchronize_rcu(), permitting a limited
                 number of updates per grace period.
 
+        The same cautions apply to call_rcu_bh() and call_rcu_sched().
+
 9.      All RCU list-traversal primitives, which include
         rcu_dereference(), list_for_each_entry_rcu(),
         list_for_each_continue_rcu(), and list_for_each_safe_rcu(),
@@ -219,7 +253,9 @@ over a rather long period of time, but improvements are always welcome!
         must be protected by appropriate update-side locks.  RCU
         read-side critical sections are delimited by rcu_read_lock()
         and rcu_read_unlock(), or by similar primitives such as
-        rcu_read_lock_bh() and rcu_read_unlock_bh().
+        rcu_read_lock_bh() and rcu_read_unlock_bh(), in which case
+        the matching rcu_dereference() primitive must be used in order
+        to keep lockdep happy, in this case, rcu_dereference_bh().
 
         The reason that it is permissible to use RCU list-traversal
         primitives when the update-side lock is held is that doing so
@@ -229,7 +265,8 @@ over a rather long period of time, but improvements are always welcome!
 10.     Conversely, if you are in an RCU read-side critical section,
         and you don't hold the appropriate update-side lock, you -must-
         use the "_rcu()" variants of the list macros.  Failing to do so
-        will break Alpha and confuse people reading your code.
+        will break Alpha, cause aggressive compilers to generate bad code,
+        and confuse people trying to read your code.
 
 11.     Note that synchronize_rcu() -only- guarantees to wait until
         all currently executing rcu_read_lock()-protected RCU read-side
@@ -239,15 +276,21 @@ over a rather long period of time, but improvements are always welcome!
         rcu_read_lock()-protected read-side critical sections, do -not-
         use synchronize_rcu().
 
-        If you want to wait for some of these other things, you might
-        instead need to use synchronize_irq() or synchronize_sched().
+        Similarly, disabling preemption is not an acceptable substitute
+        for rcu_read_lock().  Code that attempts to use preemption
+        disabling where it should be using rcu_read_lock() will break
+        in real-time kernel builds.
+
+        If you want to wait for interrupt handlers, NMI handlers, and
+        code under the influence of preempt_disable(), you instead
+        need to use synchronize_irq() or synchronize_sched().
 
 12.     Any lock acquired by an RCU callback must be acquired elsewhere
         with softirq disabled, e.g., via spin_lock_irqsave(),
         spin_lock_bh(), etc.  Failing to disable irq on a given
-        acquisition of that lock will result in deadlock as soon as the
-        RCU callback happens to interrupt that acquisition's critical
-        section.
+        acquisition of that lock will result in deadlock as soon as
+        the RCU softirq handler happens to run your RCU callback while
+        interrupting that acquisition's critical section.
 
 13.     RCU callbacks can be and are executed in parallel.  In many cases,
         the callback code simply wrappers around kfree(), so that this
@@ -265,29 +308,30 @@ over a rather long period of time, but improvements are always welcome!
         not the case, a self-spawning RCU callback would prevent the
         victim CPU from ever going offline.)
 
-14.     SRCU (srcu_read_lock(), srcu_read_unlock(), and synchronize_srcu())
-        may only be invoked from process context.  Unlike other forms of
-        RCU, it -is- permissible to block in an SRCU read-side critical
-        section (demarked by srcu_read_lock() and srcu_read_unlock()),
-        hence the "SRCU": "sleepable RCU".  Please note that if you
-        don't need to sleep in read-side critical sections, you should
-        be using RCU rather than SRCU, because RCU is almost always
-        faster and easier to use than is SRCU.
+14.     SRCU (srcu_read_lock(), srcu_read_unlock(), srcu_dereference(),
+        synchronize_srcu(), and synchronize_srcu_expedited()) may only
+        be invoked from process context.  Unlike other forms of RCU, it
+        -is- permissible to block in an SRCU read-side critical section
+        (demarked by srcu_read_lock() and srcu_read_unlock()), hence the
+        "SRCU": "sleepable RCU".  Please note that if you don't need
+        to sleep in read-side critical sections, you should be using
+        RCU rather than SRCU, because RCU is almost always faster and
+        easier to use than is SRCU.
 
         Also unlike other forms of RCU, explicit initialization
         and cleanup is required via init_srcu_struct() and
         cleanup_srcu_struct().  These are passed a "struct srcu_struct"
         that defines the scope of a given SRCU domain.  Once initialized,
         the srcu_struct is passed to srcu_read_lock(), srcu_read_unlock()
-        and synchronize_srcu().  A given synchronize_srcu() waits only
-        for SRCU read-side critical sections governed by srcu_read_lock()
-        and srcu_read_unlock() calls that have been passd the same
-        srcu_struct.  This property is what makes sleeping read-side
-        critical sections tolerable -- a given subsystem delays only
-        its own updates, not those of other subsystems using SRCU.
-        Therefore, SRCU is less prone to OOM the system than RCU would
-        be if RCU's read-side critical sections were permitted to
-        sleep.
+        synchronize_srcu(), and synchronize_srcu_expedited().  A given
+        synchronize_srcu() waits only for SRCU read-side critical
+        sections governed by srcu_read_lock() and srcu_read_unlock()
+        calls that have been passed the same srcu_struct.  This property
+        is what makes sleeping read-side critical sections tolerable --
+        a given subsystem delays only its own updates, not those of other
+        subsystems using SRCU.  Therefore, SRCU is less prone to OOM the
+        system than RCU would be if RCU's read-side critical sections
+        were permitted to sleep.
 
         The ability to sleep in read-side critical sections does not
         come for free.  First, corresponding srcu_read_lock() and
@@ -311,12 +355,12 @@ over a rather long period of time, but improvements are always welcome!
         destructive operation, and -only- -then- invoke call_rcu(),
         synchronize_rcu(), or friends.
 
-        Because these primitives only wait for pre-existing readers,
-        it is the caller's responsibility to guarantee safety to
-        any subsequent readers.
+        Because these primitives only wait for pre-existing readers, it
+        is the caller's responsibility to guarantee that any subsequent
+        readers will execute safely.
 
-16.     The various RCU read-side primitives do -not- contain memory
-        barriers.  The CPU (and in some cases, the compiler) is free
-        to reorder code into and out of RCU read-side critical sections.
-        It is the responsibility of the RCU update-side primitives to
-        deal with this.
+16.     The various RCU read-side primitives do -not- necessarily contain
+        memory barriers.  You should therefore plan for the CPU
+        and the compiler to freely reorder code into and out of RCU
+        read-side critical sections.  It is the responsibility of the
+        RCU update-side primitives to deal with this.
diff --git a/Documentation/RCU/lockdep.txt b/Documentation/RCU/lockdep.txt
new file mode 100644
index 000000000000..fe24b58627bd
--- /dev/null
+++ b/Documentation/RCU/lockdep.txt
@@ -0,0 +1,67 @@
+RCU and lockdep checking
+
+All flavors of RCU have lockdep checking available, so that lockdep is
+aware of when each task enters and leaves any flavor of RCU read-side
+critical section.  Each flavor of RCU is tracked separately (but note
+that this is not the case in 2.6.32 and earlier).  This allows lockdep's
+tracking to include RCU state, which can sometimes help when debugging
+deadlocks and the like.
+
+In addition, RCU provides the following primitives that check lockdep's
+state:
+
+        rcu_read_lock_held() for normal RCU.
+        rcu_read_lock_bh_held() for RCU-bh.
+        rcu_read_lock_sched_held() for RCU-sched.
+        srcu_read_lock_held() for SRCU.
+
+These functions are conservative, and will therefore return 1 if they
+aren't certain (for example, if CONFIG_DEBUG_LOCK_ALLOC is not set).
+This prevents things like WARN_ON(!rcu_read_lock_held()) from giving false
+positives when lockdep is disabled.
+
+In addition, a separate kernel config parameter CONFIG_PROVE_RCU enables
+checking of rcu_dereference() primitives:
+
+        rcu_dereference(p):
+                Check for RCU read-side critical section.
+        rcu_dereference_bh(p):
+                Check for RCU-bh read-side critical section.
+        rcu_dereference_sched(p):
+                Check for RCU-sched read-side critical section.
+        srcu_dereference(p, sp):
+                Check for SRCU read-side critical section.
+        rcu_dereference_check(p, c):
+                Use explicit check expression "c".
+        rcu_dereference_raw(p)
+                Don't check.  (Use sparingly, if at all.)
+
+The rcu_dereference_check() check expression can be any boolean
+expression, but would normally include one of the rcu_read_lock_held()
+family of functions and a lockdep expression.  However, any boolean
+expression can be used.  For a moderately ornate example, consider
+the following:
+
+        file = rcu_dereference_check(fdt->fd[fd],
+                                     rcu_read_lock_held() ||
+                                     lockdep_is_held(&files->file_lock) ||
+                                     atomic_read(&files->count) == 1);
+
+This expression picks up the pointer "fdt->fd[fd]" in an RCU-safe manner,
+and, if CONFIG_PROVE_RCU is configured, verifies that this expression
+is used in:
+
+1.      An RCU read-side critical section, or
+2.      with files->file_lock held, or
+3.      on an unshared files_struct.
+
+In case (1), the pointer is picked up in an RCU-safe manner for vanilla
+RCU read-side critical sections, in case (2) the ->file_lock prevents
+any change from taking place, and finally, in case (3) the current task
+is the only task accessing the file_struct, again preventing any change
+from taking place.
+
+There are currently only "universal" versions of the rcu_assign_pointer()
+and RCU list-/tree-traversal primitives, which do not (yet) check for
+being in an RCU read-side critical section.  In the future, separate
+versions of these primitives might be created.
diff --git a/Documentation/RCU/rcu.txt b/Documentation/RCU/rcu.txt
index 2a23523ce471..31852705b586 100644
--- a/Documentation/RCU/rcu.txt
+++ b/Documentation/RCU/rcu.txt
@@ -75,6 +75,8 @@ o	I hear that RCU is patented?  What is with that?
         search for the string "Patent" in RTFP.txt to find them.
         Of these, one was allowed to lapse by the assignee, and the
         others have been contributed to the Linux kernel under GPL.
+        There are now also LGPL implementations of user-level RCU
+        available (http://lttng.org/?q=node/18).
 
 o       I hear that RCU needs work in order to support realtime kernels?
 
@@ -91,48 +93,4 @@ o	Where can I find more information on RCU?
 
 o       What are all these files in this directory?
 
-
-        NMI-RCU.txt
-
-                Describes how to use RCU to implement dynamic
-                NMI handlers, which can be revectored on the fly,
-                without rebooting.
-
-        RTFP.txt
-
-                List of RCU-related publications and web sites.
-
-        UP.txt
-
-                Discussion of RCU usage in UP kernels.
-
-        arrayRCU.txt
-
-                Describes how to use RCU to protect arrays, with
-                resizeable arrays whose elements reference other
-                data structures being of the most interest.
-
-        checklist.txt
-
-                Lists things to check for when inspecting code that
-                uses RCU.
-
-        listRCU.txt
-
-                Describes how to use RCU to protect linked lists.
-                This is the simplest and most common use of RCU
-                in the Linux kernel.
-
-        rcu.txt
-
-                You are reading it!
-
-        rcuref.txt
-
-                Describes how to combine use of reference counts
-                with RCU.
-
-        whatisRCU.txt
-
-                Overview of how the RCU implementation works.  Along
-                the way, presents a conceptual view of RCU.
+        See 00-INDEX for the list.
diff --git a/Documentation/RCU/stallwarn.txt b/Documentation/RCU/stallwarn.txt
new file mode 100644
index 000000000000..1423d2570d78
--- /dev/null
+++ b/Documentation/RCU/stallwarn.txt
@@ -0,0 +1,58 @@
+Using RCU's CPU Stall Detector
+
+The CONFIG_RCU_CPU_STALL_DETECTOR kernel config parameter enables
+RCU's CPU stall detector, which detects conditions that unduly delay
+RCU grace periods.  The stall detector's idea of what constitutes
+"unduly delayed" is controlled by a pair of C preprocessor macros:
+
+RCU_SECONDS_TILL_STALL_CHECK
+
+        This macro defines the period of time that RCU will wait from
+        the beginning of a grace period until it issues an RCU CPU
+        stall warning.  It is normally ten seconds.
+
+RCU_SECONDS_TILL_STALL_RECHECK
+
+        This macro defines the period of time that RCU will wait after
+        issuing a stall warning until it issues another stall warning.
+        It is normally set to thirty seconds.
+
+RCU_STALL_RAT_DELAY
+
+        The CPU stall detector tries to make the offending CPU rat on itself,
+        as this often gives better-quality stack traces.  However, if
+        the offending CPU does not detect its own stall in the number
+        of jiffies specified by RCU_STALL_RAT_DELAY, then other CPUs will
+        complain.  This is normally set to two jiffies.
+
+The following problems can result in an RCU CPU stall warning:
+
+o       A CPU looping in an RCU read-side critical section.
+        
+o       A CPU looping with interrupts disabled.
+
+o       A CPU looping with preemption disabled.
+
+o       For !CONFIG_PREEMPT kernels, a CPU looping anywhere in the kernel
+        without invoking schedule().
+
+o       A bug in the RCU implementation.
+
+o       A hardware failure.  This is quite unlikely, but has occurred
+        at least once in a former life.  A CPU failed in a running system,
+        becoming unresponsive, but not causing an immediate crash.
+        This resulted in a series of RCU CPU stall warnings, eventually
+        leading the realization that the CPU had failed.
+
+The RCU, RCU-sched, and RCU-bh implementations have CPU stall warning.
+SRCU does not do so directly, but its calls to synchronize_sched() will
+result in RCU-sched detecting any CPU stalls that might be occurring.
+
+To diagnose the cause of the stall, inspect the stack traces.  The offending
+function will usually be near the top of the stack.  If you have a series
+of stall warnings from a single extended stall, comparing the stack traces
+can often help determine where the stall is occurring, which will usually
+be in the function nearest the top of the stack that stays the same from
+trace to trace.
+
+RCU bugs can often be debugged with the help of CONFIG_RCU_TRACE.
diff --git a/Documentation/RCU/torture.txt b/Documentation/RCU/torture.txt
index 9dba3bb90e60..0e50bc2aa1e2 100644
--- a/Documentation/RCU/torture.txt
+++ b/Documentation/RCU/torture.txt
@@ -30,6 +30,18 @@ MODULE PARAMETERS
 
 This module has the following parameters:
 
+fqs_duration    Duration (in microseconds) of artificially induced bursts
+                of force_quiescent_state() invocations.  In RCU
+                implementations having force_quiescent_state(), these
+                bursts help force races between forcing a given grace
+                period and that grace period ending on its own.
+
+fqs_holdoff     Holdoff time (in microseconds) between consecutive calls
+                to force_quiescent_state() within a burst.
+
+fqs_stutter     Wait time (in seconds) between consecutive bursts
+                of calls to force_quiescent_state().
+
 irqreaders      Says to invoke RCU readers from irq level.  This is currently
                 done via timers.  Defaults to "1" for variants of RCU that
                 permit this.  (Or, more accurately, variants of RCU that do
diff --git a/Documentation/RCU/whatisRCU.txt b/Documentation/RCU/whatisRCU.txt
index d542ca243b80..1dc00ee97163 100644
--- a/Documentation/RCU/whatisRCU.txt
+++ b/Documentation/RCU/whatisRCU.txt
@@ -323,14 +323,17 @@ used as follows:
         Defer                   Protect
 
 a.      synchronize_rcu()       rcu_read_lock() / rcu_read_unlock()
-        call_rcu()
+        call_rcu()              rcu_dereference()
 
 b.      call_rcu_bh()           rcu_read_lock_bh() / rcu_read_unlock_bh()
+                                rcu_dereference_bh()
 
-c.      synchronize_sched()     preempt_disable() / preempt_enable()
+c.      synchronize_sched()     rcu_read_lock_sched() / rcu_read_unlock_sched()
+                                preempt_disable() / preempt_enable()
                                 local_irq_save() / local_irq_restore()
                                 hardirq enter / hardirq exit
                                 NMI enter / NMI exit
+                                rcu_dereference_sched()
 
 These three mechanisms are used as follows:
 
@@ -780,9 +783,8 @@ Linux-kernel source code, but it helps to have a full list of the
 APIs, since there does not appear to be a way to categorize them
 in docbook.  Here is the list, by category.
 
-RCU pointer/list traversal:
+RCU list traversal:
 
-        rcu_dereference
         list_for_each_entry_rcu
         hlist_for_each_entry_rcu
         hlist_nulls_for_each_entry_rcu
@@ -808,7 +810,7 @@ RCU:	Critical sections	Grace period		Barrier
 
         rcu_read_lock           synchronize_net         rcu_barrier
         rcu_read_unlock         synchronize_rcu
-                                synchronize_rcu_expedited
+        rcu_dereference         synchronize_rcu_expedited
                                 call_rcu
 
 
@@ -816,7 +818,7 @@ bh:	Critical sections	Grace period		Barrier
 
         rcu_read_lock_bh        call_rcu_bh             rcu_barrier_bh
         rcu_read_unlock_bh      synchronize_rcu_bh
-                                synchronize_rcu_bh_expedited
+        rcu_dereference_bh      synchronize_rcu_bh_expedited
 
 
 sched:  Critical sections       Grace period            Barrier
@@ -825,12 +827,14 @@ sched:	Critical sections	Grace period		Barrier
         rcu_read_unlock_sched   call_rcu_sched
         [preempt_disable]       synchronize_sched_expedited
         [and friends]
+        rcu_dereference_sched
 
 
 SRCU:   Critical sections       Grace period            Barrier
 
         srcu_read_lock          synchronize_srcu        N/A
         srcu_read_unlock        synchronize_srcu_expedited
+        srcu_dereference
 
 SRCU:   Initialization/cleanup
         init_srcu_struct
diff --git a/Documentation/cachetlb.txt b/Documentation/cachetlb.txt
index da42ab414c48..b231414bb8bc 100644
--- a/Documentation/cachetlb.txt
+++ b/Documentation/cachetlb.txt
@@ -377,3 +377,27 @@ maps this page at its virtual address.
         All the functionality of flush_icache_page can be implemented in
         flush_dcache_page and update_mmu_cache. In 2.7 the hope is to
         remove this interface completely.
+
+The final category of APIs is for I/O to deliberately aliased address
+ranges inside the kernel.  Such aliases are set up by use of the
+vmap/vmalloc API.  Since kernel I/O goes via physical pages, the I/O
+subsystem assumes that the user mapping and kernel offset mapping are
+the only aliases.  This isn't true for vmap aliases, so anything in
+the kernel trying to do I/O to vmap areas must manually manage
+coherency.  It must do this by flushing the vmap range before doing
+I/O and invalidating it after the I/O returns.
+
+  void flush_kernel_vmap_range(void *vaddr, int size)
+       flushes the kernel cache for a given virtual address range in
+       the vmap area.  This is to make sure that any data the kernel
+       modified in the vmap range is made visible to the physical
+       page.  The design is to make this area safe to perform I/O on.
+       Note that this API does *not* also flush the offset map alias
+       of the area.
+
+  void invalidate_kernel_vmap_range(void *vaddr, int size) invalidates
+       the cache for a given virtual address range in the vmap area
+       which prevents the processor from making the cache stale by
+       speculatively reading data while the I/O was occurring to the
+       physical pages.  This is only necessary for data reads into the
+       vmap area.
diff --git a/Documentation/dontdiff b/Documentation/dontdiff
index 3ad6acead949..d9bcffd59433 100644
--- a/Documentation/dontdiff
+++ b/Documentation/dontdiff
@@ -69,7 +69,6 @@ av_permissions.h
 bbootsect
 bin2c
 binkernel.spec
-binoffset
 bootsect
 bounds.h
 bsetup
diff --git a/Documentation/dvb/get_dvb_firmware b/Documentation/dvb/get_dvb_firmware
index 14b7b5a3bcb9..239cbdbf4d12 100644
--- a/Documentation/dvb/get_dvb_firmware
+++ b/Documentation/dvb/get_dvb_firmware
@@ -26,7 +26,7 @@ use IO::Handle;
                 "dec3000s", "vp7041", "dibusb", "nxt2002", "nxt2004",
                 "or51211", "or51132_qam", "or51132_vsb", "bluebird",
                 "opera1", "cx231xx", "cx18", "cx23885", "pvrusb2", "mpc718",
-                "af9015");
+                "af9015", "ngene");
 
 # Check args
 syntax() if (scalar(@ARGV) != 1);
@@ -39,7 +39,7 @@ for ($i=0; $i < scalar(@components); $i++) {
         die $@ if $@;
         print STDERR <<EOF;
 Firmware(s) $outfile extracted successfully.
-Now copy it(they) to either /usr/lib/hotplug/firmware or /lib/firmware
+Now copy it(them) to either /usr/lib/hotplug/firmware or /lib/firmware
 (depending on configuration of firmware hotplug).
 EOF
         exit(0);
@@ -549,6 +549,24 @@ sub af9015 {
         close INFILE;
 }
 
+sub ngene {
+    my $url = "http://www.digitaldevices.de/download/";
+    my $file1 = "ngene_15.fw";
+    my $hash1 = "d798d5a757121174f0dbc5f2833c0c85";
+    my $file2 = "ngene_17.fw";
+    my $hash2 = "26b687136e127b8ac24b81e0eeafc20b";
+
+    checkstandard();
+
+    wgetfile($file1, $url . $file1);
+    verify($file1, $hash1);
+
+    wgetfile($file2, $url . $file2);
+    verify($file2, $hash2);
+
+    "$file1, $file2";
+}
+
 # ---------------------------------------------------------------
 # Utilities
 
@@ -667,6 +685,7 @@ sub delzero{
 sub syntax() {
     print STDERR "syntax: get_dvb_firmware <component>\n";
     print STDERR "Supported components:\n";
+    @components = sort @components;
     for($i=0; $i < scalar(@components); $i++) {
         print STDERR "\t" . $components[$i] . "\n";
     }
diff --git a/Documentation/feature-removal-schedule.txt b/Documentation/feature-removal-schedule.txt
index 0a46833c1b76..ea401495528d 100644
--- a/Documentation/feature-removal-schedule.txt
+++ b/Documentation/feature-removal-schedule.txt
@@ -6,21 +6,6 @@ be removed from this file.
 
 ---------------------------
 
-What:   USER_SCHED
-When:   2.6.34
-
-Why:    USER_SCHED was implemented as a proof of concept for group scheduling.
-        The effect of USER_SCHED can already be achieved from userspace with
-        the help of libcgroup. The removal of USER_SCHED will also simplify
-        the scheduler code with the removal of one major ifdef. There are also
-        issues USER_SCHED has with USER_NS. A decision was taken not to fix
-        those and instead remove USER_SCHED. Also new group scheduling
-        features will not be implemented for USER_SCHED.
-
-Who:    Dhaval Giani <dhaval@linux.vnet.ibm.com>
-
----------------------------
-
 What:   PRISM54
 When:   2.6.34
 
@@ -64,6 +49,17 @@ Who:	Robin Getz <rgetz@blackfin.uclinux.org> & Matt Mackall <mpm@selenic.com>
 
 ---------------------------
 
+What:   Deprecated snapshot ioctls
+When:   2.6.36
+
+Why:    The ioctls in kernel/power/user.c were marked as deprecated long time
+        ago. Now they notify users about that so that they need to replace
+        their userspace. After some more time, remove them completely.
+
+Who:    Jiri Slaby <jirislaby@gmail.com>
+
+---------------------------
+
 What:   The ieee80211_regdom module parameter
 When:   March 2010 / desktop catchup
 
diff --git a/Documentation/filesystems/dentry-locking.txt b/Documentation/filesystems/dentry-locking.txt
index 4c0c575a4012..79334ed5daa7 100644
--- a/Documentation/filesystems/dentry-locking.txt
+++ b/Documentation/filesystems/dentry-locking.txt
@@ -62,7 +62,8 @@ changes are :
 2. Insertion of a dentry into the hash table is done using
    hlist_add_head_rcu() which take care of ordering the writes - the
    writes to the dentry must be visible before the dentry is
-   inserted. This works in conjunction with hlist_for_each_rcu() while
+   inserted. This works in conjunction with hlist_for_each_rcu(),
+   which has since been replaced by hlist_for_each_entry_rcu(), while
    walking the hash chain. The only requirement is that all
    initialization to the dentry must be done before
    hlist_add_head_rcu() since we don't have dcache_lock protection
diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index e7848a0d99eb..8c666d80f0e7 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -1738,6 +1738,9 @@ and is between 256 and 4096 characters. It is defined in the file
         nomfgpt         [X86-32] Disable Multi-Function General Purpose
                         Timer usage (for AMD Geode machines).
 
+        nopat           [X86] Disable PAT (page attribute table extension of
+                        pagetables) support.
+
         norandmaps      Don't use address space randomization.  Equivalent to
                         echo 0 > /proc/sys/kernel/randomize_va_space
 
@@ -1948,8 +1951,12 @@ and is between 256 and 4096 characters. It is defined in the file
                                 IRQ routing is enabled.
                 noacpi          [X86] Do not use ACPI for IRQ routing
                                 or for PCI scanning.
-                use_crs         [X86] Use _CRS for PCI resource
-                                allocation.
+                use_crs         [X86] Use PCI host bridge window information
+                                from ACPI.  On BIOSes from 2008 or later, this
+                                is enabled by default.  If you need to use this,
+                                please report a bug.
+                nocrs           [X86] Ignore PCI host bridge windows from ACPI.
+                                If you need to use this, please report a bug.
                 routeirq        Do IRQ routing for all PCI devices.
                                 This is normally done in pci_enable_device(),
                                 so this option is a temporary workaround
@@ -1998,6 +2005,14 @@ and is between 256 and 4096 characters. It is defined in the file
                 force   Enable ASPM even on devices that claim not to support it.
                         WARNING: Forcing ASPM on may cause system lockups.
 
+        pcie_pme=       [PCIE,PM] Native PCIe PME signaling options:
+                off     Do not use native PCIe PME signaling.
+                force   Use native PCIe PME signaling even if the BIOS refuses
+                        to allow the kernel to control the relevant PCIe config
+                        registers.
+                nomsi   Do not use MSI for native PCIe PME signaling (this makes
+                        all PCIe root ports use INTx for everything).
+
         pcmv=           [HW,PCMCIA] BadgePAD 4
 
         pd.             [PARIDE]
@@ -2703,6 +2718,13 @@ and is between 256 and 4096 characters. It is defined in the file
                                         medium is write-protected).
                         Example: quirks=0419:aaf5:rl,0421:0433:rc
 
+        userpte=
+                        [X86] Flags controlling user PTE allocations.
+
+                                nohigh = do not allocate PTE pages in
+                                        HIGHMEM regardless of setting
+                                        of CONFIG_HIGHPTE.
+
         vdso=           [X86,SH]
                         vdso=2: enable compat VDSO (default with COMPAT_VDSO)
                         vdso=1: enable VDSO (default)
diff --git a/Documentation/lguest/lguest.c b/Documentation/lguest/lguest.c
index 42208511b5c0..3119f5db75bd 100644
--- a/Documentation/lguest/lguest.c
+++ b/Documentation/lguest/lguest.c
@@ -34,7 +34,6 @@
 #include <sys/uio.h>
 #include <termios.h>
 #include <getopt.h>
-#include <zlib.h>
 #include <assert.h>
 #include <sched.h>
 #include <limits.h>
diff --git a/Documentation/pcmcia/locking.txt b/Documentation/pcmcia/locking.txt
new file mode 100644
index 000000000000..68f622bc4064
--- /dev/null
+++ b/Documentation/pcmcia/locking.txt
@@ -0,0 +1,118 @@
+This file explains the locking and exclusion scheme used in the PCCARD
+and PCMCIA subsystems.
+
+
+A) Overview, Locking Hierarchy:
+===============================
+
+pcmcia_socket_list_rwsem        - protects only the list of sockets
+- skt_mutex                     - serializes card insert / ejection
+  - ops_mutex                   - serializes socket operation
+
+
+B) Exclusion
+============
+
+The following functions and callbacks to struct pcmcia_socket must
+be called with "skt_mutex" held:
+
+        socket_detect_change()
+        send_event()
+        socket_reset()
+        socket_shutdown()
+        socket_setup()
+        socket_remove()
+        socket_insert()
+        socket_early_resume()
+        socket_late_resume()
+        socket_resume()
+        socket_suspend()
+
+        struct pcmcia_callback  *callback
+
+The following functions and callbacks to struct pcmcia_socket must
+be called with "ops_mutex" held:
+
+        socket_reset()
+        socket_setup()
+
+        struct pccard_operations        *ops
+        struct pccard_resource_ops      *resource_ops;
+
+Note that send_event() and struct pcmcia_callback *callback must not be
+called with "ops_mutex" held.
+
+
+C) Protection
+=============
+
+1. Global Data:
+---------------
+struct list_head        pcmcia_socket_list;
+
+protected by pcmcia_socket_list_rwsem;
+
+
+2. Per-Socket Data:
+-------------------
+The resource_ops and their data are protected by ops_mutex.
+
+The "main" struct pcmcia_socket is protected as follows (read-only fields
+or single-use fields not mentioned):
+
+- by pcmcia_socket_list_rwsem:
+        struct list_head        socket_list;
+
+- by thread_lock:
+        unsigned int            thread_events;
+
+- by skt_mutex:
+        u_int                   suspended_state;
+        void                    (*tune_bridge);
+        struct pcmcia_callback  *callback;
+        int                     resume_status;
+
+- by ops_mutex:
+        socket_state_t          socket;
+        u_int                   state;
+        u_short                 lock_count;
+        pccard_mem_map          cis_mem;
+        void __iomem            *cis_virt;
+        struct { }              irq;
+        io_window_t             io[];
+        pccard_mem_map          win[];
+        struct list_head        cis_cache;
+        size_t                  fake_cis_len;
+        u8                      *fake_cis;
+        u_int                   irq_mask;
+        void                    (*zoom_video);
+        int                     (*power_hook);
+        u8                      resource...;
+        struct list_head        devices_list;
+        u8                      device_count;
+        struct                  pcmcia_state;
+
+
+3. Per PCMCIA-device Data:
+--------------------------
+
+The "main" struct pcmcia_devie is protected as follows (read-only fields
+or single-use fields not mentioned):
+
+
+- by pcmcia_socket->ops_mutex:
+        struct list_head        socket_device_list;
+        struct config_t         *function_config;
+        u16                     _irq:1;
+        u16                     _io:1;
+        u16                     _win:4;
+        u16                     _locked:1;
+        u16                     allow_func_id_match:1;
+        u16                     suspended:1;
+        u16                     _removed:1;
+
+- by the PCMCIA driver:
+        io_req_t                io;
+        irq_req_t               irq;
+        config_req_t            conf;
+        window_handle_t         win;
diff --git a/Documentation/powerpc/dts-bindings/fsl/mpc5121-psc.txt b/Documentation/powerpc/dts-bindings/fsl/mpc5121-psc.txt
new file mode 100644
index 000000000000..8832e8798912
--- /dev/null
+++ b/Documentation/powerpc/dts-bindings/fsl/mpc5121-psc.txt
@@ -0,0 +1,70 @@
+MPC5121 PSC Device Tree Bindings
+
+PSC in UART mode
+----------------
+
+For PSC in UART mode the needed PSC serial devices
+are specified by fsl,mpc5121-psc-uart nodes in the
+fsl,mpc5121-immr SoC node. Additionally the PSC FIFO
+Controller node fsl,mpc5121-psc-fifo is requered there:
+
+fsl,mpc5121-psc-uart nodes
+--------------------------
+
+Required properties :
+ - compatible : Should contain "fsl,mpc5121-psc-uart" and "fsl,mpc5121-psc"
+ - cell-index : Index of the PSC in hardware
+ - reg : Offset and length of the register set for the PSC device
+ - interrupts : <a b> where a is the interrupt number of the
+   PSC FIFO Controller and b is a field that represents an
+   encoding of the sense and level information for the interrupt.
+ - interrupt-parent : the phandle for the interrupt controller that
+   services interrupts for this device.
+
+Recommended properties :
+ - fsl,rx-fifo-size : the size of the RX fifo slice (a multiple of 4)
+ - fsl,tx-fifo-size : the size of the TX fifo slice (a multiple of 4)
+
+
+fsl,mpc5121-psc-fifo node
+-------------------------
+
+Required properties :
+ - compatible : Should be "fsl,mpc5121-psc-fifo"
+ - reg : Offset and length of the register set for the PSC
+         FIFO Controller
+ - interrupts : <a b> where a is the interrupt number of the
+   PSC FIFO Controller and b is a field that represents an
+   encoding of the sense and level information for the interrupt.
+ - interrupt-parent : the phandle for the interrupt controller that
+   services interrupts for this device.
+
+
+Example for a board using PSC0 and PSC1 devices in serial mode:
+
+serial@11000 {
+        compatible = "fsl,mpc5121-psc-uart", "fsl,mpc5121-psc";
+        cell-index = <0>;
+        reg = <0x11000 0x100>;
+        interrupts = <40 0x8>;
+        interrupt-parent = < &ipic >;
+        fsl,rx-fifo-size = <16>;
+        fsl,tx-fifo-size = <16>;
+};
+
+serial@11100 {
+        compatible = "fsl,mpc5121-psc-uart", "fsl,mpc5121-psc";
+        cell-index = <1>;
+        reg = <0x11100 0x100>;
+        interrupts = <40 0x8>;
+        interrupt-parent = < &ipic >;
+        fsl,rx-fifo-size = <16>;
+        fsl,tx-fifo-size = <16>;
+};
+
+pscfifo@11f00 {
+        compatible = "fsl,mpc5121-psc-fifo";
+        reg = <0x11f00 0x100>;
+        interrupts = <40 0x8>;
+        interrupt-parent = < &ipic >;
+};
diff --git a/Documentation/powerpc/dts-bindings/fsl/spi.txt b/Documentation/powerpc/dts-bindings/fsl/spi.txt
index e7d9a344c4f4..80510c018eea 100644
--- a/Documentation/powerpc/dts-bindings/fsl/spi.txt
+++ b/Documentation/powerpc/dts-bindings/fsl/spi.txt
@@ -13,6 +13,11 @@ Required properties:
 - interrupt-parent : the phandle for the interrupt controller that
   services interrupts for this device.
 
+Optional properties:
+- gpios : specifies the gpio pins to be used for chipselects.
+  The gpios will be referred to as reg = <index> in the SPI child nodes.
+  If unspecified, a single SPI device without a chip select can be used.
+
 Example:
         spi@4c0 {
                 cell-index = <0>;
@@ -21,4 +26,6 @@ Example:
                 interrupts = <82 0>;
                 interrupt-parent = <700>;
                 mode = "cpu";
+                gpios = <&gpio 18 1     // device reg=<0>
+                         &gpio 19 1>;   // device reg=<1>
         };
diff --git a/Documentation/powerpc/ptrace.txt b/Documentation/powerpc/ptrace.txt
new file mode 100644
index 000000000000..f4a5499b7bc6
--- /dev/null
+++ b/Documentation/powerpc/ptrace.txt
@@ -0,0 +1,134 @@
+GDB intends to support the following hardware debug features of BookE
+processors:
+
+4 hardware breakpoints (IAC)
+2 hardware watchpoints (read, write and read-write) (DAC)
+2 value conditions for the hardware watchpoints (DVC)
+
+For that, we need to extend ptrace so that GDB can query and set these
+resources. Since we're extending, we're trying to create an interface
+that's extendable and that covers both BookE and server processors, so
+that GDB doesn't need to special-case each of them. We added the
+following 3 new ptrace requests.
+
+1. PTRACE_PPC_GETHWDEBUGINFO
+
+Query for GDB to discover the hardware debug features. The main info to
+be returned here is the minimum alignment for the hardware watchpoints.
+BookE processors don't have restrictions here, but server processors have
+an 8-byte alignment restriction for hardware watchpoints. We'd like to avoid
+adding special cases to GDB based on what it sees in AUXV.
+
+Since we're at it, we added other useful info that the kernel can return to
+GDB: this query will return the number of hardware breakpoints, hardware
+watchpoints and whether it supports a range of addresses and a condition.
+The query will fill the following structure provided by the requesting process:
+
+struct ppc_debug_info {
+       unit32_t version;
+       unit32_t num_instruction_bps;
+       unit32_t num_data_bps;
+       unit32_t num_condition_regs;
+       unit32_t data_bp_alignment;
+       unit32_t sizeof_condition; /* size of the DVC register */
+       uint64_t features; /* bitmask of the individual flags */
+};
+
+features will have bits indicating whether there is support for:
+
+#define PPC_DEBUG_FEATURE_INSN_BP_RANGE         0x1
+#define PPC_DEBUG_FEATURE_INSN_BP_MASK          0x2
+#define PPC_DEBUG_FEATURE_DATA_BP_RANGE         0x4
+#define PPC_DEBUG_FEATURE_DATA_BP_MASK          0x8
+
+2. PTRACE_SETHWDEBUG
+
+Sets a hardware breakpoint or watchpoint, according to the provided structure:
+
+struct ppc_hw_breakpoint {
+        uint32_t version;
+#define PPC_BREAKPOINT_TRIGGER_EXECUTE  0x1
+#define PPC_BREAKPOINT_TRIGGER_READ     0x2
+#define PPC_BREAKPOINT_TRIGGER_WRITE    0x4
+        uint32_t trigger_type;       /* only some combinations allowed */
+#define PPC_BREAKPOINT_MODE_EXACT               0x0
+#define PPC_BREAKPOINT_MODE_RANGE_INCLUSIVE     0x1
+#define PPC_BREAKPOINT_MODE_RANGE_EXCLUSIVE     0x2
+#define PPC_BREAKPOINT_MODE_MASK                0x3
+        uint32_t addr_mode;          /* address match mode */
+
+#define PPC_BREAKPOINT_CONDITION_MODE   0x3
+#define PPC_BREAKPOINT_CONDITION_NONE   0x0
+#define PPC_BREAKPOINT_CONDITION_AND    0x1
+#define PPC_BREAKPOINT_CONDITION_EXACT  0x1     /* different name for the same thing as above */
+#define PPC_BREAKPOINT_CONDITION_OR     0x2
+#define PPC_BREAKPOINT_CONDITION_AND_OR 0x3
+#define PPC_BREAKPOINT_CONDITION_BE_ALL 0x00ff0000      /* byte enable bits */
+#define PPC_BREAKPOINT_CONDITION_BE(n)  (1<<((n)+16))
+        uint32_t condition_mode;     /* break/watchpoint condition flags */
+
+        uint64_t addr;
+        uint64_t addr2;
+        uint64_t condition_value;
+};
+
+A request specifies one event, not necessarily just one register to be set.
+For instance, if the request is for a watchpoint with a condition, both the
+DAC and DVC registers will be set in the same request.
+
+With this GDB can ask for all kinds of hardware breakpoints and watchpoints
+that the BookE supports. COMEFROM breakpoints available in server processors
+are not contemplated, but that is out of the scope of this work.
+
+ptrace will return an integer (handle) uniquely identifying the breakpoint or
+watchpoint just created. This integer will be used in the PTRACE_DELHWDEBUG
+request to ask for its removal. Return -ENOSPC if the requested breakpoint
+can't be allocated on the registers.
+
+Some examples of using the structure to:
+
+- set a breakpoint in the first breakpoint register
+
+  p.version         = PPC_DEBUG_CURRENT_VERSION;
+  p.trigger_type    = PPC_BREAKPOINT_TRIGGER_EXECUTE;
+  p.addr_mode       = PPC_BREAKPOINT_MODE_EXACT;
+  p.condition_mode  = PPC_BREAKPOINT_CONDITION_NONE;
+  p.addr            = (uint64_t) address;
+  p.addr2           = 0;
+  p.condition_value = 0;
+
+- set a watchpoint which triggers on reads in the second watchpoint register
+
+  p.version         = PPC_DEBUG_CURRENT_VERSION;
+  p.trigger_type    = PPC_BREAKPOINT_TRIGGER_READ;
+  p.addr_mode       = PPC_BREAKPOINT_MODE_EXACT;
+  p.condition_mode  = PPC_BREAKPOINT_CONDITION_NONE;
+  p.addr            = (uint64_t) address;
+  p.addr2           = 0;
+  p.condition_value = 0;
+
+- set a watchpoint which triggers only with a specific value
+
+  p.version         = PPC_DEBUG_CURRENT_VERSION;
+  p.trigger_type    = PPC_BREAKPOINT_TRIGGER_READ;
+  p.addr_mode       = PPC_BREAKPOINT_MODE_EXACT;
+  p.condition_mode  = PPC_BREAKPOINT_CONDITION_AND | PPC_BREAKPOINT_CONDITION_BE_ALL;
+  p.addr            = (uint64_t) address;
+  p.addr2           = 0;
+  p.condition_value = (uint64_t) condition;
+
+- set a ranged hardware breakpoint
+
+  p.version         = PPC_DEBUG_CURRENT_VERSION;
+  p.trigger_type    = PPC_BREAKPOINT_TRIGGER_EXECUTE;
+  p.addr_mode       = PPC_BREAKPOINT_MODE_RANGE_INCLUSIVE;
+  p.condition_mode  = PPC_BREAKPOINT_CONDITION_NONE;
+  p.addr            = (uint64_t) begin_range;
+  p.addr2           = (uint64_t) end_range;
+  p.condition_value = 0;
+
+3. PTRACE_DELHWDEBUG
+
+Takes an integer which identifies an existing breakpoint or watchpoint
+(i.e., the value returned from PTRACE_SETHWDEBUG), and deletes the
+corresponding breakpoint or watchpoint..
diff --git a/Documentation/s390/CommonIO b/Documentation/s390/CommonIO
index 339207d11d95..d378cba66456 100644
--- a/Documentation/s390/CommonIO
+++ b/Documentation/s390/CommonIO
@@ -87,6 +87,12 @@ Command line parameters
   compatibility, by the device number in hexadecimal (0xabcd or abcd). Device
   numbers given as 0xabcd will be interpreted as 0.0.abcd.
 
+* /proc/cio_settle
+
+  A write request to this file is blocked until all queued cio actions are
+  handled. This will allow userspace to wait for pending work affecting
+  device availability after changing cio_ignore or the hardware configuration.
+
 * For some of the information present in the /proc filesystem in 2.4 (namely,
   /proc/subchannels and /proc/chpids), see driver-model.txt.
   Information formerly in /proc/irq_count is now in /proc/interrupts.
diff --git a/Documentation/s390/driver-model.txt b/Documentation/s390/driver-model.txt
index bde473df748d..ed265cf54cde 100644
--- a/Documentation/s390/driver-model.txt
+++ b/Documentation/s390/driver-model.txt
@@ -223,8 +223,8 @@ touched by the driver - it should use the ccwgroup device's driver_data for its
 private data.
 
 To implement a ccwgroup driver, please refer to include/asm/ccwgroup.h. Keep in
-mind that most drivers will need to implement both a ccwgroup and a ccw driver
-(unless you have a meta ccw driver, like cu3088 for lcs and ctc).
+mind that most drivers will need to implement both a ccwgroup and a ccw
+driver.
 
 
 2. Channel paths
diff --git a/Documentation/scsi/ChangeLog.megaraid_sas b/Documentation/scsi/ChangeLog.megaraid_sas
index 17ffa0607712..30023568805e 100644
--- a/Documentation/scsi/ChangeLog.megaraid_sas
+++ b/Documentation/scsi/ChangeLog.megaraid_sas
@@ -1,3 +1,19 @@
+1 Release Date    : Thur.  Oct 29, 2009 09:12:45 PST 2009 -
+                        (emaild-id:megaraidlinux@lsi.com)
+                        Bo Yang
+
+2 Current Version : 00.00.04.17.1-rc1
+3 Older Version   : 00.00.04.12
+
+1.      Add the pad_0 in mfi frame structure to 0 to fix the
+        context value larger than 32bit value issue.
+
+2.      Add the logic drive list to the driver.  Driver will
+        keep the logic drive list internal after driver load.
+
+3.      driver fixed the device update issue after get the AEN
+        PD delete/ADD, LD add/delete from FW.
+
 1 Release Date    : Tues.  July 28, 2009 10:12:45 PST 2009 -
                         (emaild-id:megaraidlinux@lsi.com)
                         Bo Yang
diff --git a/Documentation/trace/ftrace-design.txt b/Documentation/trace/ftrace-design.txt
index 6a5a579126b0..f1f81afee8a0 100644
--- a/Documentation/trace/ftrace-design.txt
+++ b/Documentation/trace/ftrace-design.txt
@@ -238,11 +238,10 @@ HAVE_SYSCALL_TRACEPOINTS
 
 You need very few things to get the syscalls tracing in an arch.
 
+- Support HAVE_ARCH_TRACEHOOK (see arch/Kconfig).
 - Have a NR_syscalls variable in <asm/unistd.h> that provides the number
   of syscalls supported by the arch.
-- Implement arch_syscall_addr() that resolves a syscall address from a
-  syscall number.
-- Support the TIF_SYSCALL_TRACEPOINT thread flags
+- Support the TIF_SYSCALL_TRACEPOINT thread flags.
 - Put the trace_sys_enter() and trace_sys_exit() tracepoints calls from ptrace
   in the ptrace syscalls tracing path.
 - Tag this arch as HAVE_SYSCALL_TRACEPOINTS.
diff --git a/Documentation/trace/kprobetrace.txt b/Documentation/trace/kprobetrace.txt
index 47aabeebbdf6..a9100b28eb84 100644
--- a/Documentation/trace/kprobetrace.txt
+++ b/Documentation/trace/kprobetrace.txt
@@ -24,6 +24,7 @@ Synopsis of kprobe_events
 -------------------------
   p[:[GRP/]EVENT] SYMBOL[+offs]|MEMADDR [FETCHARGS]     : Set a probe
   r[:[GRP/]EVENT] SYMBOL[+0] [FETCHARGS]                : Set a return probe
+  -:[GRP/]EVENT                                         : Clear a probe
 
  GRP            : Group name. If omitted, use "kprobes" for it.
  EVENT          : Event name. If omitted, the event name is generated
@@ -37,15 +38,12 @@ Synopsis of kprobe_events
   @SYM[+|-offs] : Fetch memory at SYM +|- offs (SYM should be a data symbol)
   $stackN       : Fetch Nth entry of stack (N >= 0)
   $stack        : Fetch stack address.
-  $argN         : Fetch function argument. (N >= 0)(*)
-  $retval       : Fetch return value.(**)
-  +|-offs(FETCHARG) : Fetch memory at FETCHARG +|- offs address.(***)
+  $retval       : Fetch return value.(*)
+  +|-offs(FETCHARG) : Fetch memory at FETCHARG +|- offs address.(**)
   NAME=FETCHARG: Set NAME as the argument name of FETCHARG.
 
-  (*) aN may not correct on asmlinkaged functions and at the middle of
-      function body.
-  (**) only for return probe.
-  (***) this is useful for fetching a field of data structures.
+  (*) only for return probe.
+  (**) this is useful for fetching a field of data structures.
 
 
 Per-Probe Event Filtering
@@ -82,13 +80,16 @@ Usage examples
 To add a probe as a new event, write a new definition to kprobe_events
 as below.
 
-  echo p:myprobe do_sys_open dfd=$arg0 filename=$arg1 flags=$arg2 mode=$arg3 > /sys/kernel/debug/tracing/kprobe_events
+  echo 'p:myprobe do_sys_open dfd=%ax filename=%dx flags=%cx mode=+4($stack)' > /sys/kernel/debug/tracing/kprobe_events
 
  This sets a kprobe on the top of do_sys_open() function with recording
-1st to 4th arguments as "myprobe" event. As this example shows, users can
-choose more familiar names for each arguments.
+1st to 4th arguments as "myprobe" event. Note, which register/stack entry is
+assigned to each function argument depends on arch-specific ABI. If you unsure
+the ABI, please try to use probe subcommand of perf-tools (you can find it
+under tools/perf/).
+As this example shows, users can choose more familiar names for each arguments.
 
-  echo r:myretprobe do_sys_open $retval >> /sys/kernel/debug/tracing/kprobe_events
+  echo 'r:myretprobe do_sys_open $retval' >> /sys/kernel/debug/tracing/kprobe_events
 
  This sets a kretprobe on the return point of do_sys_open() function with
 recording return value as "myretprobe" event.
@@ -97,23 +98,24 @@ recording return value as "myretprobe" event.
 
   cat /sys/kernel/debug/tracing/events/kprobes/myprobe/format
 name: myprobe
-ID: 75
+ID: 780
 format:
-        field:unsigned short common_type;       offset:0;       size:2;
-        field:unsigned char common_flags;       offset:2;       size:1;
-        field:unsigned char common_preempt_count;       offset:3;       size:1;
-        field:int common_pid;   offset:4;       size:4;
-        field:int common_tgid;  offset:8;       size:4;
+        field:unsigned short common_type;       offset:0;       size:2; signed:0;
+        field:unsigned char common_flags;       offset:2;       size:1; signed:0;
+        field:unsigned char common_preempt_count;       offset:3; size:1;signed:0;
+        field:int common_pid;   offset:4;       size:4; signed:1;
+        field:int common_lock_depth;    offset:8;       size:4; signed:1;
 
-        field: unsigned long ip;        offset:16;tsize:8;
-        field: int nargs;       offset:24;tsize:4;
-        field: unsigned long dfd;       offset:32;tsize:8;
-        field: unsigned long filename;  offset:40;tsize:8;
-        field: unsigned long flags;     offset:48;tsize:8;
-        field: unsigned long mode;      offset:56;tsize:8;
+        field:unsigned long __probe_ip; offset:12;      size:4; signed:0;
+        field:int __probe_nargs;        offset:16;      size:4; signed:1;
+        field:unsigned long dfd;        offset:20;      size:4; signed:0;
+        field:unsigned long filename;   offset:24;      size:4; signed:0;
+        field:unsigned long flags;      offset:28;      size:4; signed:0;
+        field:unsigned long mode;       offset:32;      size:4; signed:0;
 
-print fmt: "(%lx) dfd=%lx filename=%lx flags=%lx mode=%lx", REC->ip, REC->dfd, REC->filename, REC->flags, REC->mode
 
+print fmt: "(%lx) dfd=%lx filename=%lx flags=%lx mode=%lx", REC->__probe_ip,
+REC->dfd, REC->filename, REC->flags, REC->mode
 
  You can see that the event has 4 arguments as in the expressions you specified.
 
@@ -121,6 +123,12 @@ print fmt: "(%lx) dfd=%lx filename=%lx flags=%lx mode=%lx", REC->ip, REC->dfd, R
 
  This clears all probe points.
 
+ Or,
+
+  echo -:myprobe >> kprobe_events
+
+ This clears probe points selectively.
+
  Right after definition, each event is disabled by default. For tracing these
 events, you need to enable it.
 
@@ -146,4 +154,3 @@ events, you need to enable it.
 returns from SYMBOL(e.g. "sys_open+0x1b/0x1d <- do_sys_open" means kernel
 returns from do_sys_open to sys_open+0x1b).
 
-
diff --git a/Documentation/video4linux/CARDLIST.cx23885 b/Documentation/video4linux/CARDLIST.cx23885
index 7539e8fa1ffd..16ca030e1185 100644
--- a/Documentation/video4linux/CARDLIST.cx23885
+++ b/Documentation/video4linux/CARDLIST.cx23885
@@ -26,3 +26,4 @@
  25 -> Compro VideoMate E800                               [1858:e800]
  26 -> Hauppauge WinTV-HVR1290                             [0070:8551]
  27 -> Mygica X8558 PRO DMB-TH                             [14f1:8578]
+ 28 -> LEADTEK WinFast PxTV1200                            [107d:6f22]
diff --git a/Documentation/video4linux/CARDLIST.saa7134 b/Documentation/video4linux/CARDLIST.saa7134
index fce1e7eb0474..b4a767060ed7 100644
--- a/Documentation/video4linux/CARDLIST.saa7134
+++ b/Documentation/video4linux/CARDLIST.saa7134
@@ -174,3 +174,4 @@
 173 -> Zolid Hybrid TV Tuner PCI                [1131:2004]
 174 -> Asus Europa Hybrid OEM                   [1043:4847]
 175 -> Leadtek Winfast DTV1000S                 [107d:6655]
+176 -> Beholder BeholdTV 505 RDS                [0000:5051]
diff --git a/Documentation/video4linux/CARDLIST.tuner b/Documentation/video4linux/CARDLIST.tuner
index e0d298fe8830..9b2e0dd6017e 100644
--- a/Documentation/video4linux/CARDLIST.tuner
+++ b/Documentation/video4linux/CARDLIST.tuner
@@ -81,3 +81,4 @@ tuner=80 - Philips FQ1216LME MK3 PAL/SECAM w/active loopthrough
 tuner=81 - Partsnic (Daewoo) PTI-5NF05
 tuner=82 - Philips CU1216L
 tuner=83 - NXP TDA18271
+tuner=84 - Sony BTF-Pxn01Z
diff --git a/Documentation/video4linux/README.tlg2300 b/Documentation/video4linux/README.tlg2300
new file mode 100644
index 000000000000..416ccb93d8c9
--- /dev/null
+++ b/Documentation/video4linux/README.tlg2300
@@ -0,0 +1,47 @@
+tlg2300 release notes
+====================
+
+This is a v4l2/dvb device driver for the tlg2300 chip.
+
+
+current status
+==============
+
+video
+        - support mmap and read().(no overlay)
+
+audio
+        - The driver will register a ALSA card for the audio input.
+
+vbi
+        - Works for almost TV norms.
+
+dvb-t
+        - works for DVB-T
+
+FM
+        - Works for radio.
+
+---------------------------------------------------------------------------
+TESTED APPLICATIONS:
+
+-VLC1.0.4 test the video and dvb. The GUI is friendly to use.
+
+-Mplayer test the video.
+
+-Mplayer test the FM. The mplayer should be compiled with --enable-radio and
+         --enable-radio-capture.
+        The command runs as this(The alsa audio registers to card 1):
+        #mplayer radio://103.7/capture/ -radio adevice=hw=1,0:arate=48000 \
+                -rawaudio rate=48000:channels=2
+
+---------------------------------------------------------------------------
+KNOWN PROBLEMS:
+about preemphasis:
+        You can set the preemphasis for radio by the following command:
+        #v4l2-ctl -d /dev/radio0 --set-ctrl=pre_emphasis_settings=1
+
+        "pre_emphasis_settings=1" means that you select the 50us. If you want
+        to select the 75us, please use "pre_emphasis_settings=2"
+
+
diff --git a/Documentation/video4linux/gspca.txt b/Documentation/video4linux/gspca.txt
index 1800a62cf135..181b9e6fd984 100644
--- a/Documentation/video4linux/gspca.txt
+++ b/Documentation/video4linux/gspca.txt
@@ -42,6 +42,7 @@ ov519		041e:4064	Creative Live! VISTA VF0420
 ov519           041e:4067       Creative Live! Cam Video IM (VF0350)
 ov519           041e:4068       Creative Live! VISTA VF0470
 spca561         0458:7004       Genius VideoCAM Express V2
+sn9c2028        0458:7005       Genius Smart 300, version 2
 sunplus         0458:7006       Genius Dsc 1.3 Smart
 zc3xx           0458:7007       Genius VideoCam V2
 zc3xx           0458:700c       Genius VideoCam V3
@@ -109,6 +110,7 @@ sunplus		04a5:3003	Benq DC 1300
 sunplus         04a5:3008       Benq DC 1500
 sunplus         04a5:300a       Benq DC 3410
 spca500         04a5:300c       Benq DC 1016
+benq            04a5:3035       Benq DC E300
 finepix         04cb:0104       Fujifilm FinePix 4800
 finepix         04cb:0109       Fujifilm FinePix A202
 finepix         04cb:010b       Fujifilm FinePix A203
@@ -142,6 +144,7 @@ sunplus		04fc:5360	Sunplus Generic
 spca500         04fc:7333       PalmPixDC85
 sunplus         04fc:ffff       Pure DigitalDakota
 spca501         0506:00df       3Com HomeConnect Lite
+sunplus         052b:1507       Megapixel 5 Pretec DC-1007
 sunplus         052b:1513       Megapix V4
 sunplus         052b:1803       MegaImage VI
 tv8532          0545:808b       Veo Stingray
@@ -151,6 +154,7 @@ sunplus		0546:3191	Polaroid Ion 80
 sunplus         0546:3273       Polaroid PDC2030
 ov519           054c:0154       Sonny toy4
 ov519           054c:0155       Sonny toy5
+cpia1           0553:0002       CPIA CPiA (version1) based cameras
 zc3xx           055f:c005       Mustek Wcam300A
 spca500         055f:c200       Mustek Gsmart 300
 sunplus         055f:c211       Kowa Bs888e Microcamera
@@ -188,8 +192,7 @@ spca500		06bd:0404	Agfa CL20
 spca500         06be:0800       Optimedia
 sunplus         06d6:0031       Trust 610 LCD PowerC@m Zoom
 spca506         06e1:a190       ADS Instant VCD
-ov534           06f8:3002       Hercules Blog Webcam
-ov534           06f8:3003       Hercules Dualpix HD Weblog
+ov534_9         06f8:3003       Hercules Dualpix HD Weblog
 sonixj          06f8:3004       Hercules Classic Silver
 sonixj          06f8:3008       Hercules Deluxe Optical Glass
 pac7302         06f8:3009       Hercules Classic Link
@@ -204,6 +207,7 @@ sunplus		0733:2221	Mercury Digital Pro 3.1p
 sunplus         0733:3261       Concord 3045 spca536a
 sunplus         0733:3281       Cyberpix S550V
 spca506         0734:043b       3DeMon USB Capture aka
+cpia1           0813:0001       QX3 camera
 ov519           0813:0002       Dual Mode USB Camera Plus
 spca500         084d:0003       D-Link DSC-350
 spca500         08ca:0103       Aiptek PocketDV
@@ -225,7 +229,8 @@ sunplus		08ca:2050	Medion MD 41437
 sunplus         08ca:2060       Aiptek PocketDV5300
 tv8532          0923:010f       ICM532 cams
 mars            093a:050f       Mars-Semi Pc-Camera
-mr97310a        093a:010f       Sakar Digital no. 77379
+mr97310a        093a:010e       All known CIF cams with this ID
+mr97310a        093a:010f       All known VGA cams with this ID
 pac207          093a:2460       Qtec Webcam 100
 pac207          093a:2461       HP Webcam
 pac207          093a:2463       Philips SPC 220 NC
@@ -302,6 +307,7 @@ sonixj		0c45:613b	Surfer SN-206
 sonixj          0c45:613c       Sonix Pccam168
 sonixj          0c45:6143       Sonix Pccam168
 sonixj          0c45:6148       Digitus DA-70811/ZSMC USB PC Camera ZS211/Microdia
+sonixj          0c45:614a       Frontech E-Ccam (JIL-2225)
 sn9c20x         0c45:6240       PC Camera (SN9C201 + MT9M001)
 sn9c20x         0c45:6242       PC Camera (SN9C201 + MT9M111)
 sn9c20x         0c45:6248       PC Camera (SN9C201 + OV9655)
@@ -324,6 +330,10 @@ sn9c20x		0c45:62b0	PC Camera (SN9C202 + MT9V011/MT9V111/MT9V112)
 sn9c20x         0c45:62b3       PC Camera (SN9C202 + OV9655)
 sn9c20x         0c45:62bb       PC Camera (SN9C202 + OV7660)
 sn9c20x         0c45:62bc       PC Camera (SN9C202 + HV7131R)
+sn9c2028        0c45:8001       Wild Planet Digital Spy Camera
+sn9c2028        0c45:8003       Sakar #11199, #6637x, #67480 keychain cams
+sn9c2028        0c45:8008       Mini-Shotz ms-350
+sn9c2028        0c45:800a       Vivitar Vivicam 3350B
 sunplus         0d64:0303       Sunplus FashionCam DXG
 ov519           0e96:c001       TRUST 380 USB2 SPACEC@M
 etoms           102c:6151       Qcam Sangha CIF
@@ -341,10 +351,11 @@ spca501		1776:501c	Arowana 300K CMOS Camera
 t613            17a1:0128       TASCORP JPEG Webcam, NGS Cyclops
 vc032x          17ef:4802       Lenovo Vc0323+MI1310_SOC
 pac207          2001:f115       D-Link DSB-C120
-sq905c          2770:9050       sq905c
-sq905c          2770:905c       DualCamera
-sq905           2770:9120       Argus Digital Camera DC1512
-sq905c          2770:913d       sq905c
+sq905c          2770:9050       Disney pix micro (CIF)
+sq905c          2770:9052       Disney pix micro 2 (VGA)
+sq905c          2770:905c       All 11 known cameras with this ID
+sq905           2770:9120       All 24 known cameras with this ID
+sq905c          2770:913d       All 4 known cameras with this ID
 spca500         2899:012c       Toptro Industrial
 ov519           8020:ef04       ov519
 spca508         8086:0110       Intel Easy PC Camera
diff --git a/Documentation/video4linux/v4l2-framework.txt b/Documentation/video4linux/v4l2-framework.txt
index 74d677c8b036..5155700c206b 100644
--- a/Documentation/video4linux/v4l2-framework.txt
+++ b/Documentation/video4linux/v4l2-framework.txt
@@ -599,99 +599,13 @@ video_device::minor fields.
 video buffer helper functions
 -----------------------------
 
-The v4l2 core API provides a standard method for dealing with video
-buffers. Those methods allow a driver to implement read(), mmap() and
-overlay() on a consistent way.
-
-There are currently methods for using video buffers on devices that
-supports DMA with scatter/gather method (videobuf-dma-sg), DMA with
-linear access (videobuf-dma-contig), and vmalloced buffers, mostly
-used on USB drivers (videobuf-vmalloc).
-
-Any driver using videobuf should provide operations (callbacks) for
-four handlers:
-
-ops->buf_setup   - calculates the size of the video buffers and avoid they
-                   to waste more than some maximum limit of RAM;
-ops->buf_prepare - fills the video buffer structs and calls
-                   videobuf_iolock() to alloc and prepare mmaped memory;
-ops->buf_queue   - advices the driver that another buffer were
-                   requested (by read() or by QBUF);
-ops->buf_release - frees any buffer that were allocated.
-
-In order to use it, the driver need to have a code (generally called at
-interrupt context) that will properly handle the buffer request lists,
-announcing that a new buffer were filled.
-
-The irq handling code should handle the videobuf task lists, in order
-to advice videobuf that a new frame were filled, in order to honor to a
-request. The code is generally like this one:
-        if (list_empty(&dma_q->active))
-                return;
-
-        buf = list_entry(dma_q->active.next, struct vbuffer, vb.queue);
-
-        if (!waitqueue_active(&buf->vb.done))
-                return;
-
-        /* Some logic to handle the buf may be needed here */
-
-        list_del(&buf->vb.queue);
-        do_gettimeofday(&buf->vb.ts);
-        wake_up(&buf->vb.done);
-
-Those are the videobuffer functions used on drivers, implemented on
-videobuf-core:
-
-- Videobuf init functions
-  videobuf_queue_sg_init()
-      Initializes the videobuf infrastructure. This function should be
-      called before any other videobuf function on drivers that uses DMA
-      Scatter/Gather buffers.
-
-  videobuf_queue_dma_contig_init
-      Initializes the videobuf infrastructure. This function should be
-      called before any other videobuf function on drivers that need DMA
-      contiguous buffers.
-
-  videobuf_queue_vmalloc_init()
-      Initializes the videobuf infrastructure. This function should be
-      called before any other videobuf function on USB (and other drivers)
-      that need a vmalloced type of videobuf.
-
-- videobuf_iolock()
-  Prepares the videobuf memory for the proper method (read, mmap, overlay).
-
-- videobuf_queue_is_busy()
-  Checks if a videobuf is streaming.
-
-- videobuf_queue_cancel()
-  Stops video handling.
-
-- videobuf_mmap_free()
-  frees mmap buffers.
-
-- videobuf_stop()
-  Stops video handling, ends mmap and frees mmap and other buffers.
-
-- V4L2 api functions. Those functions correspond to VIDIOC_foo ioctls:
-   videobuf_reqbufs(), videobuf_querybuf(), videobuf_qbuf(),
-   videobuf_dqbuf(), videobuf_streamon(), videobuf_streamoff().
-
-- V4L1 api function (corresponds to VIDIOCMBUF ioctl):
-   videobuf_cgmbuf()
-      This function is used to provide backward compatibility with V4L1
-      API.
-
-- Some help functions for read()/poll() operations:
-   videobuf_read_stream()
-      For continuous stream read()
-   videobuf_read_one()
-      For snapshot read()
-   videobuf_poll_stream()
-      polling help function
-
-The better way to understand it is to take a look at vivi driver. One
-of the main reasons for vivi is to be a videobuf usage example. the
-vivi_thread_tick() does the task that the IRQ callback would do on PCI
-drivers (or the irq callback on USB).
+The v4l2 core API provides a set of standard methods (called "videobuf")
+for dealing with video buffers. Those methods allow a driver to implement
+read(), mmap() and overlay() in a consistent way.  There are currently
+methods for using video buffers on devices that supports DMA with
+scatter/gather method (videobuf-dma-sg), DMA with linear access
+(videobuf-dma-contig), and vmalloced buffers, mostly used on USB drivers
+(videobuf-vmalloc).
+
+Please see Documentation/video4linux/videobuf for more information on how
+to use the videobuf layer.
diff --git a/Documentation/video4linux/videobuf b/Documentation/video4linux/videobuf
new file mode 100644
index 000000000000..17a1f9abf260
--- /dev/null
+++ b/Documentation/video4linux/videobuf
@@ -0,0 +1,360 @@
+An introduction to the videobuf layer
+Jonathan Corbet <corbet@lwn.net>
+Current as of 2.6.33
+
+The videobuf layer functions as a sort of glue layer between a V4L2 driver
+and user space.  It handles the allocation and management of buffers for
+the storage of video frames.  There is a set of functions which can be used
+to implement many of the standard POSIX I/O system calls, including read(),
+poll(), and, happily, mmap().  Another set of functions can be used to
+implement the bulk of the V4L2 ioctl() calls related to streaming I/O,
+including buffer allocation, queueing and dequeueing, and streaming
+control.  Using videobuf imposes a few design decisions on the driver
+author, but the payback comes in the form of reduced code in the driver and
+a consistent implementation of the V4L2 user-space API.
+
+Buffer types
+
+Not all video devices use the same kind of buffers.  In fact, there are (at
+least) three common variations:
+
+ - Buffers which are scattered in both the physical and (kernel) virtual
+   address spaces.  (Almost) all user-space buffers are like this, but it
+   makes great sense to allocate kernel-space buffers this way as well when
+   it is possible.  Unfortunately, it is not always possible; working with
+   this kind of buffer normally requires hardware which can do
+   scatter/gather DMA operations.
+
+ - Buffers which are physically scattered, but which are virtually
+   contiguous; buffers allocated with vmalloc(), in other words.  These
+   buffers are just as hard to use for DMA operations, but they can be
+   useful in situations where DMA is not available but virtually-contiguous
+   buffers are convenient.
+
+ - Buffers which are physically contiguous.  Allocation of this kind of
+   buffer can be unreliable on fragmented systems, but simpler DMA
+   controllers cannot deal with anything else.
+
+Videobuf can work with all three types of buffers, but the driver author
+must pick one at the outset and design the driver around that decision.
+
+[It's worth noting that there's a fourth kind of buffer: "overlay" buffers
+which are located within the system's video memory.  The overlay
+functionality is considered to be deprecated for most use, but it still
+shows up occasionally in system-on-chip drivers where the performance
+benefits merit the use of this technique.  Overlay buffers can be handled
+as a form of scattered buffer, but there are very few implementations in
+the kernel and a description of this technique is currently beyond the
+scope of this document.]
+
+Data structures, callbacks, and initialization
+
+Depending on which type of buffers are being used, the driver should
+include one of the following files:
+
+    <media/videobuf-dma-sg.h>           /* Physically scattered */
+    <media/videobuf-vmalloc.h>          /* vmalloc() buffers    */
+    <media/videobuf-dma-contig.h>       /* Physically contiguous */
+
+The driver's data structure describing a V4L2 device should include a
+struct videobuf_queue instance for the management of the buffer queue,
+along with a list_head for the queue of available buffers.  There will also
+need to be an interrupt-safe spinlock which is used to protect (at least)
+the queue.
+
+The next step is to write four simple callbacks to help videobuf deal with
+the management of buffers:
+
+    struct videobuf_queue_ops {
+        int (*buf_setup)(struct videobuf_queue *q,
+                         unsigned int *count, unsigned int *size);
+        int (*buf_prepare)(struct videobuf_queue *q,
+                           struct videobuf_buffer *vb,
+                           enum v4l2_field field);
+        void (*buf_queue)(struct videobuf_queue *q,
+                          struct videobuf_buffer *vb);
+        void (*buf_release)(struct videobuf_queue *q,
+                            struct videobuf_buffer *vb);
+    };
+
+buf_setup() is called early in the I/O process, when streaming is being
+initiated; its purpose is to tell videobuf about the I/O stream.  The count
+parameter will be a suggested number of buffers to use; the driver should
+check it for rationality and adjust it if need be.  As a practical rule, a
+minimum of two buffers are needed for proper streaming, and there is
+usually a maximum (which cannot exceed 32) which makes sense for each
+device.  The size parameter should be set to the expected (maximum) size
+for each frame of data.
+
+Each buffer (in the form of a struct videobuf_buffer pointer) will be
+passed to buf_prepare(), which should set the buffer's size, width, height,
+and field fields properly.  If the buffer's state field is
+VIDEOBUF_NEEDS_INIT, the driver should pass it to:
+
+    int videobuf_iolock(struct videobuf_queue* q, struct videobuf_buffer *vb,
+                        struct v4l2_framebuffer *fbuf);
+
+Among other things, this call will usually allocate memory for the buffer.
+Finally, the buf_prepare() function should set the buffer's state to
+VIDEOBUF_PREPARED.
+
+When a buffer is queued for I/O, it is passed to buf_queue(), which should
+put it onto the driver's list of available buffers and set its state to
+VIDEOBUF_QUEUED.  Note that this function is called with the queue spinlock
+held; if it tries to acquire it as well things will come to a screeching
+halt.  Yes, this is the voice of experience.  Note also that videobuf may
+wait on the first buffer in the queue; placing other buffers in front of it
+could again gum up the works.  So use list_add_tail() to enqueue buffers.
+
+Finally, buf_release() is called when a buffer is no longer intended to be
+used.  The driver should ensure that there is no I/O active on the buffer,
+then pass it to the appropriate free routine(s):
+
+    /* Scatter/gather drivers */
+    int videobuf_dma_unmap(struct videobuf_queue *q,
+                           struct videobuf_dmabuf *dma);
+    int videobuf_dma_free(struct videobuf_dmabuf *dma);
+
+    /* vmalloc drivers */
+    void videobuf_vmalloc_free (struct videobuf_buffer *buf);
+
+    /* Contiguous drivers */
+    void videobuf_dma_contig_free(struct videobuf_queue *q,
+                                  struct videobuf_buffer *buf);
+
+One way to ensure that a buffer is no longer under I/O is to pass it to:
+
+    int videobuf_waiton(struct videobuf_buffer *vb, int non_blocking, int intr);
+
+Here, vb is the buffer, non_blocking indicates whether non-blocking I/O
+should be used (it should be zero in the buf_release() case), and intr
+controls whether an interruptible wait is used.
+
+File operations
+
+At this point, much of the work is done; much of the rest is slipping
+videobuf calls into the implementation of the other driver callbacks.  The
+first step is in the open() function, which must initialize the
+videobuf queue.  The function to use depends on the type of buffer used:
+
+    void videobuf_queue_sg_init(struct videobuf_queue *q,
+                                struct videobuf_queue_ops *ops,
+                                struct device *dev,
+                                spinlock_t *irqlock,
+                                enum v4l2_buf_type type,
+                                enum v4l2_field field,
+                                unsigned int msize,
+                                void *priv);
+
+    void videobuf_queue_vmalloc_init(struct videobuf_queue *q,
+                                struct videobuf_queue_ops *ops,
+                                struct device *dev,
+                                spinlock_t *irqlock,
+                                enum v4l2_buf_type type,
+                                enum v4l2_field field,
+                                unsigned int msize,
+                                void *priv);
+
+    void videobuf_queue_dma_contig_init(struct videobuf_queue *q,
+                                       struct videobuf_queue_ops *ops,
+                                       struct device *dev,
+                                       spinlock_t *irqlock,
+                                       enum v4l2_buf_type type,
+                                       enum v4l2_field field,
+                                       unsigned int msize,
+                                       void *priv);
+
+In each case, the parameters are the same: q is the queue structure for the
+device, ops is the set of callbacks as described above, dev is the device
+structure for this video device, irqlock is an interrupt-safe spinlock to
+protect access to the data structures, type is the buffer type used by the
+device (cameras will use V4L2_BUF_TYPE_VIDEO_CAPTURE, for example), field
+describes which field is being captured (often V4L2_FIELD_NONE for
+progressive devices), msize is the size of any containing structure used
+around struct videobuf_buffer, and priv is a private data pointer which
+shows up in the priv_data field of struct videobuf_queue.  Note that these
+are void functions which, evidently, are immune to failure.
+
+V4L2 capture drivers can be written to support either of two APIs: the
+read() system call and the rather more complicated streaming mechanism.  As
+a general rule, it is necessary to support both to ensure that all
+applications have a chance of working with the device.  Videobuf makes it
+easy to do that with the same code.  To implement read(), the driver need
+only make a call to one of:
+
+    ssize_t videobuf_read_one(struct videobuf_queue *q,
+                              char __user *data, size_t count,
+                              loff_t *ppos, int nonblocking);
+
+    ssize_t videobuf_read_stream(struct videobuf_queue *q,
+                                 char __user *data, size_t count,
+                                 loff_t *ppos, int vbihack, int nonblocking);
+
+Either one of these functions will read frame data into data, returning the
+amount actually read; the difference is that videobuf_read_one() will only
+read a single frame, while videobuf_read_stream() will read multiple frames
+if they are needed to satisfy the count requested by the application.  A
+typical driver read() implementation will start the capture engine, call
+one of the above functions, then stop the engine before returning (though a
+smarter implementation might leave the engine running for a little while in
+anticipation of another read() call happening in the near future).
+
+The poll() function can usually be implemented with a direct call to:
+
+    unsigned int videobuf_poll_stream(struct file *file,
+                                      struct videobuf_queue *q,
+                                      poll_table *wait);
+
+Note that the actual wait queue eventually used will be the one associated
+with the first available buffer.
+
+When streaming I/O is done to kernel-space buffers, the driver must support
+the mmap() system call to enable user space to access the data.  In many
+V4L2 drivers, the often-complex mmap() implementation simplifies to a
+single call to:
+
+    int videobuf_mmap_mapper(struct videobuf_queue *q,
+                             struct vm_area_struct *vma);
+
+Everything else is handled by the videobuf code.
+
+The release() function requires two separate videobuf calls:
+
+    void videobuf_stop(struct videobuf_queue *q);
+    int videobuf_mmap_free(struct videobuf_queue *q);
+
+The call to videobuf_stop() terminates any I/O in progress - though it is
+still up to the driver to stop the capture engine.  The call to
+videobuf_mmap_free() will ensure that all buffers have been unmapped; if
+so, they will all be passed to the buf_release() callback.  If buffers
+remain mapped, videobuf_mmap_free() returns an error code instead.  The
+purpose is clearly to cause the closing of the file descriptor to fail if
+buffers are still mapped, but every driver in the 2.6.32 kernel cheerfully
+ignores its return value.
+
+ioctl() operations
+
+The V4L2 API includes a very long list of driver callbacks to respond to
+the many ioctl() commands made available to user space.  A number of these
+- those associated with streaming I/O - turn almost directly into videobuf
+calls.  The relevant helper functions are:
+
+    int videobuf_reqbufs(struct videobuf_queue *q,
+                         struct v4l2_requestbuffers *req);
+    int videobuf_querybuf(struct videobuf_queue *q, struct v4l2_buffer *b);
+    int videobuf_qbuf(struct videobuf_queue *q, struct v4l2_buffer *b);
+    int videobuf_dqbuf(struct videobuf_queue *q, struct v4l2_buffer *b,
+                       int nonblocking);
+    int videobuf_streamon(struct videobuf_queue *q);
+    int videobuf_streamoff(struct videobuf_queue *q);
+    int videobuf_cgmbuf(struct videobuf_queue *q, struct video_mbuf *mbuf,
+                        int count);
+
+So, for example, a VIDIOC_REQBUFS call turns into a call to the driver's
+vidioc_reqbufs() callback which, in turn, usually only needs to locate the
+proper struct videobuf_queue pointer and pass it to videobuf_reqbufs().
+These support functions can replace a great deal of buffer management
+boilerplate in a lot of V4L2 drivers.
+
+The vidioc_streamon() and vidioc_streamoff() functions will be a bit more
+complex, of course, since they will also need to deal with starting and
+stopping the capture engine.  videobuf_cgmbuf(), called from the driver's
+vidiocgmbuf() function, only exists if the V4L1 compatibility module has
+been selected with CONFIG_VIDEO_V4L1_COMPAT, so its use must be surrounded
+with #ifdef directives.
+
+Buffer allocation
+
+Thus far, we have talked about buffers, but have not looked at how they are
+allocated.  The scatter/gather case is the most complex on this front.  For
+allocation, the driver can leave buffer allocation entirely up to the
+videobuf layer; in this case, buffers will be allocated as anonymous
+user-space pages and will be very scattered indeed.  If the application is
+using user-space buffers, no allocation is needed; the videobuf layer will
+take care of calling get_user_pages() and filling in the scatterlist array.
+
+If the driver needs to do its own memory allocation, it should be done in
+the vidioc_reqbufs() function, *after* calling videobuf_reqbufs().  The
+first step is a call to:
+
+    struct videobuf_dmabuf *videobuf_to_dma(struct videobuf_buffer *buf);
+
+The returned videobuf_dmabuf structure (defined in
+<media/videobuf-dma-sg.h>) includes a couple of relevant fields:
+
+    struct scatterlist  *sglist;
+    int                 sglen;
+
+The driver must allocate an appropriately-sized scatterlist array and
+populate it with pointers to the pieces of the allocated buffer; sglen
+should be set to the length of the array.
+
+Drivers using the vmalloc() method need not (and cannot) concern themselves
+with buffer allocation at all; videobuf will handle those details.  The
+same is normally true of contiguous-DMA drivers as well; videobuf will
+allocate the buffers (with dma_alloc_coherent()) when it sees fit.  That
+means that these drivers may be trying to do high-order allocations at any
+time, an operation which is not always guaranteed to work.  Some drivers
+play tricks by allocating DMA space at system boot time; videobuf does not
+currently play well with those drivers.
+
+As of 2.6.31, contiguous-DMA drivers can work with a user-supplied buffer,
+as long as that buffer is physically contiguous.  Normal user-space
+allocations will not meet that criterion, but buffers obtained from other
+kernel drivers, or those contained within huge pages, will work with these
+drivers.
+
+Filling the buffers
+
+The final part of a videobuf implementation has no direct callback - it's
+the portion of the code which actually puts frame data into the buffers,
+usually in response to interrupts from the device.  For all types of
+drivers, this process works approximately as follows:
+
+ - Obtain the next available buffer and make sure that somebody is actually
+   waiting for it.
+
+ - Get a pointer to the memory and put video data there.
+
+ - Mark the buffer as done and wake up the process waiting for it.
+
+Step (1) above is done by looking at the driver-managed list_head structure
+- the one which is filled in the buf_queue() callback.  Because starting
+the engine and enqueueing buffers are done in separate steps, it's possible
+for the engine to be running without any buffers available - in the
+vmalloc() case especially.  So the driver should be prepared for the list
+to be empty.  It is equally possible that nobody is yet interested in the
+buffer; the driver should not remove it from the list or fill it until a
+process is waiting on it.  That test can be done by examining the buffer's
+done field (a wait_queue_head_t structure) with waitqueue_active().
+
+A buffer's state should be set to VIDEOBUF_ACTIVE before being mapped for
+DMA; that ensures that the videobuf layer will not try to do anything with
+it while the device is transferring data.
+
+For scatter/gather drivers, the needed memory pointers will be found in the
+scatterlist structure described above.  Drivers using the vmalloc() method
+can get a memory pointer with:
+
+    void *videobuf_to_vmalloc(struct videobuf_buffer *buf);
+
+For contiguous DMA drivers, the function to use is:
+
+    dma_addr_t videobuf_to_dma_contig(struct videobuf_buffer *buf);
+
+The contiguous DMA API goes out of its way to hide the kernel-space address
+of the DMA buffer from drivers.
+
+The final step is to set the size field of the relevant videobuf_buffer
+structure to the actual size of the captured image, set state to
+VIDEOBUF_DONE, then call wake_up() on the done queue.  At this point, the
+buffer is owned by the videobuf layer and the driver should not touch it
+again.
+
+Developers who are interested in more information can go into the relevant
+header files; there are a few low-level functions declared there which have
+not been talked about here.  Also worthwhile is the vivi driver
+(drivers/media/video/vivi.c), which is maintained as an example of how V4L2
+drivers should be written.  Vivi only uses the vmalloc() API, but it's good
+enough to get started with.  Note also that all of these calls are exported
+GPL-only, so they will not be available to non-GPL kernel modules.
diff --git a/Documentation/x86/x86_64/boot-options.txt b/Documentation/x86/x86_64/boot-options.txt
index 29a6ff8bc7d3..7fbbaf85f5b7 100644
--- a/Documentation/x86/x86_64/boot-options.txt
+++ b/Documentation/x86/x86_64/boot-options.txt
@@ -166,19 +166,13 @@ NUMA
 
   numa=noacpi   Don't parse the SRAT table for NUMA setup
 
-  numa=fake=CMDLINE
-                If a number, fakes CMDLINE nodes and ignores NUMA setup of the
-                actual machine.  Otherwise, system memory is configured
-                depending on the sizes and coefficients listed.  For example:
-                        numa=fake=2*512,1024,4*256,*128
-                gives two 512M nodes, a 1024M node, four 256M nodes, and the
-                rest split into 128M chunks.  If the last character of CMDLINE
-                is a *, the remaining memory is divided up equally among its
-                coefficient:
-                        numa=fake=2*512,2*
-                gives two 512M nodes and the rest split into two nodes.
-                Otherwise, the remaining system RAM is allocated to an
-                additional node.
+  numa=fake=<size>[MG]
+                If given as a memory unit, fills all system RAM with nodes of
+                size interleaved over physical nodes.
+
+  numa=fake=<N>
+                If given as an integer, fills all system RAM with N fake nodes
+                interleaved over physical nodes.
 
 ACPI