28 files changed, 1961 insertions, 496 deletions
diff --git a/Documentation/Changes b/Documentation/Changes
index 783ddc3ce4e8..86b86399d61d 100644
--- a/Documentation/Changes
+++ b/Documentation/Changes
@@ -139,9 +139,14 @@ You'll probably want to upgrade.
 Ksymoops
 --------
-If the unthinkable happens and your kernel oopses, you'll need a 2.4
+If the unthinkable happens and your kernel oopses, you may need the
-version of ksymoops to decode the report; see REPORTING-BUGS in the
+ksymoops tool to decode it, but in most cases you don't.
-root of the Linux source for more information.
+In the 2.6 kernel it is generally preferred to build the kernel with
+CONFIG_KALLSYMS so that it produces readable dumps that can be used as-is
+(this also produces better output than ksymoops).
+If for some reason your kernel is not build with CONFIG_KALLSYMS and
+you have no way to rebuild and reproduce the Oops with that option, then
+you can still decode that Oops with ksymoops.
 Module-Init-Tools
 -----------------
diff --git a/Documentation/DocBook/Makefile b/Documentation/DocBook/Makefile
index fa3e29ad8a46..7018f5c6a447 100644
--- a/Documentation/DocBook/Makefile
+++ b/Documentation/DocBook/Makefile
@@ -10,7 +10,7 @@ DOCBOOKS := wanbook.xml z8530book.xml mcabook.xml videobook.xml \
            kernel-hacking.xml kernel-locking.xml deviceiobook.xml \
            procfs-guide.xml writing_usb_driver.xml \
            sis900.xml kernel-api.xml journal-api.xml lsm.xml usb.xml \
-            gadget.xml libata.xml mtdnand.xml librs.xml
+            gadget.xml libata.xml mtdnand.xml librs.xml rapidio.xml
 ###
 # The build process is as follows (targets):
diff --git a/Documentation/DocBook/journal-api.tmpl b/Documentation/DocBook/journal-api.tmpl
index 341aaa4ce481..2077f9a28c19 100644
--- a/Documentation/DocBook/journal-api.tmpl
+++ b/Documentation/DocBook/journal-api.tmpl
@@ -306,7 +306,7 @@ an example.
 </para>
        <sect1><title>Journal Level</title>
 !Efs/jbd/journal.c
-!Efs/jbd/recovery.c
+!Ifs/jbd/recovery.c
        </sect1>
        <sect1><title>Transasction Level</title>
 !Efs/jbd/transaction.c  
diff --git a/Documentation/DocBook/kernel-api.tmpl b/Documentation/DocBook/kernel-api.tmpl
index ec474e5a25ed..a8316b1a3e3d 100644
--- a/Documentation/DocBook/kernel-api.tmpl
+++ b/Documentation/DocBook/kernel-api.tmpl
@@ -118,7 +118,7 @@ X!Ilib/string.c
     </sect1>
     <sect1><title>User Space Memory Access</title>
 !Iinclude/asm-i386/uaccess.h
-!Iarch/i386/lib/usercopy.c
+!Earch/i386/lib/usercopy.c
     </sect1>
     <sect1><title>More Memory Management Functions</title>
 !Iinclude/linux/rmap.h
@@ -174,7 +174,6 @@ X!Ilib/string.c
     <title>The Linux VFS</title>
     <sect1><title>The Filesystem types</title>
 !Iinclude/linux/fs.h
-!Einclude/linux/fs.h
     </sect1>
     <sect1><title>The Directory Cache</title>
 !Efs/dcache.c
@@ -266,7 +265,7 @@ X!Ekernel/module.c
  <chapter id="hardware">
     <title>Hardware Interfaces</title>
     <sect1><title>Interrupt Handling</title>
-!Ikernel/irq/manage.c
+!Ekernel/irq/manage.c
     </sect1>
     <sect1><title>Resources Management</title>
@@ -501,7 +500,7 @@ KAO -->
 !Edrivers/video/modedb.c
     </sect1>
     <sect1><title>Frame Buffer Macintosh Video Mode Database</title>
-!Idrivers/video/macmodes.c
+!Edrivers/video/macmodes.c
     </sect1>
     <sect1><title>Frame Buffer Fonts</title>
        <para>
diff --git a/Documentation/DocBook/rapidio.tmpl b/Documentation/DocBook/rapidio.tmpl
new file mode 100644
index 000000000000..1becf27ba27e
--- /dev/null
+++ b/Documentation/DocBook/rapidio.tmpl
@@ -0,0 +1,160 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
+        "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
+        <!ENTITY rapidio SYSTEM "rapidio.xml">
+        ]>
+<book id="RapidIO-Guide">
+ <bookinfo>
+  <title>RapidIO Subsystem Guide</title>
+  <authorgroup>
+   <author>
+    <firstname>Matt</firstname>
+    <surname>Porter</surname>
+    <affiliation>
+     <address>
+      <email>mporter@kernel.crashing.org</email>
+      <email>mporter@mvista.com</email>
+     </address>
+    </affiliation>
+   </author>
+  </authorgroup>
+  <copyright>
+   <year>2005</year>
+   <holder>MontaVista Software, Inc.</holder>
+  </copyright>
+  <legalnotice>
+   <para>
+     This documentation is free software; you can redistribute
+     it and/or modify it under the terms of the GNU General Public
+     License version 2 as published by the Free Software Foundation.
+   </para>
+   <para>
+     This program is distributed in the hope that it will be
+     useful, but WITHOUT ANY WARRANTY; without even the implied
+     warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+     See the GNU General Public License for more details.
+   </para>
+   <para>
+     You should have received a copy of the GNU General Public
+     License along with this program; if not, write to the Free
+     Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+     MA 02111-1307 USA
+   </para>
+   <para>
+     For more details see the file COPYING in the source
+     distribution of Linux.
+   </para>
+  </legalnotice>
+ </bookinfo>
+<toc></toc>
+  <chapter id="intro">
+      <title>Introduction</title>
+  <para>
+        RapidIO is a high speed switched fabric interconnect with
+        features aimed at the embedded market.  RapidIO provides
+        support for memory-mapped I/O as well as message-based
+        transactions over the switched fabric network. RapidIO has
+        a standardized discovery mechanism not unlike the PCI bus
+        standard that allows simple detection of devices in a
+        network.
+  </para>
+  <para>
+        This documentation is provided for developers intending
+        to support RapidIO on new architectures, write new drivers,
+        or to understand the subsystem internals.
+  </para>
+  </chapter>
+  <chapter id="bugs">
+     <title>Known Bugs and Limitations</title>
+     <sect1>
+        <title>Bugs</title>
+          <para>None. ;)</para>
+     </sect1>
+     <sect1>
+        <title>Limitations</title>
+          <para>
+            <orderedlist>
+              <listitem><para>Access/management of RapidIO memory regions is not supported</para></listitem>
+              <listitem><para>Multiple host enumeration is not supported</para></listitem>
+            </orderedlist>
+         </para>
+     </sect1>
+  </chapter>
+  <chapter id="drivers">
+        <title>RapidIO driver interface</title>
+        <para>
+                Drivers are provided a set of calls in order
+                to interface with the subsystem to gather info
+                on devices, request/map memory region resources,
+                and manage mailboxes/doorbells.
+        </para>
+        <sect1>
+                <title>Functions</title>
+!Iinclude/linux/rio_drv.h
+!Edrivers/rapidio/rio-driver.c
+!Edrivers/rapidio/rio.c
+        </sect1>
+  </chapter>
+  <chapter id="internals">
+     <title>Internals</title>
+     <para>
+     This chapter contains the autogenerated documentation of the RapidIO
+     subsystem.
+     </para>
+     <sect1><title>Structures</title>
+!Iinclude/linux/rio.h
+     </sect1>
+     <sect1><title>Enumeration and Discovery</title>
+!Idrivers/rapidio/rio-scan.c
+     </sect1>
+     <sect1><title>Driver functionality</title>
+!Idrivers/rapidio/rio.c
+!Idrivers/rapidio/rio-access.c
+     </sect1>
+     <sect1><title>Device model support</title>
+!Idrivers/rapidio/rio-driver.c
+     </sect1>
+     <sect1><title>Sysfs support</title>
+!Idrivers/rapidio/rio-sysfs.c
+     </sect1>
+     <sect1><title>PPC32 support</title>
+!Iarch/ppc/kernel/rio.c
+!Earch/ppc/syslib/ppc85xx_rio.c
+!Iarch/ppc/syslib/ppc85xx_rio.c
+     </sect1>
+  </chapter>
+  <chapter id="credits">
+     <title>Credits</title>
+        <para>
+                The following people have contributed to the RapidIO
+                subsystem directly or indirectly:
+                <orderedlist>
+                        <listitem><para>Matt Porter<email>mporter@kernel.crashing.org</email></para></listitem>
+                        <listitem><para>Randy Vinson<email>rvinson@mvista.com</email></para></listitem>
+                        <listitem><para>Dan Malek<email>dan@embeddedalley.com</email></para></listitem>
+                </orderedlist>
+        </para>
+        <para>
+                The following people have contributed to this document:
+                <orderedlist>
+                        <listitem><para>Matt Porter<email>mporter@kernel.crashing.org</email></para></listitem>
+                </orderedlist>
+        </para>
+  </chapter>
+</book>
diff --git a/Documentation/MSI-HOWTO.txt b/Documentation/MSI-HOWTO.txt
index 63edc5f847c4..3ec6c720b016 100644
--- a/Documentation/MSI-HOWTO.txt
+++ b/Documentation/MSI-HOWTO.txt
@@ -10,14 +10,22 @@
 This guide describes the basics of Message Signaled Interrupts (MSI),
 the advantages of using MSI over traditional interrupt mechanisms,
 and how to enable your driver to use MSI or MSI-X. Also included is
-a Frequently Asked Questions.
+a Frequently Asked Questions (FAQ) section.
+1.1 Terminology
+PCI devices can be single-function or multi-function.  In either case,
+when this text talks about enabling or disabling MSI on a "device
+function," it is referring to one specific PCI device and function and
+not to all functions on a PCI device (unless the PCI device has only
+one function).
 2. Copyright 2003 Intel Corporation
 3. What is MSI/MSI-X?
 Message Signaled Interrupt (MSI), as described in the PCI Local Bus
-Specification Revision 2.3 or latest, is an optional feature, and a
+Specification Revision 2.3 or later, is an optional feature, and a
 required feature for PCI Express devices. MSI enables a device function
 to request service by sending an Inbound Memory Write on its PCI bus to
 the FSB as a Message Signal Interrupt transaction. Because MSI is
@@ -27,7 +35,7 @@ supported.
 A PCI device that supports MSI must also support pin IRQ assertion
 interrupt mechanism to provide backward compatibility for systems that
-do not support MSI. In Systems, which support MSI, the bus driver is
+do not support MSI. In systems which support MSI, the bus driver is
 responsible for initializing the message address and message data of
 the device function's MSI/MSI-X capability structure during device
 initial configuration.
@@ -61,17 +69,17 @@ over the MSI capability structure as described below.
        - MSI and MSI-X both support per-vector masking. Per-vector
        masking is an optional extension of MSI but a required
-        feature for MSI-X. Per-vector masking provides the kernel
+        feature for MSI-X. Per-vector masking provides the kernel the
-        the ability to mask/unmask MSI when servicing its software
+        ability to mask/unmask a single MSI while running its
-        interrupt service routing handler. If per-vector masking is
+        interrupt service routine. If per-vector masking is
        not supported, then the device driver should provide the
        hardware/software synchronization to ensure that the device
        generates MSI when the driver wants it to do so.
 4. Why use MSI?
-As a benefit the simplification of board design, MSI allows board
+As a benefit to the simplification of board design, MSI allows board
-designers to remove out of band interrupt routing. MSI is another
+designers to remove out-of-band interrupt routing. MSI is another
 step towards a legacy-free environment.
 Due to increasing pressure on chipset and processor packages to
@@ -87,7 +95,7 @@ support. As a result, the PCI Express technology requires MSI
 support for better interrupt performance.
 Using MSI enables the device functions to support two or more
-vectors, which can be configured to target different CPU's to
+vectors, which can be configured to target different CPUs to
 increase scalability.
 5. Configuring a driver to use MSI/MSI-X
@@ -119,13 +127,13 @@ pci_enable_msi() explicitly.
 int pci_enable_msi(struct pci_dev *dev)
-With this new API, any existing device driver, which like to have
+With this new API, a device driver that wants to have MSI
-MSI enabled on its device function, must call this API to enable MSI
+enabled on its device function must call this API to enable MSI.
 A successful call will initialize the MSI capability structure
 with ONE vector, regardless of whether a device function is
 capable of supporting multiple messages. This vector replaces the
-pre-assigned dev->irq with a new MSI vector. To avoid the conflict
+pre-assigned dev->irq with a new MSI vector. To avoid a conflict
-of new assigned vector with existing pre-assigned vector requires
+of the new assigned vector with existing pre-assigned vector requires
 a device driver to call this API before calling request_irq().
 5.2.2 API pci_disable_msi
@@ -137,14 +145,14 @@ when a device driver is unloading. This API restores dev->irq with
 the pre-assigned IOAPIC vector and switches a device's interrupt
 mode to PCI pin-irq assertion/INTx emulation mode.
-Note that a device driver should always call free_irq() on MSI vector
+Note that a device driver should always call free_irq() on the MSI vector
-it has done request_irq() on before calling this API. Failure to do
+that it has done request_irq() on before calling this API. Failure to do
-so results a BUG_ON() and a device will be left with MSI enabled and
+so results in a BUG_ON() and a device will be left with MSI enabled and
 leaks its vector.
 5.2.3 MSI mode vs. legacy mode diagram
-The below diagram shows the events, which switches the interrupt
+The below diagram shows the events which switch the interrupt
 mode on the MSI-capable device function between MSI mode and
 PIN-IRQ assertion mode.
@@ -155,9 +163,9 @@ PIN-IRQ assertion mode.
         ------------   pci_disable_msi  ------------------------
-Figure 1.0 MSI Mode vs. Legacy Mode
+Figure 1. MSI Mode vs. Legacy Mode
-In Figure 1.0, a device operates by default in legacy mode. Legacy
+In Figure 1, a device operates by default in legacy mode. Legacy
 in this context means PCI pin-irq assertion or PCI-Express INTx
 emulation. A successful MSI request (using pci_enable_msi()) switches
 a device's interrupt mode to MSI mode. A pre-assigned IOAPIC vector
@@ -166,11 +174,11 @@ assigned MSI vector will replace dev->irq.
 To return back to its default mode, a device driver should always call
 pci_disable_msi() to undo the effect of pci_enable_msi(). Note that a
-device driver should always call free_irq() on MSI vector it has done
+device driver should always call free_irq() on the MSI vector it has
-request_irq() on before calling pci_disable_msi(). Failure to do so
+done request_irq() on before calling pci_disable_msi(). Failure to do
-results a BUG_ON() and a device will be left with MSI enabled and
+so results in a BUG_ON() and a device will be left with MSI enabled and
 leaks its vector. Otherwise, the PCI subsystem restores a device's
-dev->irq with a pre-assigned IOAPIC vector and marks released
+dev->irq with a pre-assigned IOAPIC vector and marks the released
 MSI vector as unused.
 Once being marked as unused, there is no guarantee that the PCI
@@ -178,8 +186,8 @@ subsystem will reserve this MSI vector for a device. Depending on
 the availability of current PCI vector resources and the number of
 MSI/MSI-X requests from other drivers, this MSI may be re-assigned.
-For the case where the PCI subsystem re-assigned this MSI vector
+For the case where the PCI subsystem re-assigns this MSI vector to
-another driver, a request to switching back to MSI mode may result
+another driver, a request to switch back to MSI mode may result
 in being assigned a different MSI vector or a failure if no more
 vectors are available.
@@ -208,12 +216,12 @@ Unlike the function pci_enable_msi(), the function pci_enable_msix()
 does not replace the pre-assigned IOAPIC dev->irq with a new MSI
 vector because the PCI subsystem writes the 1:1 vector-to-entry mapping
 into the field vector of each element contained in a second argument.
-Note that the pre-assigned IO-APIC dev->irq is valid only if the device
+Note that the pre-assigned IOAPIC dev->irq is valid only if the device
-operates in PIN-IRQ assertion mode. In MSI-X mode, any attempt of
+operates in PIN-IRQ assertion mode. In MSI-X mode, any attempt at
 using dev->irq by the device driver to request for interrupt service
 may result unpredictabe behavior.
-For each MSI-X vector granted, a device driver is responsible to call
+For each MSI-X vector granted, a device driver is responsible for calling
 other functions like request_irq(), enable_irq(), etc. to enable
 this vector with its corresponding interrupt service handler. It is
 a device driver's choice to assign all vectors with the same
@@ -224,13 +232,13 @@ service handler.
 The PCI 3.0 specification has implementation notes that MMIO address
 space for a device's MSI-X structure should be isolated so that the
-software system can set different page for controlling accesses to
+software system can set different pages for controlling accesses to the
-the MSI-X structure. The implementation of MSI patch requires the PCI
+MSI-X structure. The implementation of MSI support requires the PCI
 subsystem, not a device driver, to maintain full control of the MSI-X
-table/MSI-X PBA and MMIO address space of the MSI-X table/MSI-X PBA.
+table/MSI-X PBA (Pending Bit Array) and MMIO address space of the MSI-X
-A device driver is prohibited from requesting the MMIO address space
+table/MSI-X PBA.  A device driver is prohibited from requesting the MMIO
-of the MSI-X table/MSI-X PBA. Otherwise, the PCI subsystem will fail
+address space of the MSI-X table/MSI-X PBA. Otherwise, the PCI subsystem
-enabling MSI-X on its hardware device when it calls the function
+will fail enabling MSI-X on its hardware device when it calls the function
 pci_enable_msix().
 5.3.2 Handling MSI-X allocation
@@ -274,9 +282,9 @@ For the case where fewer MSI-X vectors are allocated to a function
 than requested, the function pci_enable_msix() will return the
 maximum number of MSI-X vectors available to the caller. A device
 driver may re-send its request with fewer or equal vectors indicated
-in a return. For example, if a device driver requests 5 vectors, but
+in the return. For example, if a device driver requests 5 vectors, but
-the number of available vectors is 3 vectors, a value of 3 will be a
+the number of available vectors is 3 vectors, a value of 3 will be
-return as a result of pci_enable_msix() call. A function could be
+returned as a result of pci_enable_msix() call. A function could be
 designed for its driver to use only 3 MSI-X table entries as
 different combinations as ABC--, A-B-C, A--CB, etc. Note that this
 patch does not support multiple entries with the same vector. Such
@@ -285,49 +293,46 @@ as ABBCC, AABCC, BCCBA, etc will result as a failure by the function
 pci_enable_msix(). Below are the reasons why supporting multiple
 entries with the same vector is an undesirable solution.
-        - The PCI subsystem can not determine which entry, which
+        - The PCI subsystem cannot determine the entry that
-          generated the message, to mask/unmask MSI while handling
+          generated the message to mask/unmask MSI while handling
          software driver ISR. Attempting to walk through all MSI-X
          table entries (2048 max) to mask/unmask any match vector
          is an undesirable solution.
-        - Walk through all MSI-X table entries (2048 max) to handle
+        - Walking through all MSI-X table entries (2048 max) to handle
          SMP affinity of any match vector is an undesirable solution.
 5.3.4 API pci_enable_msix
-int pci_enable_msix(struct pci_dev *dev, u32 *entries, int nvec)
+int pci_enable_msix(struct pci_dev *dev, struct msix_entry *entries, int nvec)
 This API enables a device driver to request the PCI subsystem
-for enabling MSI-X messages on its hardware device. Depending on
+to enable MSI-X messages on its hardware device. Depending on
 the availability of PCI vectors resources, the PCI subsystem enables
-either all or nothing.
+either all or none of the requested vectors.
-Argument dev points to the device (pci_dev) structure.
+Argument 'dev' points to the device (pci_dev) structure.
-Argument entries is a pointer of unsigned integer type. The number of
+Argument 'entries' is a pointer to an array of msix_entry structs.
-elements is indicated in argument nvec. The content of each element
+The number of entries is indicated in argument 'nvec'.
-will be mapped to the following struct defined in /driver/pci/msi.h.
+struct msix_entry is defined in /driver/pci/msi.h:
 struct msix_entry {
        u16     vector; /* kernel uses to write alloc vector */
        u16     entry; /* driver uses to specify entry */
 };
-A device driver is responsible for initializing the field entry of
+A device driver is responsible for initializing the field 'entry' of
-each element with unique entry supported by MSI-X table. Otherwise,
+each element with a unique entry supported by MSI-X table. Otherwise,
 -EINVAL will be returned as a result. A successful return of zero
-indicates the PCI subsystem completes initializing each of requested
+indicates the PCI subsystem completed initializing each of the requested
 entries of the MSI-X table with message address and message data.
 Last but not least, the PCI subsystem will write the 1:1
-vector-to-entry mapping into the field vector of each element. A
+vector-to-entry mapping into the field 'vector' of each element. A
-device driver is responsible of keeping track of allocated MSI-X
+device driver is responsible for keeping track of allocated MSI-X
 vectors in its internal data structure.
-Argument nvec is an integer indicating the number of messages
+A return of zero indicates that the number of MSI-X vectors was
-requested.
-A return of zero indicates that the number of MSI-X vectors is
 successfully allocated. A return of greater than zero indicates
 MSI-X vector shortage. Or a return of less than zero indicates
 a failure. This failure may be a result of duplicate entries
@@ -341,12 +346,12 @@ void pci_disable_msix(struct pci_dev *dev)
 This API should always be used to undo the effect of pci_enable_msix()
 when a device driver is unloading. Note that a device driver should
 always call free_irq() on all MSI-X vectors it has done request_irq()
-on before calling this API. Failure to do so results a BUG_ON() and
+on before calling this API. Failure to do so results in a BUG_ON() and
 a device will be left with MSI-X enabled and leaks its vectors.
 5.3.6 MSI-X mode vs. legacy mode diagram
-The below diagram shows the events, which switches the interrupt
+The below diagram shows the events which switch the interrupt
 mode on the MSI-X capable device function between MSI-X mode and
 PIN-IRQ assertion mode (legacy).
@@ -356,22 +361,22 @@ PIN-IRQ assertion mode (legacy).
        |            | ===============>     |                        |
         ------------   pci_disable_msix     ------------------------
-Figure 2.0 MSI-X Mode vs. Legacy Mode
+Figure 2. MSI-X Mode vs. Legacy Mode
-In Figure 2.0, a device operates by default in legacy mode. A
+In Figure 2, a device operates by default in legacy mode. A
 successful MSI-X request (using pci_enable_msix()) switches a
 device's interrupt mode to MSI-X mode. A pre-assigned IOAPIC vector
 stored in dev->irq will be saved by the PCI subsystem; however,
 unlike MSI mode, the PCI subsystem will not replace dev->irq with
 assigned MSI-X vector because the PCI subsystem already writes the 1:1
-vector-to-entry mapping into the field vector of each element
+vector-to-entry mapping into the field 'vector' of each element
 specified in second argument.
 To return back to its default mode, a device driver should always call
 pci_disable_msix() to undo the effect of pci_enable_msix(). Note that
 a device driver should always call free_irq() on all MSI-X vectors it
 has done request_irq() on before calling pci_disable_msix(). Failure
-to do so results a BUG_ON() and a device will be left with MSI-X
+to do so results in a BUG_ON() and a device will be left with MSI-X
 enabled and leaks its vectors. Otherwise, the PCI subsystem switches a
 device function's interrupt mode from MSI-X mode to legacy mode and
 marks all allocated MSI-X vectors as unused.
@@ -383,53 +388,56 @@ MSI/MSI-X requests from other drivers, these MSI-X vectors may be
 re-assigned.
 For the case where the PCI subsystem re-assigned these MSI-X vectors
-to other driver, a request to switching back to MSI-X mode may result
+to other drivers, a request to switch back to MSI-X mode may result
 being assigned with another set of MSI-X vectors or a failure if no
 more vectors are available.
-5.4 Handling function implementng both MSI and MSI-X capabilities
+5.4 Handling function implementing both MSI and MSI-X capabilities
 For the case where a function implements both MSI and MSI-X
 capabilities, the PCI subsystem enables a device to run either in MSI
 mode or MSI-X mode but not both. A device driver determines whether it
 wants MSI or MSI-X enabled on its hardware device. Once a device
-driver requests for MSI, for example, it is prohibited to request for
+driver requests for MSI, for example, it is prohibited from requesting
 MSI-X; in other words, a device driver is not permitted to ping-pong
 between MSI mod MSI-X mode during a run-time.
 5.5 Hardware requirements for MSI/MSI-X support
 MSI/MSI-X support requires support from both system hardware and
 individual hardware device functions.
 5.5.1 System hardware support
 Since the target of MSI address is the local APIC CPU, enabling
-MSI/MSI-X support in Linux kernel is dependent on whether existing
+MSI/MSI-X support in the Linux kernel is dependent on whether existing
-system hardware supports local APIC. Users should verify their
+system hardware supports local APIC. Users should verify that their
-system whether it runs when CONFIG_X86_LOCAL_APIC=y.
+system supports local APIC operation by testing that it runs when
+CONFIG_X86_LOCAL_APIC=y.
 In SMP environment, CONFIG_X86_LOCAL_APIC is automatically set;
 however, in UP environment, users must manually set
 CONFIG_X86_LOCAL_APIC. Once CONFIG_X86_LOCAL_APIC=y, setting
-CONFIG_PCI_MSI enables the VECTOR based scheme and
+CONFIG_PCI_MSI enables the VECTOR based scheme and the option for
-the option for MSI-capable device drivers to selectively enable
+MSI-capable device drivers to selectively enable MSI/MSI-X.
-MSI/MSI-X.
 Note that CONFIG_X86_IO_APIC setting is irrelevant because MSI/MSI-X
 vector is allocated new during runtime and MSI/MSI-X support does not
 depend on BIOS support. This key independency enables MSI/MSI-X
-support on future IOxAPIC free platform.
+support on future IOxAPIC free platforms.
 5.5.2 Device hardware support
 The hardware device function supports MSI by indicating the
 MSI/MSI-X capability structure on its PCI capability list. By
 default, this capability structure will not be initialized by
 the kernel to enable MSI during the system boot. In other words,
 the device function is running on its default pin assertion mode.
 Note that in many cases the hardware supporting MSI have bugs,
-which may result in system hang. The software driver of specific
+which may result in system hangs. The software driver of specific
-MSI-capable hardware is responsible for whether calling
+MSI-capable hardware is responsible for deciding whether to call
 pci_enable_msi or not. A return of zero indicates the kernel
-successfully initializes the MSI/MSI-X capability structure of the
+successfully initialized the MSI/MSI-X capability structure of the
 device function. The device function is now running on MSI/MSI-X mode.
 5.6 How to tell whether MSI/MSI-X is enabled on device function
@@ -439,10 +447,10 @@ pci_enable_msi()/pci_enable_msix() indicates to a device driver that
 its device function is initialized successfully and ready to run in
 MSI/MSI-X mode.
-At the user level, users can use command 'cat /proc/interrupts'
+At the user level, users can use the command 'cat /proc/interrupts'
-to display the vector allocated for a device and its interrupt
+to display the vectors allocated for devices and their interrupt
-MSI/MSI-X mode ("PCI MSI"/"PCI MSIX"). Below shows below MSI mode is
+MSI/MSI-X modes ("PCI-MSI"/"PCI-MSI-X"). Below shows MSI mode is
-enabled on a SCSI Adaptec 39320D Ultra320.
+enabled on a SCSI Adaptec 39320D Ultra320 controller.
           CPU0       CPU1
  0:     324639          0    IO-APIC-edge  timer
@@ -453,8 +461,8 @@ enabled on a SCSI Adaptec 39320D Ultra320.
 15:          1          0    IO-APIC-edge  ide1
 169:          0          0   IO-APIC-level  uhci-hcd
 185:          0          0   IO-APIC-level  uhci-hcd
-193:        138         10         PCI MSI  aic79xx
+193:        138         10         PCI-MSI  aic79xx
-201:         30          0         PCI MSI  aic79xx
+201:         30          0         PCI-MSI  aic79xx
 225:         30          0   IO-APIC-level  aic7xxx
 233:         30          0   IO-APIC-level  aic7xxx
 NMI:          0          0
@@ -490,8 +498,8 @@ target address set as 0xfeexxxxx, as conformed to PCI
 specification 2.3 or latest, then it should work.
 Q4. From the driver point of view, if the MSI is lost because
-of the errors occur during inbound memory write, then it may
+of errors occurring during inbound memory write, then it may
-wait for ever. Is there a mechanism for it to recover?
+wait forever. Is there a mechanism for it to recover?
 A4. Since the target of the transaction is an inbound memory
 write, all transaction termination conditions (Retry,
diff --git a/Documentation/RCU/whatisRCU.txt b/Documentation/RCU/whatisRCU.txt
index 354d89c78377..15da16861fa3 100644
--- a/Documentation/RCU/whatisRCU.txt
+++ b/Documentation/RCU/whatisRCU.txt
@@ -772,8 +772,6 @@ RCU pointer/list traversal:
        list_for_each_entry_rcu
        list_for_each_continue_rcu      (to be deprecated in favor of new
                                         list_for_each_entry_continue_rcu)
-        hlist_for_each_rcu              (to be deprecated in favor of
-                                         hlist_for_each_entry_rcu)
        hlist_for_each_entry_rcu
 RCU pointer update:
diff --git a/Documentation/arm/README b/Documentation/arm/README
index a6f718e90a86..5ed6f3530b86 100644
--- a/Documentation/arm/README
+++ b/Documentation/arm/README
@@ -8,10 +8,9 @@ Compilation of kernel
 ---------------------
  In order to compile ARM Linux, you will need a compiler capable of
-  generating ARM ELF code with GNU extensions.  GCC 2.95.1, EGCS
+  generating ARM ELF code with GNU extensions.  GCC 3.3 is known to be
-  1.1.2, and GCC 3.3 are known to be good compilers.  Fortunately, you
+  a good compiler.  Fortunately, you needn't guess.  The kernel will report
-  needn't guess.  The kernel will report an error if your compiler is
+  an error if your compiler is a recognized offender.
-  a recognized offender.
  To build ARM Linux natively, you shouldn't have to alter the ARCH = line
  in the top level Makefile.  However, if you don't have the ARM Linux ELF
diff --git a/Documentation/device-mapper/snapshot.txt b/Documentation/device-mapper/snapshot.txt
index dca274ff4005..a5009c8300f3 100644
--- a/Documentation/device-mapper/snapshot.txt
+++ b/Documentation/device-mapper/snapshot.txt
@@ -19,7 +19,6 @@ There are two dm targets available: snapshot and snapshot-origin.
 *) snapshot-origin <origin>
 which will normally have one or more snapshots based on it.
-You must create the snapshot-origin device before you can create snapshots.
 Reads will be mapped directly to the backing device. For each write, the
 original data will be saved in the <COW device> of each snapshot to keep
 its visible content unchanged, at least until the <COW device> fills up.
@@ -27,7 +26,7 @@ its visible content unchanged, at least until the <COW device> fills up.
 *) snapshot <origin> <COW device> <persistent?> <chunksize>
-A snapshot is created of the <origin> block device. Changed chunks of
+A snapshot of the <origin> block device is created. Changed chunks of
 <chunksize> sectors will be stored on the <COW device>.  Writes will
 only go to the <COW device>.  Reads will come from the <COW device> or
 from <origin> for unchanged data.  <COW device> will often be
@@ -37,6 +36,8 @@ the amount of free space and expand the <COW device> before it fills up.
 <persistent?> is P (Persistent) or N (Not persistent - will not survive
 after reboot).
+The difference is that for transient snapshots less metadata must be
+saved on disk - they can be kept in memory by the kernel.
 How this is used by LVM2
diff --git a/Documentation/fb/vesafb.txt b/Documentation/fb/vesafb.txt
index 62db6758d1c1..ee277dd204b0 100644
--- a/Documentation/fb/vesafb.txt
+++ b/Documentation/fb/vesafb.txt
@@ -146,10 +146,10 @@ pmipal	Use the protected mode interface for palette changes.
 mtrr:n  setup memory type range registers for the vesafb framebuffer
        where n:
-              0 - disabled (equivalent to nomtrr)
+              0 - disabled (equivalent to nomtrr) (default)
              1 - uncachable
              2 - write-back
-              3 - write-combining (default)
+              3 - write-combining
              4 - write-through
        If you see the following in dmesg, choose the type that matches the
diff --git a/Documentation/feature-removal-schedule.txt b/Documentation/feature-removal-schedule.txt
index b67189a8d8d4..decdf9917e0d 100644
--- a/Documentation/feature-removal-schedule.txt
+++ b/Documentation/feature-removal-schedule.txt
@@ -69,6 +69,22 @@ Who:	Grant Coady <gcoady@gmail.com>
 ---------------------------
+What:   remove EXPORT_SYMBOL(panic_timeout)
+When:   April 2006
+Files:  kernel/panic.c
+Why:    No modular usage in the kernel.
+Who:    Adrian Bunk <bunk@stusta.de>
+---------------------------
+What:   remove EXPORT_SYMBOL(insert_resource)
+When:   April 2006
+Files:  kernel/resource.c
+Why:    No modular usage in the kernel.
+Who:    Adrian Bunk <bunk@stusta.de>
+---------------------------
 What:   PCMCIA control ioctl (needed for pcmcia-cs [cardmgr, cardctl])
 When:   November 2005
 Files:  drivers/pcmcia/: pcmcia_ioctl.c
diff --git a/Documentation/filesystems/dentry-locking.txt b/Documentation/filesystems/dentry-locking.txt
new file mode 100644
index 000000000000..4c0c575a4012
--- /dev/null
+++ b/Documentation/filesystems/dentry-locking.txt
@@ -0,0 +1,173 @@
+RCU-based dcache locking model
+==============================
+On many workloads, the most common operation on dcache is to look up a
+dentry, given a parent dentry and the name of the child. Typically,
+for every open(), stat() etc., the dentry corresponding to the
+pathname will be looked up by walking the tree starting with the first
+component of the pathname and using that dentry along with the next
+component to look up the next level and so on. Since it is a frequent
+operation for workloads like multiuser environments and web servers,
+it is important to optimize this path.
+Prior to 2.5.10, dcache_lock was acquired in d_lookup and thus in
+every component during path look-up. Since 2.5.10 onwards, fast-walk
+algorithm changed this by holding the dcache_lock at the beginning and
+walking as many cached path component dentries as possible. This
+significantly decreases the number of acquisition of
+dcache_lock. However it also increases the lock hold time
+significantly and affects performance in large SMP machines. Since
+2.5.62 kernel, dcache has been using a new locking model that uses RCU
+to make dcache look-up lock-free.
+The current dcache locking model is not very different from the
+existing dcache locking model. Prior to 2.5.62 kernel, dcache_lock
+protected the hash chain, d_child, d_alias, d_lru lists as well as
+d_inode and several other things like mount look-up. RCU-based changes
+affect only the way the hash chain is protected. For everything else
+the dcache_lock must be taken for both traversing as well as
+updating. The hash chain updates too take the dcache_lock.  The
+significant change is the way d_lookup traverses the hash chain, it
+doesn't acquire the dcache_lock for this and rely on RCU to ensure
+that the dentry has not been *freed*.
+Dcache locking details
+======================
+For many multi-user workloads, open() and stat() on files are very
+frequently occurring operations. Both involve walking of path names to
+find the dentry corresponding to the concerned file. In 2.4 kernel,
+dcache_lock was held during look-up of each path component. Contention
+and cache-line bouncing of this global lock caused significant
+scalability problems. With the introduction of RCU in Linux kernel,
+this was worked around by making the look-up of path components during
+path walking lock-free.
+Safe lock-free look-up of dcache hash table
+===========================================
+Dcache is a complex data structure with the hash table entries also
+linked together in other lists. In 2.4 kernel, dcache_lock protected
+all the lists. We applied RCU only on hash chain walking. The rest of
+the lists are still protected by dcache_lock.  Some of the important
+changes are :
+1. The deletion from hash chain is done using hlist_del_rcu() macro
+   which doesn't initialize next pointer of the deleted dentry and
+   this allows us to walk safely lock-free while a deletion is
+   happening.
+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
+   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
+   while traversing the hash chain. This isn't different from the
+   existing code.
+3. The dentry looked up without holding dcache_lock by cannot be
+   returned for walking if it is unhashed. It then may have a NULL
+   d_inode or other bogosity since RCU doesn't protect the other
+   fields in the dentry. We therefore use a flag DCACHE_UNHASHED to
+   indicate unhashed dentries and use this in conjunction with a
+   per-dentry lock (d_lock). Once looked up without the dcache_lock,
+   we acquire the per-dentry lock (d_lock) and check if the dentry is
+   unhashed. If so, the look-up is failed. If not, the reference count
+   of the dentry is increased and the dentry is returned.
+4. Once a dentry is looked up, it must be ensured during the path walk
+   for that component it doesn't go away. In pre-2.5.10 code, this was
+   done holding a reference to the dentry. dcache_rcu does the same.
+   In some sense, dcache_rcu path walking looks like the pre-2.5.10
+   version.
+5. All dentry hash chain updates must take the dcache_lock as well as
+   the per-dentry lock in that order. dput() does this to ensure that
+   a dentry that has just been looked up in another CPU doesn't get
+   deleted before dget() can be done on it.
+6. There are several ways to do reference counting of RCU protected
+   objects. One such example is in ipv4 route cache where deferred
+   freeing (using call_rcu()) is done as soon as the reference count
+   goes to zero. This cannot be done in the case of dentries because
+   tearing down of dentries require blocking (dentry_iput()) which
+   isn't supported from RCU callbacks. Instead, tearing down of
+   dentries happen synchronously in dput(), but actual freeing happens
+   later when RCU grace period is over. This allows safe lock-free
+   walking of the hash chains, but a matched dentry may have been
+   partially torn down. The checking of DCACHE_UNHASHED flag with
+   d_lock held detects such dentries and prevents them from being
+   returned from look-up.
+Maintaining POSIX rename semantics
+==================================
+Since look-up of dentries is lock-free, it can race against a
+concurrent rename operation. For example, during rename of file A to
+B, look-up of either A or B must succeed.  So, if look-up of B happens
+after A has been removed from the hash chain but not added to the new
+hash chain, it may fail.  Also, a comparison while the name is being
+written concurrently by a rename may result in false positive matches
+violating rename semantics.  Issues related to race with rename are
+handled as described below :
+1. Look-up can be done in two ways - d_lookup() which is safe from
+   simultaneous renames and __d_lookup() which is not.  If
+   __d_lookup() fails, it must be followed up by a d_lookup() to
+   correctly determine whether a dentry is in the hash table or
+   not. d_lookup() protects look-ups using a sequence lock
+   (rename_lock).
+2. The name associated with a dentry (d_name) may be changed if a
+   rename is allowed to happen simultaneously. To avoid memcmp() in
+   __d_lookup() go out of bounds due to a rename and false positive
+   comparison, the name comparison is done while holding the
+   per-dentry lock. This prevents concurrent renames during this
+   operation.
+3. Hash table walking during look-up may move to a different bucket as
+   the current dentry is moved to a different bucket due to rename.
+   But we use hlists in dcache hash table and they are
+   null-terminated.  So, even if a dentry moves to a different bucket,
+   hash chain walk will terminate. [with a list_head list, it may not
+   since termination is when the list_head in the original bucket is
+   reached].  Since we redo the d_parent check and compare name while
+   holding d_lock, lock-free look-up will not race against d_move().
+4. There can be a theoretical race when a dentry keeps coming back to
+   original bucket due to double moves. Due to this look-up may
+   consider that it has never moved and can end up in a infinite loop.
+   But this is not any worse that theoretical livelocks we already
+   have in the kernel.
+Important guidelines for filesystem developers related to dcache_rcu
+====================================================================
+1. Existing dcache interfaces (pre-2.5.62) exported to filesystem
+   don't change. Only dcache internal implementation changes. However
+   filesystems *must not* delete from the dentry hash chains directly
+   using the list macros like allowed earlier. They must use dcache
+   APIs like d_drop() or __d_drop() depending on the situation.
+2. d_flags is now protected by a per-dentry lock (d_lock). All access
+   to d_flags must be protected by it.
+3. For a hashed dentry, checking of d_count needs to be protected by
+   d_lock.
+Papers and other documentation on dcache locking
+================================================
+1. Scaling dcache with RCU (http://linuxjournal.com/article.php?sid=7124).
+2. http://lse.sourceforge.net/locking/dcache/dcache.html
diff --git a/Documentation/filesystems/devfs/README b/Documentation/filesystems/devfs/README
index 54366ecc241f..aabfba24bc2e 100644
--- a/Documentation/filesystems/devfs/README
+++ b/Documentation/filesystems/devfs/README
@@ -1812,11 +1812,6 @@ it may overflow the messages buffer, but try to get as much of it as
 you can
-if you get an Oops, run ksymoops to decode it so that the
-names of the offending functions are provided. A non-decoded Oops is
-pretty useless
 send a copy of your devfsd configuration file(s)
 send the bug report to me first.
diff --git a/Documentation/filesystems/ramfs-rootfs-initramfs.txt b/Documentation/filesystems/ramfs-rootfs-initramfs.txt
new file mode 100644
index 000000000000..b3404a032596
--- /dev/null
+++ b/Documentation/filesystems/ramfs-rootfs-initramfs.txt
@@ -0,0 +1,195 @@
+ramfs, rootfs and initramfs
+October 17, 2005
+Rob Landley <rob@landley.net>
+=============================
+What is ramfs?
+--------------
+Ramfs is a very simple filesystem that exports Linux's disk caching
+mechanisms (the page cache and dentry cache) as a dynamically resizable
+ram-based filesystem.
+Normally all files are cached in memory by Linux.  Pages of data read from
+backing store (usually the block device the filesystem is mounted on) are kept
+around in case it's needed again, but marked as clean (freeable) in case the
+Virtual Memory system needs the memory for something else.  Similarly, data
+written to files is marked clean as soon as it has been written to backing
+store, but kept around for caching purposes until the VM reallocates the
+memory.  A similar mechanism (the dentry cache) greatly speeds up access to
+directories.
+With ramfs, there is no backing store.  Files written into ramfs allocate
+dentries and page cache as usual, but there's nowhere to write them to.
+This means the pages are never marked clean, so they can't be freed by the
+VM when it's looking to recycle memory.
+The amount of code required to implement ramfs is tiny, because all the
+work is done by the existing Linux caching infrastructure.  Basically,
+you're mounting the disk cache as a filesystem.  Because of this, ramfs is not
+an optional component removable via menuconfig, since there would be negligible
+space savings.
+ramfs and ramdisk:
+------------------
+The older "ram disk" mechanism created a synthetic block device out of
+an area of ram and used it as backing store for a filesystem.  This block
+device was of fixed size, so the filesystem mounted on it was of fixed
+size.  Using a ram disk also required unnecessarily copying memory from the
+fake block device into the page cache (and copying changes back out), as well
+as creating and destroying dentries.  Plus it needed a filesystem driver
+(such as ext2) to format and interpret this data.
+Compared to ramfs, this wastes memory (and memory bus bandwidth), creates
+unnecessary work for the CPU, and pollutes the CPU caches.  (There are tricks
+to avoid this copying by playing with the page tables, but they're unpleasantly
+complicated and turn out to be about as expensive as the copying anyway.)
+More to the point, all the work ramfs is doing has to happen _anyway_,
+since all file access goes through the page and dentry caches.  The ram
+disk is simply unnecessary, ramfs is internally much simpler.
+Another reason ramdisks are semi-obsolete is that the introduction of
+loopback devices offered a more flexible and convenient way to create
+synthetic block devices, now from files instead of from chunks of memory.
+See losetup (8) for details.
+ramfs and tmpfs:
+----------------
+One downside of ramfs is you can keep writing data into it until you fill
+up all memory, and the VM can't free it because the VM thinks that files
+should get written to backing store (rather than swap space), but ramfs hasn't
+got any backing store.  Because of this, only root (or a trusted user) should
+be allowed write access to a ramfs mount.
+A ramfs derivative called tmpfs was created to add size limits, and the ability
+to write the data to swap space.  Normal users can be allowed write access to
+tmpfs mounts.  See Documentation/filesystems/tmpfs.txt for more information.
+What is rootfs?
+---------------
+Rootfs is a special instance of ramfs, which is always present in 2.6 systems.
+(It's used internally as the starting and stopping point for searches of the
+kernel's doubly-linked list of mount points.)
+Most systems just mount another filesystem over it and ignore it.  The
+amount of space an empty instance of ramfs takes up is tiny.
+What is initramfs?
+------------------
+All 2.6 Linux kernels contain a gzipped "cpio" format archive, which is
+extracted into rootfs when the kernel boots up.  After extracting, the kernel
+checks to see if rootfs contains a file "init", and if so it executes it as PID
+1.  If found, this init process is responsible for bringing the system the
+rest of the way up, including locating and mounting the real root device (if
+any).  If rootfs does not contain an init program after the embedded cpio
+archive is extracted into it, the kernel will fall through to the older code
+to locate and mount a root partition, then exec some variant of /sbin/init
+out of that.
+All this differs from the old initrd in several ways:
+  - The old initrd was a separate file, while the initramfs archive is linked
+    into the linux kernel image.  (The directory linux-*/usr is devoted to
+    generating this archive during the build.)
+  - The old initrd file was a gzipped filesystem image (in some file format,
+    such as ext2, that had to be built into the kernel), while the new
+    initramfs archive is a gzipped cpio archive (like tar only simpler,
+    see cpio(1) and Documentation/early-userspace/buffer-format.txt).
+  - The program run by the old initrd (which was called /initrd, not /init) did
+    some setup and then returned to the kernel, while the init program from
+    initramfs is not expected to return to the kernel.  (If /init needs to hand
+    off control it can overmount / with a new root device and exec another init
+    program.  See the switch_root utility, below.)
+  - When switching another root device, initrd would pivot_root and then
+    umount the ramdisk.  But initramfs is rootfs: you can neither pivot_root
+    rootfs, nor unmount it.  Instead delete everything out of rootfs to
+    free up the space (find -xdev / -exec rm '{}' ';'), overmount rootfs
+    with the new root (cd /newmount; mount --move . /; chroot .), attach
+    stdin/stdout/stderr to the new /dev/console, and exec the new init.
+    Since this is a remarkably persnickity process (and involves deleting
+    commands before you can run them), the klibc package introduced a helper
+    program (utils/run_init.c) to do all this for you.  Most other packages
+    (such as busybox) have named this command "switch_root".
+Populating initramfs:
+---------------------
+The 2.6 kernel build process always creates a gzipped cpio format initramfs
+archive and links it into the resulting kernel binary.  By default, this
+archive is empty (consuming 134 bytes on x86).  The config option
+CONFIG_INITRAMFS_SOURCE (for some reason buried under devices->block devices
+in menuconfig, and living in usr/Kconfig) can be used to specify a source for
+the initramfs archive, which will automatically be incorporated into the
+resulting binary.  This option can point to an existing gzipped cpio archive, a
+directory containing files to be archived, or a text file specification such
+as the following example:
+  dir /dev 755 0 0
+  nod /dev/console 644 0 0 c 5 1
+  nod /dev/loop0 644 0 0 b 7 0
+  dir /bin 755 1000 1000
+  slink /bin/sh busybox 777 0 0
+  file /bin/busybox initramfs/busybox 755 0 0
+  dir /proc 755 0 0
+  dir /sys 755 0 0
+  dir /mnt 755 0 0
+  file /init initramfs/init.sh 755 0 0
+One advantage of the text file is that root access is not required to
+set permissions or create device nodes in the new archive.  (Note that those
+two example "file" entries expect to find files named "init.sh" and "busybox" in
+a directory called "initramfs", under the linux-2.6.* directory.  See
+Documentation/early-userspace/README for more details.)
+If you don't already understand what shared libraries, devices, and paths
+you need to get a minimal root filesystem up and running, here are some
+references:
+http://www.tldp.org/HOWTO/Bootdisk-HOWTO/
+http://www.tldp.org/HOWTO/From-PowerUp-To-Bash-Prompt-HOWTO.html
+http://www.linuxfromscratch.org/lfs/view/stable/
+The "klibc" package (http://www.kernel.org/pub/linux/libs/klibc) is
+designed to be a tiny C library to statically link early userspace
+code against, along with some related utilities.  It is BSD licensed.
+I use uClibc (http://www.uclibc.org) and busybox (http://www.busybox.net)
+myself.  These are LGPL and GPL, respectively.
+In theory you could use glibc, but that's not well suited for small embedded
+uses like this.  (A "hello world" program statically linked against glibc is
+over 400k.  With uClibc it's 7k.  Also note that glibc dlopens libnss to do
+name lookups, even when otherwise statically linked.)
+Future directions:
+------------------
+Today (2.6.14), initramfs is always compiled in, but not always used.  The
+kernel falls back to legacy boot code that is reached only if initramfs does
+not contain an /init program.  The fallback is legacy code, there to ensure a
+smooth transition and allowing early boot functionality to gradually move to
+"early userspace" (I.E. initramfs).
+The move to early userspace is necessary because finding and mounting the real
+root device is complex.  Root partitions can span multiple devices (raid or
+separate journal).  They can be out on the network (requiring dhcp, setting a
+specific mac address, logging into a server, etc).  They can live on removable
+media, with dynamically allocated major/minor numbers and persistent naming
+issues requiring a full udev implementation to sort out.  They can be
+compressed, encrypted, copy-on-write, loopback mounted, strangely partitioned,
+and so on.
+This kind of complexity (which inevitably includes policy) is rightly handled
+in userspace.  Both klibc and busybox/uClibc are working on simple initramfs
+packages to drop into a kernel build, and when standard solutions are ready
+and widely deployed, the kernel's legacy early boot code will become obsolete
+and a candidate for the feature removal schedule.
+But that's a while off yet.
diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt
index f042c12e0ed2..ee4c0a8b8db7 100644
--- a/Documentation/filesystems/vfs.txt
+++ b/Documentation/filesystems/vfs.txt
@@ -3,7 +3,7 @@
        Original author: Richard Gooch <rgooch@atnf.csiro.au>
-                  Last updated on August 25, 2005
+                  Last updated on October 28, 2005
  Copyright (C) 1999 Richard Gooch
  Copyright (C) 2005 Pekka Enberg
@@ -11,62 +11,61 @@
  This file is released under the GPLv2.
-What is it?
+Introduction
-===========
+============
-The Virtual File System (otherwise known as the Virtual Filesystem
+The Virtual File System (also known as the Virtual Filesystem Switch)
-Switch) is the software layer in the kernel that provides the
+is the software layer in the kernel that provides the filesystem
-filesystem interface to userspace programs. It also provides an
+interface to userspace programs. It also provides an abstraction
-abstraction within the kernel which allows different filesystem
+within the kernel which allows different filesystem implementations to
-implementations to coexist.
+coexist.
+VFS system calls open(2), stat(2), read(2), write(2), chmod(2) and so
+on are called from a process context. Filesystem locking is described
+in the document Documentation/filesystems/Locking.
-A Quick Look At How It Works
-============================
-In this section I'll briefly describe how things work, before
+Directory Entry Cache (dcache)
-launching into the details. I'll start with describing what happens
+------------------------------
-when user programs open and manipulate files, and then look from the
-other view which is how a filesystem is supported and subsequently
-mounted.
-Opening a File
--------------
-The VFS implements the open(2), stat(2), chmod(2) and similar system
-calls. The pathname argument is used by the VFS to search through the
-directory entry cache (dentry cache or "dcache"). This provides a very
-fast look-up mechanism to translate a pathname (filename) into a
-specific dentry.
-An individual dentry usually has a pointer to an inode. Inodes are the
-things that live on disc drives, and can be regular files (you know:
-those things that you write data into), directories, FIFOs and other
-beasts. Dentries live in RAM and are never saved to disc: they exist
-only for performance. Inodes live on disc and are copied into memory
-when required. Later any changes are written back to disc. The inode
-that lives in RAM is a VFS inode, and it is this which the dentry
-points to. A single inode can be pointed to by multiple dentries
-(think about hardlinks).
-The dcache is meant to be a view into your entire filespace. Unlike
-Linus, most of us losers can't fit enough dentries into RAM to cover
-all of our filespace, so the dcache has bits missing. In order to
-resolve your pathname into a dentry, the VFS may have to resort to
-creating dentries along the way, and then loading the inode. This is
-done by looking up the inode.
-To look up an inode (usually read from disc) requires that the VFS
-calls the lookup() method of the parent directory inode. This method
-is installed by the specific filesystem implementation that the inode
-lives in. There will be more on this later.
-Once the VFS has the required dentry (and hence the inode), we can do
+The VFS implements the open(2), stat(2), chmod(2), and similar system
-all those boring things like open(2) the file, or stat(2) it to peek
+calls. The pathname argument that is passed to them is used by the VFS
-at the inode data. The stat(2) operation is fairly simple: once the
+to search through the directory entry cache (also known as the dentry
-VFS has the dentry, it peeks at the inode data and passes some of it
+cache or dcache). This provides a very fast look-up mechanism to
-back to userspace.
+translate a pathname (filename) into a specific dentry. Dentries live
+in RAM and are never saved to disc: they exist only for performance.
+The dentry cache is meant to be a view into your entire filespace. As
+most computers cannot fit all dentries in the RAM at the same time,
+some bits of the cache are missing. In order to resolve your pathname
+into a dentry, the VFS may have to resort to creating dentries along
+the way, and then loading the inode. This is done by looking up the
+inode.
+The Inode Object
+----------------
+An individual dentry usually has a pointer to an inode. Inodes are
+filesystem objects such as regular files, directories, FIFOs and other
+beasts.  They live either on the disc (for block device filesystems)
+or in the memory (for pseudo filesystems). Inodes that live on the
+disc are copied into the memory when required and changes to the inode
+are written back to disc. A single inode can be pointed to by multiple
+dentries (hard links, for example, do this).
+To look up an inode requires that the VFS calls the lookup() method of
+the parent directory inode. This method is installed by the specific
+filesystem implementation that the inode lives in. Once the VFS has
+the required dentry (and hence the inode), we can do all those boring
+things like open(2) the file, or stat(2) it to peek at the inode
+data. The stat(2) operation is fairly simple: once the VFS has the
+dentry, it peeks at the inode data and passes some of it back to
+userspace.
+The File Object
+---------------
 Opening a file requires another operation: allocation of a file
 structure (this is the kernel-side implementation of file
@@ -74,51 +73,39 @@ descriptors). The freshly allocated file structure is initialized with
 a pointer to the dentry and a set of file operation member functions.
 These are taken from the inode data. The open() file method is then
 called so the specific filesystem implementation can do it's work. You
-can see that this is another switch performed by the VFS.
+can see that this is another switch performed by the VFS. The file
+structure is placed into the file descriptor table for the process.
-The file structure is placed into the file descriptor table for the
-process.
 Reading, writing and closing files (and other assorted VFS operations)
 is done by using the userspace file descriptor to grab the appropriate
-file structure, and then calling the required file structure method
+file structure, and then calling the required file structure method to
-function to do whatever is required.
+do whatever is required. For as long as the file is open, it keeps the
+dentry in use, which in turn means that the VFS inode is still in use.
-For as long as the file is open, it keeps the dentry "open" (in use),
-which in turn means that the VFS inode is still in use.
-All VFS system calls (i.e. open(2), stat(2), read(2), write(2),
-chmod(2) and so on) are called from a process context. You should
-assume that these calls are made without any kernel locks being
-held. This means that the processes may be executing the same piece of
-filesystem or driver code at the same time, on different
-processors. You should ensure that access to shared resources is
-protected by appropriate locks.
 Registering and Mounting a Filesystem
-------------------------------------
+=====================================
-If you want to support a new kind of filesystem in the kernel, all you
+To register and unregister a filesystem, use the following API
-need to do is call register_filesystem(). You pass a structure
+functions:
-describing the filesystem implementation (struct file_system_type)
-which is then added to an internal table of supported filesystems. You
-can do:
-% cat /proc/filesystems
+   #include <linux/fs.h>
-to see what filesystems are currently available on your system.
+   extern int register_filesystem(struct file_system_type *);
+   extern int unregister_filesystem(struct file_system_type *);
-When a request is made to mount a block device onto a directory in
+The passed struct file_system_type describes your filesystem. When a
-your filespace the VFS will call the appropriate method for the
+request is made to mount a device onto a directory in your filespace,
-specific filesystem. The dentry for the mount point will then be
+the VFS will call the appropriate get_sb() method for the specific
-updated to point to the root inode for the new filesystem.
+filesystem. The dentry for the mount point will then be updated to
+point to the root inode for the new filesystem.
-It's now time to look at things in more detail.
+You can see all filesystems that are registered to the kernel in the
+file /proc/filesystems.
 struct file_system_type
-=======================
+-----------------------
 This describes the filesystem. As of kernel 2.6.13, the following
 members are defined:
@@ -197,8 +184,14 @@ A fill_super() method implementation has the following arguments:
  int silent: whether or not to be silent on error
+The Superblock Object
+=====================
+A superblock object represents a mounted filesystem.
 struct super_operations
-=======================
+-----------------------
 This describes how the VFS can manipulate the superblock of your
 filesystem. As of kernel 2.6.13, the following members are defined:
@@ -286,9 +279,9 @@ or bottom half).
        a superblock. The second parameter indicates whether the method
        should wait until the write out has been completed. Optional.
-  write_super_lockfs: called when VFS is locking a filesystem and forcing
+  write_super_lockfs: called when VFS is locking a filesystem and
-        it into a consistent state.  This function is currently used by the
+        forcing it into a consistent state.  This method is currently
-        Logical Volume Manager (LVM).
+        used by the Logical Volume Manager (LVM).
  unlockfs: called when VFS is unlocking a filesystem and making it writable
        again.
@@ -317,8 +310,14 @@ field. This is a pointer to a "struct inode_operations" which
 describes the methods that can be performed on individual inodes.
+The Inode Object
+================
+An inode object represents an object within the filesystem.
 struct inode_operations
-=======================
+-----------------------
 This describes how the VFS can manipulate an inode in your
 filesystem. As of kernel 2.6.13, the following members are defined:
@@ -394,51 +393,62 @@ otherwise noted.
        will probably need to call d_instantiate() just as you would
        in the create() method
+  rename: called by the rename(2) system call to rename the object to
+        have the parent and name given by the second inode and dentry.
  readlink: called by the readlink(2) system call. Only required if
        you want to support reading symbolic links
  follow_link: called by the VFS to follow a symbolic link to the
        inode it points to.  Only required if you want to support
-        symbolic links.  This function returns a void pointer cookie
+        symbolic links.  This method returns a void pointer cookie
        that is passed to put_link().
  put_link: called by the VFS to release resources allocated by
-        follow_link().  The cookie returned by follow_link() is passed to
+        follow_link().  The cookie returned by follow_link() is passed
-        to this function as the last parameter.  It is used by filesystems
+        to to this method as the last parameter.  It is used by
-        such as NFS where page cache is not stable (i.e. page that was
+        filesystems such as NFS where page cache is not stable
-        installed when the symbolic link walk started might not be in the
+        (i.e. page that was installed when the symbolic link walk
-        page cache at the end of the walk).
+        started might not be in the page cache at the end of the
+        walk).
-  truncate: called by the VFS to change the size of a file.  The i_size
-        field of the inode is set to the desired size by the VFS before
+  truncate: called by the VFS to change the size of a file.  The
-        this function is called.  This function is called by the truncate(2)
+        i_size field of the inode is set to the desired size by the
-        system call and related functionality.
+        VFS before this method is called.  This method is called by
+        the truncate(2) system call and related functionality.
  permission: called by the VFS to check for access rights on a POSIX-like
        filesystem.
-  setattr: called by the VFS to set attributes for a file.  This function is
+  setattr: called by the VFS to set attributes for a file. This method
-        called by chmod(2) and related system calls.
+        is called by chmod(2) and related system calls.
-  getattr: called by the VFS to get attributes of a file.  This function is
+  getattr: called by the VFS to get attributes of a file. This method
-        called by stat(2) and related system calls.
+        is called by stat(2) and related system calls.
  setxattr: called by the VFS to set an extended attribute for a file.
-        Extended attribute is a name:value pair associated with an inode. This
+        Extended attribute is a name:value pair associated with an
-        function is called by setxattr(2) system call.
+        inode. This method is called by setxattr(2) system call.
+  getxattr: called by the VFS to retrieve the value of an extended
+        attribute name. This method is called by getxattr(2) function
+        call.
-  getxattr: called by the VFS to retrieve the value of an extended attribute
+  listxattr: called by the VFS to list all extended attributes for a
-        name.  This function is called by getxattr(2) function call.
+        given file. This method is called by listxattr(2) system call.
-  listxattr: called by the VFS to list all extended attributes for a given
+  removexattr: called by the VFS to remove an extended attribute from
-        file.  This function is called by listxattr(2) system call.
+        a file. This method is called by removexattr(2) system call.
-  removexattr: called by the VFS to remove an extended attribute from a file.
-        This function is called by removexattr(2) system call.
+The Address Space Object
+========================
+The address space object is used to identify pages in the page cache.
 struct address_space_operations
-===============================
+-------------------------------
 This describes how the VFS can manipulate mapping of a file to page cache in
 your filesystem. As of kernel 2.6.13, the following members are defined:
@@ -502,8 +512,14 @@ struct address_space_operations {
        it.  An example implementation can be found in fs/ext2/xip.c.
+The File Object
+===============
+A file object represents a file opened by a process.
 struct file_operations
-======================
+----------------------
 This describes how the VFS can manipulate an open file. As of kernel
 2.6.13, the following members are defined:
@@ -661,7 +677,7 @@ of child dentries. Child dentries are basically like files in a
 directory.
-Directory Entry Cache APIs
+Directory Entry Cache API
 --------------------------
 There are a number of functions defined which permit a filesystem to
@@ -705,178 +721,24 @@ manipulate dentries:
        and the dentry is returned. The caller must use d_put()
        to free the dentry when it finishes using it.
+For further information on dentry locking, please refer to the document
+Documentation/filesystems/dentry-locking.txt.
-RCU-based dcache locking model
------------------------------
-On many workloads, the most common operation on dcache is
+Resources
-to look up a dentry, given a parent dentry and the name
+=========
-of the child. Typically, for every open(), stat() etc.,
-the dentry corresponding to the pathname will be looked
+(Note some of these resources are not up-to-date with the latest kernel
-up by walking the tree starting with the first component
+ version.)
-of the pathname and using that dentry along with the next
-component to look up the next level and so on. Since it
+Creating Linux virtual filesystems. 2002
-is a frequent operation for workloads like multiuser
+    <http://lwn.net/Articles/13325/>
-environments and web servers, it is important to optimize
-this path.
+The Linux Virtual File-system Layer by Neil Brown. 1999
+    <http://www.cse.unsw.edu.au/~neilb/oss/linux-commentary/vfs.html>
-Prior to 2.5.10, dcache_lock was acquired in d_lookup and thus
-in every component during path look-up. Since 2.5.10 onwards,
+A tour of the Linux VFS by Michael K. Johnson. 1996
-fast-walk algorithm changed this by holding the dcache_lock
+    <http://www.tldp.org/LDP/khg/HyperNews/get/fs/vfstour.html>
-at the beginning and walking as many cached path component
-dentries as possible. This significantly decreases the number
-of acquisition of dcache_lock. However it also increases the
-lock hold time significantly and affects performance in large
-SMP machines. Since 2.5.62 kernel, dcache has been using
-a new locking model that uses RCU to make dcache look-up
-lock-free.
-The current dcache locking model is not very different from the existing
-dcache locking model. Prior to 2.5.62 kernel, dcache_lock
-protected the hash chain, d_child, d_alias, d_lru lists as well
-as d_inode and several other things like mount look-up. RCU-based
-changes affect only the way the hash chain is protected. For everything
-else the dcache_lock must be taken for both traversing as well as
-updating. The hash chain updates too take the dcache_lock.
-The significant change is the way d_lookup traverses the hash chain,
-it doesn't acquire the dcache_lock for this and rely on RCU to
-ensure that the dentry has not been *freed*.
-Dcache locking details
----------------------
-For many multi-user workloads, open() and stat() on files are
+A small trail through the Linux kernel by Andries Brouwer. 2001
-very frequently occurring operations. Both involve walking
+    <http://www.win.tue.nl/~aeb/linux/vfs/trail.html>
-of path names to find the dentry corresponding to the
-concerned file. In 2.4 kernel, dcache_lock was held
-during look-up of each path component. Contention and
-cache-line bouncing of this global lock caused significant
-scalability problems. With the introduction of RCU
-in Linux kernel, this was worked around by making
-the look-up of path components during path walking lock-free.
-Safe lock-free look-up of dcache hash table
-===========================================
-Dcache is a complex data structure with the hash table entries
-also linked together in other lists. In 2.4 kernel, dcache_lock
-protected all the lists. We applied RCU only on hash chain
-walking. The rest of the lists are still protected by dcache_lock.
-Some of the important changes are :
-1. The deletion from hash chain is done using hlist_del_rcu() macro which
-   doesn't initialize next pointer of the deleted dentry and this
-   allows us to walk safely lock-free while a deletion is happening.
-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 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 while traversing
-   the hash chain. This isn't different from the existing code.
-3. The dentry looked up without holding dcache_lock by cannot be
-   returned for walking if it is unhashed. It then may have a NULL
-   d_inode or other bogosity since RCU doesn't protect the other
-   fields in the dentry. We therefore use a flag DCACHE_UNHASHED to
-   indicate unhashed  dentries and use this in conjunction with a
-   per-dentry lock (d_lock). Once looked up without the dcache_lock,
-   we acquire the per-dentry lock (d_lock) and check if the
-   dentry is unhashed. If so, the look-up is failed. If not, the
-   reference count of the dentry is increased and the dentry is returned.
-4. Once a dentry is looked up, it must be ensured during the path
-   walk for that component it doesn't go away. In pre-2.5.10 code,
-   this was done holding a reference to the dentry. dcache_rcu does
-   the same.  In some sense, dcache_rcu path walking looks like
-   the pre-2.5.10 version.
-5. All dentry hash chain updates must take the dcache_lock as well as
-   the per-dentry lock in that order. dput() does this to ensure
-   that a dentry that has just been looked up in another CPU
-   doesn't get deleted before dget() can be done on it.
-6. There are several ways to do reference counting of RCU protected
-   objects. One such example is in ipv4 route cache where
-   deferred freeing (using call_rcu()) is done as soon as
-   the reference count goes to zero. This cannot be done in
-   the case of dentries because tearing down of dentries
-   require blocking (dentry_iput()) which isn't supported from
-   RCU callbacks. Instead, tearing down of dentries happen
-   synchronously in dput(), but actual freeing happens later
-   when RCU grace period is over. This allows safe lock-free
-   walking of the hash chains, but a matched dentry may have
-   been partially torn down. The checking of DCACHE_UNHASHED
-   flag with d_lock held detects such dentries and prevents
-   them from being returned from look-up.
-Maintaining POSIX rename semantics
-==================================
-Since look-up of dentries is lock-free, it can race against
-a concurrent rename operation. For example, during rename
-of file A to B, look-up of either A or B must succeed.
-So, if look-up of B happens after A has been removed from the
-hash chain but not added to the new hash chain, it may fail.
-Also, a comparison while the name is being written concurrently
-by a rename may result in false positive matches violating
-rename semantics.  Issues related to race with rename are
-handled as described below :
-1. Look-up can be done in two ways - d_lookup() which is safe
-   from simultaneous renames and __d_lookup() which is not.
-   If __d_lookup() fails, it must be followed up by a d_lookup()
-   to correctly determine whether a dentry is in the hash table
-   or not. d_lookup() protects look-ups using a sequence
-   lock (rename_lock).
-2. The name associated with a dentry (d_name) may be changed if
-   a rename is allowed to happen simultaneously. To avoid memcmp()
-   in __d_lookup() go out of bounds due to a rename and false
-   positive comparison, the name comparison is done while holding the
-   per-dentry lock. This prevents concurrent renames during this
-   operation.
-3. Hash table walking during look-up may move to a different bucket as
-   the current dentry is moved to a different bucket due to rename.
-   But we use hlists in dcache hash table and they are null-terminated.
-   So, even if a dentry moves to a different bucket, hash chain
-   walk will terminate. [with a list_head list, it may not since
-   termination is when the list_head in the original bucket is reached].
-   Since we redo the d_parent check and compare name while holding
-   d_lock, lock-free look-up will not race against d_move().
-4. There can be a theoretical race when a dentry keeps coming back
-   to original bucket due to double moves. Due to this look-up may
-   consider that it has never moved and can end up in a infinite loop.
-   But this is not any worse that theoretical livelocks we already
-   have in the kernel.
-Important guidelines for filesystem developers related to dcache_rcu
-====================================================================
-1. Existing dcache interfaces (pre-2.5.62) exported to filesystem
-   don't change. Only dcache internal implementation changes. However
-   filesystems *must not* delete from the dentry hash chains directly
-   using the list macros like allowed earlier. They must use dcache
-   APIs like d_drop() or __d_drop() depending on the situation.
-2. d_flags is now protected by a per-dentry lock (d_lock). All
-   access to d_flags must be protected by it.
-3. For a hashed dentry, checking of d_count needs to be protected
-   by d_lock.
-Papers and other documentation on dcache locking
-================================================
-1. Scaling dcache with RCU (http://linuxjournal.com/article.php?sid=7124).
-2. http://lse.sourceforge.net/locking/dcache/dcache.html
diff --git a/Documentation/hpet.txt b/Documentation/hpet.txt
index 4e7cc8d3359b..e52457581f47 100644
--- a/Documentation/hpet.txt
+++ b/Documentation/hpet.txt
@@ -1,18 +1,21 @@
                High Precision Event Timer Driver for Linux
-The High Precision Event Timer (HPET) hardware is the future replacement for the 8254 and Real
+The High Precision Event Timer (HPET) hardware is the future replacement
-Time Clock (RTC) periodic timer functionality.  Each HPET can have up two 32 timers.  It is possible
+for the 8254 and Real Time Clock (RTC) periodic timer functionality.
-to configure the first two timers as legacy replacements for 8254 and RTC periodic.  A specification
+Each HPET can have up two 32 timers.  It is possible to configure the
-done by INTEL and Microsoft can be found at http://www.intel.com/labs/platcomp/hpet/hpetspec.htm.
+first two timers as legacy replacements for 8254 and RTC periodic timers.
+A specification done by Intel and Microsoft can be found at
-The driver supports detection of HPET driver allocation and initialization of the HPET before the
+<http://www.intel.com/hardwaredesign/hpetspec.htm>.
-driver module_init routine is called.  This enables platform code which uses timer 0 or 1 as the
-main timer to intercept HPET initialization.  An example of this initialization can be found in
+The driver supports detection of HPET driver allocation and initialization
+of the HPET before the driver module_init routine is called.  This enables
+platform code which uses timer 0 or 1 as the main timer to intercept HPET
+initialization.  An example of this initialization can be found in
 arch/i386/kernel/time_hpet.c.
-The driver provides two APIs which are very similar to the API found in the rtc.c driver.
+The driver provides two APIs which are very similar to the API found in
-There is a user space API and a kernel space API.  An example user space program is provided
+the rtc.c driver.  There is a user space API and a kernel space API.
-below.
+An example user space program is provided below.
 #include <stdio.h>
 #include <stdlib.h>
@@ -290,9 +293,8 @@ The kernel API has three interfaces exported from the driver:
        hpet_unregister(struct hpet_task *tp)
        hpet_control(struct hpet_task *tp, unsigned int cmd, unsigned long arg)
-The kernel module using this interface fills in the ht_func and ht_data members of the
+The kernel module using this interface fills in the ht_func and ht_data
-hpet_task structure before calling hpet_register.  hpet_control simply vectors to the hpet_ioctl
+members of the hpet_task structure before calling hpet_register.
-routine and has the same commands and respective arguments as the user API.  hpet_unregister
+hpet_control simply vectors to the hpet_ioctl routine and has the same
+commands and respective arguments as the user API.  hpet_unregister
 is used to terminate usage of the HPET timer reserved by hpet_register.
diff --git a/Documentation/ioctl-number.txt b/Documentation/ioctl-number.txt
index 769f925c8526..87f4d052e39c 100644
--- a/Documentation/ioctl-number.txt
+++ b/Documentation/ioctl-number.txt
@@ -130,8 +130,6 @@ Code	Seq#	Include File		Comments
                                        <mailto:zapman@interlan.net>
 'i'     00-3F   linux/i2o.h
 'j'     00-3F   linux/joystick.h
-'k'     all     asm-sparc/kbio.h
-                asm-sparc64/kbio.h
 'l'     00-3F   linux/tcfs_fs.h         transparent cryptographic file system
                                        <http://mikonos.dia.unisa.it/tcfs>
 'l'     40-7F   linux/udf_fs_i.h        in development:
diff --git a/Documentation/magic-number.txt b/Documentation/magic-number.txt
index bd8eefa17587..af67faccf4de 100644
--- a/Documentation/magic-number.txt
+++ b/Documentation/magic-number.txt
@@ -120,7 +120,7 @@ ISDN_NET_MAGIC        0x49344C02  isdn_net_local_s  drivers/isdn/i4l/isdn_net_li
 SAVEKMSG_MAGIC2       0x4B4D5347  savekmsg          arch/*/amiga/config.c
 STLI_BOARDMAGIC       0x4bc6c825  stlibrd           include/linux/istallion.h
 CS_STATE_MAGIC        0x4c4f4749  cs_state          sound/oss/cs46xx.c
-SLAB_C_MAGIC          0x4f17a36d  kmem_cache_s      mm/slab.c
+SLAB_C_MAGIC          0x4f17a36d  kmem_cache        mm/slab.c
 COW_MAGIC             0x4f4f4f4d  cow_header_v1     arch/um/drivers/ubd_user.c
 I810_CARD_MAGIC       0x5072696E  i810_card         sound/oss/i810_audio.c
 TRIDENT_CARD_MAGIC    0x5072696E  trident_card      sound/oss/trident.c
diff --git a/Documentation/networking/decnet.txt b/Documentation/networking/decnet.txt
index c6bd25f5d61d..e6c39c5831f5 100644
--- a/Documentation/networking/decnet.txt
+++ b/Documentation/networking/decnet.txt
@@ -176,8 +176,6 @@ information (_most_ of which _is_ _essential_) includes:
 - Which client caused the problem ?
 - How much data was being transferred ?
 - Was the network congested ?
- - If there was a kernel panic, please run the output through ksymoops
-   before sending it to me, otherwise its _useless_.
 - How can the problem be reproduced ?
 - Can you use tcpdump to get a trace ? (N.B. Most (all?) versions of 
   tcpdump don't understand how to dump DECnet properly, so including
diff --git a/Documentation/oops-tracing.txt b/Documentation/oops-tracing.txt
index 66eaaab7773d..c563842ed805 100644
--- a/Documentation/oops-tracing.txt
+++ b/Documentation/oops-tracing.txt
@@ -1,6 +1,6 @@
 NOTE: ksymoops is useless on 2.6.  Please use the Oops in its original format
 (from dmesg, etc).  Ignore any references in this or other docs to "decoding
-the Oops" or "running it through ksymoops".  If you post an Oops fron 2.6 that
+the Oops" or "running it through ksymoops".  If you post an Oops from 2.6 that
 has been run through ksymoops, people will just tell you to repost it.
 Quick Summary
diff --git a/Documentation/power/video.txt b/Documentation/power/video.txt
index 526d6dd267ea..912bed87c758 100644
--- a/Documentation/power/video.txt
+++ b/Documentation/power/video.txt
@@ -11,9 +11,9 @@ boot video card. (Kernel usually does not even contain video card
 driver -- vesafb and vgacon are widely used).
 This is not problem for swsusp, because during swsusp resume, BIOS is
-run normally so video card is normally initialized. S3 has absolutely
+run normally so video card is normally initialized. It should not be
-no chance of working with SMP/HT. Be sure it to turn it off before
+problem for S1 standby, because hardware should retain its state over
-testing (swsusp should work ok, OTOH).
+that.
 There are a few types of systems where video works after S3 resume:
@@ -64,7 +64,7 @@ your video card (good luck getting docs :-(). Maybe suspending from X
 (proper X, knowing your hardware, not XF68_FBcon) might have better
 chance of working.
-Table of known working systems:
+Table of known working notebooks:
 Model                           hack (or "how to do it")
 ------------------------------------------------------------------------------
@@ -73,7 +73,7 @@ Acer TM 242FX			vbetool (6)
 Acer TM C110                    video_post (8)
 Acer TM C300                    vga=normal (only suspend on console, not in X), vbetool (6) or video_post (8)
 Acer TM 4052LCi                 s3_bios (2)
-Acer TM 636Lci                  s3_bios vga=normal (2)
+Acer TM 636Lci                  s3_bios,s3_mode (4)
 Acer TM 650 (Radeon M7)         vga=normal plus boot-radeon (5) gets text console back
 Acer TM 660                     ??? (*)
 Acer TM 800                     vga=normal, X patches, see webpage (5) or vbetool (6)
@@ -137,6 +137,13 @@ Toshiba Satellite P10-554       s3_bios,s3_mode (4)(****)
 Toshiba M30                     (2) xor X with nvidia driver using internal AGP
 Uniwill 244IIO                  ??? (*)
+Known working desktop systems
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Mainboard           Graphics card                 hack (or "how to do it")
+------------------------------------------------------------------------------
+Asus A7V8X          nVidia RIVA TNT2 model 64     s3_bios,s3_mode (4)
 (*) from http://www.ubuntulinux.org/wiki/HoaryPMResults, not sure
    which options to use. If you know, please tell me.
diff --git a/Documentation/s390/driver-model.txt b/Documentation/s390/driver-model.txt
index 19461958e2bd..df09758bf3fe 100644
--- a/Documentation/s390/driver-model.txt
+++ b/Documentation/s390/driver-model.txt
@@ -8,11 +8,10 @@ All devices which can be addressed by means of ccws are called 'CCW devices' -
 even if they aren't actually driven by ccws.
 All ccw devices are accessed via a subchannel, this is reflected in the 
-structures under root/:
+structures under devices/:
-root/
+devices/
-     - sys
+     - system/
-     - legacy
     - css0/
           - 0.0.0000/0.0.0815/
           - 0.0.0001/0.0.4711/
@@ -36,7 +35,7 @@ availability: Can be 'good' or 'boxed'; 'no path' or 'no device' for
 online:     An interface to set the device online and offline.
            In the special case of the device being disconnected (see the
-            notify function under 1.2), piping 0 to online will focibly delete
+            notify function under 1.2), piping 0 to online will forcibly delete
            the device.
 The device drivers can add entries to export per-device data and interfaces.
@@ -222,7 +221,7 @@ and are called 'chp0.<chpid>'. They have no driver and do not belong to any bus.
 Please note, that unlike /proc/chpids in 2.4, the channel path objects reflect
 only the logical state and not the physical state, since we cannot track the
 latter consistently due to lacking machine support (we don't need to be aware
-of anyway).
+of it anyway).
 status - Can be 'online' or 'offline'.
         Piping 'on' or 'off' sets the chpid logically online/offline.
@@ -235,12 +234,16 @@ status - Can be 'online' or 'offline'.
 3. System devices
 -----------------
-Note: cpus may yet be added here.
 3.1 xpram 
 ---------
-xpram shows up under sys/ as 'xpram'.
+xpram shows up under devices/system/ as 'xpram'.
+3.2 cpus
+--------
+For each cpu, a directory is created under devices/system/cpu/. Each cpu has an
+attribute 'online' which can be 0 or 1.
 4. Other devices
diff --git a/Documentation/sharedsubtree.txt b/Documentation/sharedsubtree.txt
new file mode 100644
index 000000000000..2d8f403eb6eb
--- /dev/null
+++ b/Documentation/sharedsubtree.txt
@@ -0,0 +1,1060 @@
+Shared Subtrees
+---------------
+Contents:
+        1) Overview
+        2) Features
+        3) smount command
+        4) Use-case
+        5) Detailed semantics
+        6) Quiz
+        7) FAQ
+        8) Implementation
+1) Overview
+-----------
+Consider the following situation:
+A process wants to clone its own namespace, but still wants to access the CD
+that got mounted recently.  Shared subtree semantics provide the necessary
+mechanism to accomplish the above.
+It provides the necessary building blocks for features like per-user-namespace
+and versioned filesystem.
+2) Features
+-----------
+Shared subtree provides four different flavors of mounts; struct vfsmount to be
+precise
+        a. shared mount
+        b. slave mount
+        c. private mount
+        d. unbindable mount
+2a) A shared mount can be replicated to as many mountpoints and all the
+replicas continue to be exactly same.
+        Here is an example:
+        Lets say /mnt has a mount that is shared.
+        mount --make-shared /mnt
+        note: mount command does not yet support the --make-shared flag.
+        I have included a small C program which does the same by executing
+        'smount /mnt shared'
+        #mount --bind /mnt /tmp
+        The above command replicates the mount at /mnt to the mountpoint /tmp
+        and the contents of both the mounts remain identical.
+        #ls /mnt
+        a b c
+        #ls /tmp
+        a b c
+        Now lets say we mount a device at /tmp/a
+        #mount /dev/sd0  /tmp/a
+        #ls /tmp/a
+        t1 t2 t2
+        #ls /mnt/a
+        t1 t2 t2
+        Note that the mount has propagated to the mount at /mnt as well.
+        And the same is true even when /dev/sd0 is mounted on /mnt/a. The
+        contents will be visible under /tmp/a too.
+2b) A slave mount is like a shared mount except that mount and umount events
+        only propagate towards it.
+        All slave mounts have a master mount which is a shared.
+        Here is an example:
+        Lets say /mnt has a mount which is shared.
+        #mount --make-shared /mnt
+        Lets bind mount /mnt to /tmp
+        #mount --bind /mnt /tmp
+        the new mount at /tmp becomes a shared mount and it is a replica of
+        the mount at /mnt.
+        Now lets make the mount at /tmp; a slave of /mnt
+        #mount --make-slave /tmp
+        [or smount /tmp slave]
+        lets mount /dev/sd0 on /mnt/a
+        #mount /dev/sd0 /mnt/a
+        #ls /mnt/a
+        t1 t2 t3
+        #ls /tmp/a
+        t1 t2 t3
+        Note the mount event has propagated to the mount at /tmp
+        However lets see what happens if we mount something on the mount at /tmp
+        #mount /dev/sd1 /tmp/b
+        #ls /tmp/b
+        s1 s2 s3
+        #ls /mnt/b
+        Note how the mount event has not propagated to the mount at
+        /mnt
+2c) A private mount does not forward or receive propagation.
+        This is the mount we are familiar with. Its the default type.
+2d) A unbindable mount is a unbindable private mount
+        lets say we have a mount at /mnt and we make is unbindable
+        #mount --make-unbindable /mnt
+         [ smount /mnt  unbindable ]
+         Lets try to bind mount this mount somewhere else.
+         # mount --bind /mnt /tmp
+         mount: wrong fs type, bad option, bad superblock on /mnt,
+                or too many mounted file systems
+        Binding a unbindable mount is a invalid operation.
+3) smount command
+        Currently the mount command is not aware of shared subtree features.
+        Work is in progress to add the support in mount ( util-linux package ).
+        Till then use the following program.
+        ------------------------------------------------------------------------
+        //
+        //this code was developed my Miklos Szeredi <miklos@szeredi.hu>
+        //and modified by Ram Pai <linuxram@us.ibm.com>
+        // sample usage:
+        //              smount /tmp shared
+        //
+        #include <stdio.h>
+        #include <stdlib.h>
+        #include <unistd.h>
+        #include <sys/mount.h>
+        #include <sys/fsuid.h>
+        #ifndef MS_REC
+        #define MS_REC          0x4000  /* 16384: Recursive loopback */
+        #endif
+        #ifndef MS_SHARED
+        #define MS_SHARED               1<<20   /* Shared */
+        #endif
+        #ifndef MS_PRIVATE
+        #define MS_PRIVATE              1<<18   /* Private */
+        #endif
+        #ifndef MS_SLAVE
+        #define MS_SLAVE                1<<19   /* Slave */
+        #endif
+        #ifndef MS_UNBINDABLE
+        #define MS_UNBINDABLE           1<<17   /* Unbindable */
+        #endif
+        int main(int argc, char *argv[])
+        {
+                int type;
+                if(argc != 3) {
+                        fprintf(stderr, "usage: %s dir "
+                        "<rshared|rslave|rprivate|runbindable|shared|slave"
+                        "|private|unbindable>\n" , argv[0]);
+                        return 1;
+                }
+                fprintf(stdout, "%s %s %s\n", argv[0], argv[1], argv[2]);
+                if (strcmp(argv[2],"rshared")==0)
+                        type=(MS_SHARED|MS_REC);
+                else if (strcmp(argv[2],"rslave")==0)
+                        type=(MS_SLAVE|MS_REC);
+                else if (strcmp(argv[2],"rprivate")==0)
+                        type=(MS_PRIVATE|MS_REC);
+                else if (strcmp(argv[2],"runbindable")==0)
+                        type=(MS_UNBINDABLE|MS_REC);
+                else if (strcmp(argv[2],"shared")==0)
+                        type=MS_SHARED;
+                else if (strcmp(argv[2],"slave")==0)
+                        type=MS_SLAVE;
+                else if (strcmp(argv[2],"private")==0)
+                        type=MS_PRIVATE;
+                else if (strcmp(argv[2],"unbindable")==0)
+                        type=MS_UNBINDABLE;
+                else {
+                        fprintf(stderr, "invalid operation: %s\n", argv[2]);
+                        return 1;
+                }
+                setfsuid(getuid());
+                if(mount("", argv[1], "dontcare", type, "") == -1) {
+                        perror("mount");
+                        return 1;
+                }
+                return 0;
+        }
+        -----------------------------------------------------------------------
+        Copy the above code snippet into smount.c
+        gcc -o smount smount.c
+        (i) To mark all the mounts under /mnt as shared execute the following
+        command:
+                smount /mnt rshared
+                the corresponding syntax planned for mount command is
+                mount --make-rshared /mnt
+            just to mark a mount /mnt as shared, execute the following
+            command:
+                smount /mnt shared
+                the corresponding syntax planned for mount command is
+                mount --make-shared /mnt
+        (ii) To mark all the shared mounts under /mnt as slave execute the
+        following
+             command:
+                smount /mnt rslave
+                the corresponding syntax planned for mount command is
+                mount --make-rslave /mnt
+            just to mark a mount /mnt as slave, execute the following
+            command:
+                smount /mnt slave
+                the corresponding syntax planned for mount command is
+                mount --make-slave /mnt
+        (iii) To mark all the mounts under /mnt as private execute the
+        following command:
+                smount /mnt rprivate
+                the corresponding syntax planned for mount command is
+                mount --make-rprivate /mnt
+            just to mark a mount /mnt as private, execute the following
+            command:
+                smount /mnt private
+                the corresponding syntax planned for mount command is
+                mount --make-private /mnt
+              NOTE: by default all the mounts are created as private. But if
+              you want to change some shared/slave/unbindable  mount as
+              private at a later point in time, this command can help.
+        (iv) To mark all the mounts under /mnt as unbindable execute the
+        following
+             command:
+                smount /mnt runbindable
+                the corresponding syntax planned for mount command is
+                mount --make-runbindable /mnt
+            just to mark a mount /mnt as unbindable, execute the following
+            command:
+                smount /mnt unbindable
+                the corresponding syntax planned for mount command is
+                mount --make-unbindable /mnt
+4) Use cases
+------------
+        A) A process wants to clone its own namespace, but still wants to
+           access the CD that got mounted recently.
+           Solution:
+                The system administrator can make the mount at /cdrom shared
+                mount --bind /cdrom /cdrom
+                mount --make-shared /cdrom
+                Now any process that clones off a new namespace will have a
+                mount at /cdrom which is a replica of the same mount in the
+                parent namespace.
+                So when a CD is inserted and mounted at /cdrom that mount gets
+                propagated to the other mount at /cdrom in all the other clone
+                namespaces.
+        B) A process wants its mounts invisible to any other process, but
+        still be able to see the other system mounts.
+           Solution:
+                To begin with, the administrator can mark the entire mount tree
+                as shareable.
+                mount --make-rshared /
+                A new process can clone off a new namespace. And mark some part
+                of its namespace as slave
+                mount --make-rslave /myprivatetree
+                Hence forth any mounts within the /myprivatetree done by the
+                process will not show up in any other namespace. However mounts
+                done in the parent namespace under /myprivatetree still shows
+                up in the process's namespace.
+        Apart from the above semantics this feature provides the
+        building blocks to solve the following problems:
+        C)  Per-user namespace
+                The above semantics allows a way to share mounts across
+                namespaces.  But namespaces are associated with processes. If
+                namespaces are made first class objects with user API to
+                associate/disassociate a namespace with userid, then each user
+                could have his/her own namespace and tailor it to his/her
+                requirements. Offcourse its needs support from PAM.
+        D)  Versioned files
+                If the entire mount tree is visible at multiple locations, then
+                a underlying versioning file system can return different
+                version of the file depending on the path used to access that
+                file.
+                An example is:
+                mount --make-shared /
+                mount --rbind / /view/v1
+                mount --rbind / /view/v2
+                mount --rbind / /view/v3
+                mount --rbind / /view/v4
+                and if /usr has a versioning filesystem mounted, than that
+                mount appears at /view/v1/usr, /view/v2/usr, /view/v3/usr and
+                /view/v4/usr too
+                A user can request v3 version of the file /usr/fs/namespace.c
+                by accessing /view/v3/usr/fs/namespace.c . The underlying
+                versioning filesystem can then decipher that v3 version of the
+                filesystem is being requested and return the corresponding
+                inode.
+5) Detailed semantics:
+-------------------
+        The section below explains the detailed semantics of
+        bind, rbind, move, mount, umount and clone-namespace operations.
+        Note: the word 'vfsmount' and the noun 'mount' have been used
+        to mean the same thing, throughout this document.
+5a) Mount states
+        A given mount can be in one of the following states
+        1) shared
+        2) slave
+        3) shared and slave
+        4) private
+        5) unbindable
+        A 'propagation event' is defined as event generated on a vfsmount
+        that leads to mount or unmount actions in other vfsmounts.
+        A 'peer group' is defined as a group of vfsmounts that propagate
+        events to each other.
+        (1) Shared mounts
+                A 'shared mount' is defined as a vfsmount that belongs to a
+                'peer group'.
+                For example:
+                        mount --make-shared /mnt
+                        mount --bin /mnt /tmp
+                The mount at /mnt and that at /tmp are both shared and belong
+                to the same peer group. Anything mounted or unmounted under
+                /mnt or /tmp reflect in all the other mounts of its peer
+                group.
+        (2) Slave mounts
+                A 'slave mount' is defined as a vfsmount that receives
+                propagation events and does not forward propagation events.
+                A slave mount as the name implies has a master mount from which
+                mount/unmount events are received. Events do not propagate from
+                the slave mount to the master.  Only a shared mount can be made
+                a slave by executing the following command
+                        mount --make-slave mount
+                A shared mount that is made as a slave is no more shared unless
+                modified to become shared.
+        (3) Shared and Slave
+                A vfsmount can be both shared as well as slave.  This state
+                indicates that the mount is a slave of some vfsmount, and
+                has its own peer group too.  This vfsmount receives propagation
+                events from its master vfsmount, and also forwards propagation
+                events to its 'peer group' and to its slave vfsmounts.
+                Strictly speaking, the vfsmount is shared having its own
+                peer group, and this peer-group is a slave of some other
+                peer group.
+                Only a slave vfsmount can be made as 'shared and slave' by
+                either executing the following command
+                        mount --make-shared mount
+                or by moving the slave vfsmount under a shared vfsmount.
+        (4) Private mount
+                A 'private mount' is defined as vfsmount that does not
+                receive or forward any propagation events.
+        (5) Unbindable mount
+                A 'unbindable mount' is defined as vfsmount that does not
+                receive or forward any propagation events and cannot
+                be bind mounted.
+        State diagram:
+        The state diagram below explains the state transition of a mount,
+        in response to various commands.
+        ------------------------------------------------------------------------
+        |             |make-shared |  make-slave  | make-private |make-unbindab|
+        --------------|------------|--------------|--------------|-------------|
+        |shared       |shared      |*slave/private|   private    | unbindable  |
+        |             |            |              |              |             |
+        |-------------|------------|--------------|--------------|-------------|
+        |slave        |shared      |    **slave   |    private   | unbindable  |
+        |             |and slave   |              |              |             |
+        |-------------|------------|--------------|--------------|-------------|
+        |shared       |shared      |    slave     |    private   | unbindable  |
+        |and slave    |and slave   |              |              |             |
+        |-------------|------------|--------------|--------------|-------------|
+        |private      |shared      |  **private   |    private   | unbindable  |
+        |-------------|------------|--------------|--------------|-------------|
+        |unbindable   |shared      |**unbindable  |    private   | unbindable  |
+        ------------------------------------------------------------------------
+        * if the shared mount is the only mount in its peer group, making it
+        slave, makes it private automatically. Note that there is no master to
+        which it can be slaved to.
+        ** slaving a non-shared mount has no effect on the mount.
+        Apart from the commands listed below, the 'move' operation also changes
+        the state of a mount depending on type of the destination mount. Its
+        explained in section 5d.
+5b) Bind semantics
+        Consider the following command
+        mount --bind A/a  B/b
+        where 'A' is the source mount, 'a' is the dentry in the mount 'A', 'B'
+        is the destination mount and 'b' is the dentry in the destination mount.
+        The outcome depends on the type of mount of 'A' and 'B'. The table
+        below contains quick reference.
+   ---------------------------------------------------------------------------
+   |         BIND MOUNT OPERATION                                            |
+   |**************************************************************************
+   |source(A)->| shared       |       private  |       slave    | unbindable |
+   | dest(B)  |               |                |                |            |
+   |   |      |               |                |                |            |
+   |   v      |               |                |                |            |
+   |**************************************************************************
+   |  shared  | shared        |     shared     | shared & slave |  invalid   |
+   |          |               |                |                |            |
+   |non-shared| shared        |      private   |      slave     |  invalid   |
+   ***************************************************************************
+        Details:
+        1. 'A' is a shared mount and 'B' is a shared mount. A new mount 'C'
+        which is clone of 'A', is created. Its root dentry is 'a' . 'C' is
+        mounted on mount 'B' at dentry 'b'. Also new mount 'C1', 'C2', 'C3' ...
+        are created and mounted at the dentry 'b' on all mounts where 'B'
+        propagates to. A new propagation tree containing 'C1',..,'Cn' is
+        created. This propagation tree is identical to the propagation tree of
+        'B'.  And finally the peer-group of 'C' is merged with the peer group
+        of 'A'.
+        2. 'A' is a private mount and 'B' is a shared mount. A new mount 'C'
+        which is clone of 'A', is created. Its root dentry is 'a'. 'C' is
+        mounted on mount 'B' at dentry 'b'. Also new mount 'C1', 'C2', 'C3' ...
+        are created and mounted at the dentry 'b' on all mounts where 'B'
+        propagates to. A new propagation tree is set containing all new mounts
+        'C', 'C1', .., 'Cn' with exactly the same configuration as the
+        propagation tree for 'B'.
+        3. 'A' is a slave mount of mount 'Z' and 'B' is a shared mount. A new
+        mount 'C' which is clone of 'A', is created. Its root dentry is 'a' .
+        'C' is mounted on mount 'B' at dentry 'b'. Also new mounts 'C1', 'C2',
+        'C3' ... are created and mounted at the dentry 'b' on all mounts where
+        'B' propagates to. A new propagation tree containing the new mounts
+        'C','C1',..  'Cn' is created. This propagation tree is identical to the
+        propagation tree for 'B'. And finally the mount 'C' and its peer group
+        is made the slave of mount 'Z'.  In other words, mount 'C' is in the
+        state 'slave and shared'.
+        4. 'A' is a unbindable mount and 'B' is a shared mount. This is a
+        invalid operation.
+        5. 'A' is a private mount and 'B' is a non-shared(private or slave or
+        unbindable) mount. A new mount 'C' which is clone of 'A', is created.
+        Its root dentry is 'a'. 'C' is mounted on mount 'B' at dentry 'b'.
+        6. 'A' is a shared mount and 'B' is a non-shared mount. A new mount 'C'
+        which is a clone of 'A' is created. Its root dentry is 'a'. 'C' is
+        mounted on mount 'B' at dentry 'b'.  'C' is made a member of the
+        peer-group of 'A'.
+        7. 'A' is a slave mount of mount 'Z' and 'B' is a non-shared mount. A
+        new mount 'C' which is a clone of 'A' is created. Its root dentry is
+        'a'.  'C' is mounted on mount 'B' at dentry 'b'. Also 'C' is set as a
+        slave mount of 'Z'. In other words 'A' and 'C' are both slave mounts of
+        'Z'.  All mount/unmount events on 'Z' propagates to 'A' and 'C'. But
+        mount/unmount on 'A' do not propagate anywhere else. Similarly
+        mount/unmount on 'C' do not propagate anywhere else.
+        8. 'A' is a unbindable mount and 'B' is a non-shared mount. This is a
+        invalid operation. A unbindable mount cannot be bind mounted.
+5c) Rbind semantics
+        rbind is same as bind. Bind replicates the specified mount.  Rbind
+        replicates all the mounts in the tree belonging to the specified mount.
+        Rbind mount is bind mount applied to all the mounts in the tree.
+        If the source tree that is rbind has some unbindable mounts,
+        then the subtree under the unbindable mount is pruned in the new
+        location.
+        eg: lets say we have the following mount tree.
+                A
+              /   \
+              B   C
+             / \ / \
+             D E F G
+             Lets say all the mount except the mount C in the tree are
+             of a type other than unbindable.
+             If this tree is rbound to say Z
+             We will have the following tree at the new location.
+                Z
+                |
+                A'
+               /
+              B'                Note how the tree under C is pruned
+             / \                in the new location.
+            D' E'
+5d) Move semantics
+        Consider the following command
+        mount --move A  B/b
+        where 'A' is the source mount, 'B' is the destination mount and 'b' is
+        the dentry in the destination mount.
+        The outcome depends on the type of the mount of 'A' and 'B'. The table
+        below is a quick reference.
+   ---------------------------------------------------------------------------
+   |                    MOVE MOUNT OPERATION                                 |
+   |**************************************************************************
+   | source(A)->| shared      |       private  |       slave    | unbindable |
+   | dest(B)  |               |                |                |            |
+   |   |      |               |                |                |            |
+   |   v      |               |                |                |            |
+   |**************************************************************************
+   |  shared  | shared        |     shared     |shared and slave|  invalid   |
+   |          |               |                |                |            |
+   |non-shared| shared        |      private   |    slave       | unbindable |
+   ***************************************************************************
+        NOTE: moving a mount residing under a shared mount is invalid.
+      Details follow:
+        1. 'A' is a shared mount and 'B' is a shared mount.  The mount 'A' is
+        mounted on mount 'B' at dentry 'b'.  Also new mounts 'A1', 'A2'...'An'
+        are created and mounted at dentry 'b' on all mounts that receive
+        propagation from mount 'B'. A new propagation tree is created in the
+        exact same configuration as that of 'B'. This new propagation tree
+        contains all the new mounts 'A1', 'A2'...  'An'.  And this new
+        propagation tree is appended to the already existing propagation tree
+        of 'A'.
+        2. 'A' is a private mount and 'B' is a shared mount. The mount 'A' is
+        mounted on mount 'B' at dentry 'b'. Also new mount 'A1', 'A2'... 'An'
+        are created and mounted at dentry 'b' on all mounts that receive
+        propagation from mount 'B'. The mount 'A' becomes a shared mount and a
+        propagation tree is created which is identical to that of
+        'B'. This new propagation tree contains all the new mounts 'A1',
+        'A2'...  'An'.
+        3. 'A' is a slave mount of mount 'Z' and 'B' is a shared mount.  The
+        mount 'A' is mounted on mount 'B' at dentry 'b'.  Also new mounts 'A1',
+        'A2'... 'An' are created and mounted at dentry 'b' on all mounts that
+        receive propagation from mount 'B'. A new propagation tree is created
+        in the exact same configuration as that of 'B'. This new propagation
+        tree contains all the new mounts 'A1', 'A2'...  'An'.  And this new
+        propagation tree is appended to the already existing propagation tree of
+        'A'.  Mount 'A' continues to be the slave mount of 'Z' but it also
+        becomes 'shared'.
+        4. 'A' is a unbindable mount and 'B' is a shared mount. The operation
+        is invalid. Because mounting anything on the shared mount 'B' can
+        create new mounts that get mounted on the mounts that receive
+        propagation from 'B'.  And since the mount 'A' is unbindable, cloning
+        it to mount at other mountpoints is not possible.
+        5. 'A' is a private mount and 'B' is a non-shared(private or slave or
+        unbindable) mount. The mount 'A' is mounted on mount 'B' at dentry 'b'.
+        6. 'A' is a shared mount and 'B' is a non-shared mount.  The mount 'A'
+        is mounted on mount 'B' at dentry 'b'.  Mount 'A' continues to be a
+        shared mount.
+        7. 'A' is a slave mount of mount 'Z' and 'B' is a non-shared mount.
+        The mount 'A' is mounted on mount 'B' at dentry 'b'.  Mount 'A'
+        continues to be a slave mount of mount 'Z'.
+        8. 'A' is a unbindable mount and 'B' is a non-shared mount. The mount
+        'A' is mounted on mount 'B' at dentry 'b'. Mount 'A' continues to be a
+        unbindable mount.
+5e) Mount semantics
+        Consider the following command
+        mount device  B/b
+        'B' is the destination mount and 'b' is the dentry in the destination
+        mount.
+        The above operation is the same as bind operation with the exception
+        that the source mount is always a private mount.
+5f) Unmount semantics
+        Consider the following command
+        umount A
+        where 'A' is a mount mounted on mount 'B' at dentry 'b'.
+        If mount 'B' is shared, then all most-recently-mounted mounts at dentry
+        'b' on mounts that receive propagation from mount 'B' and does not have
+        sub-mounts within them are unmounted.
+        Example: Lets say 'B1', 'B2', 'B3' are shared mounts that propagate to
+        each other.
+        lets say 'A1', 'A2', 'A3' are first mounted at dentry 'b' on mount
+        'B1', 'B2' and 'B3' respectively.
+        lets say 'C1', 'C2', 'C3' are next mounted at the same dentry 'b' on
+        mount 'B1', 'B2' and 'B3' respectively.
+        if 'C1' is unmounted, all the mounts that are most-recently-mounted on
+        'B1' and on the mounts that 'B1' propagates-to are unmounted.
+        'B1' propagates to 'B2' and 'B3'. And the most recently mounted mount
+        on 'B2' at dentry 'b' is 'C2', and that of mount 'B3' is 'C3'.
+        So all 'C1', 'C2' and 'C3' should be unmounted.
+        If any of 'C2' or 'C3' has some child mounts, then that mount is not
+        unmounted, but all other mounts are unmounted. However if 'C1' is told
+        to be unmounted and 'C1' has some sub-mounts, the umount operation is
+        failed entirely.
+5g) Clone Namespace
+        A cloned namespace contains all the mounts as that of the parent
+        namespace.
+        Lets say 'A' and 'B' are the corresponding mounts in the parent and the
+        child namespace.
+        If 'A' is shared, then 'B' is also shared and 'A' and 'B' propagate to
+        each other.
+        If 'A' is a slave mount of 'Z', then 'B' is also the slave mount of
+        'Z'.
+        If 'A' is a private mount, then 'B' is a private mount too.
+        If 'A' is unbindable mount, then 'B' is a unbindable mount too.
+6) Quiz
+        A. What is the result of the following command sequence?
+                mount --bind /mnt /mnt
+                mount --make-shared /mnt
+                mount --bind /mnt /tmp
+                mount --move /tmp /mnt/1
+                what should be the contents of /mnt /mnt/1 /mnt/1/1 should be?
+                Should they all be identical? or should /mnt and /mnt/1 be
+                identical only?
+        B. What is the result of the following command sequence?
+                mount --make-rshared /
+                mkdir -p /v/1
+                mount --rbind / /v/1
+                what should be the content of /v/1/v/1 be?
+        C. What is the result of the following command sequence?
+                mount --bind /mnt /mnt
+                mount --make-shared /mnt
+                mkdir -p /mnt/1/2/3 /mnt/1/test
+                mount --bind /mnt/1 /tmp
+                mount --make-slave /mnt
+                mount --make-shared /mnt
+                mount --bind /mnt/1/2 /tmp1
+                mount --make-slave /mnt
+                At this point we have the first mount at /tmp and
+                its root dentry is 1. Lets call this mount 'A'
+                And then we have a second mount at /tmp1 with root
+                dentry 2. Lets call this mount 'B'
+                Next we have a third mount at /mnt with root dentry
+                mnt. Lets call this mount 'C'
+                'B' is the slave of 'A' and 'C' is a slave of 'B'
+                A -> B -> C
+                at this point if we execute the following command
+                mount --bind /bin /tmp/test
+                The mount is attempted on 'A'
+                will the mount propagate to 'B' and 'C' ?
+                what would be the contents of
+                /mnt/1/test be?
+7) FAQ
+        Q1. Why is bind mount needed? How is it different from symbolic links?
+                symbolic links can get stale if the destination mount gets
+                unmounted or moved. Bind mounts continue to exist even if the
+                other mount is unmounted or moved.
+        Q2. Why can't the shared subtree be implemented using exportfs?
+                exportfs is a heavyweight way of accomplishing part of what
+                shared subtree can do. I cannot imagine a way to implement the
+                semantics of slave mount using exportfs?
+        Q3 Why is unbindable mount needed?
+                Lets say we want to replicate the mount tree at multiple
+                locations within the same subtree.
+                if one rbind mounts a tree within the same subtree 'n' times
+                the number of mounts created is an exponential function of 'n'.
+                Having unbindable mount can help prune the unneeded bind
+                mounts. Here is a example.
+                step 1:
+                   lets say the root tree has just two directories with
+                   one vfsmount.
+                                    root
+                                   /    \
+                                  tmp    usr
+                    And we want to replicate the tree at multiple
+                    mountpoints under /root/tmp
+                step2:
+                      mount --make-shared /root
+                      mkdir -p /tmp/m1
+                      mount --rbind /root /tmp/m1
+                      the new tree now looks like this:
+                                    root
+                                   /    \
+                                 tmp    usr
+                                /
+                               m1
+                              /  \
+                             tmp  usr
+                             /
+                            m1
+                          it has two vfsmounts
+                step3:
+                            mkdir -p /tmp/m2
+                            mount --rbind /root /tmp/m2
+                        the new tree now looks like this:
+                                      root
+                                     /    \
+                                   tmp     usr
+                                  /    \
+                                m1       m2
+                               / \       /  \
+                             tmp  usr   tmp  usr
+                             / \          /
+                            m1  m2      m1
+                                / \     /  \
+                              tmp usr  tmp   usr
+                              /        / \
+                             m1       m1  m2
+                            /  \
+                          tmp   usr
+                          /  \
+                         m1   m2
+                       it has 6 vfsmounts
+                step 4:
+                          mkdir -p /tmp/m3
+                          mount --rbind /root /tmp/m3
+                          I wont' draw the tree..but it has 24 vfsmounts
+                at step i the number of vfsmounts is V[i] = i*V[i-1].
+                This is an exponential function. And this tree has way more
+                mounts than what we really needed in the first place.
+                One could use a series of umount at each step to prune
+                out the unneeded mounts. But there is a better solution.
+                Unclonable mounts come in handy here.
+                step 1:
+                   lets say the root tree has just two directories with
+                   one vfsmount.
+                                    root
+                                   /    \
+                                  tmp    usr
+                    How do we set up the same tree at multiple locations under
+                    /root/tmp
+                step2:
+                      mount --bind /root/tmp /root/tmp
+                      mount --make-rshared /root
+                      mount --make-unbindable /root/tmp
+                      mkdir -p /tmp/m1
+                      mount --rbind /root /tmp/m1
+                      the new tree now looks like this:
+                                    root
+                                   /    \
+                                 tmp    usr
+                                /
+                               m1
+                              /  \
+                             tmp  usr
+                step3:
+                            mkdir -p /tmp/m2
+                            mount --rbind /root /tmp/m2
+                      the new tree now looks like this:
+                                    root
+                                   /    \
+                                 tmp    usr
+                                /   \
+                               m1     m2
+                              /  \     / \
+                             tmp  usr tmp usr
+                step4:
+                            mkdir -p /tmp/m3
+                            mount --rbind /root /tmp/m3
+                      the new tree now looks like this:
+                                          root
+                                      /           \
+                                     tmp           usr
+                                 /    \    \
+                               m1     m2     m3
+                              /  \     / \    /  \
+                             tmp  usr tmp usr tmp usr
+8) Implementation
+8A) Datastructure
+        4 new fields are introduced to struct vfsmount
+        ->mnt_share
+        ->mnt_slave_list
+        ->mnt_slave
+        ->mnt_master
+        ->mnt_share links togather all the mount to/from which this vfsmount
+                send/receives propagation events.
+        ->mnt_slave_list links all the mounts to which this vfsmount propagates
+                to.
+        ->mnt_slave links togather all the slaves that its master vfsmount
+                propagates to.
+        ->mnt_master points to the master vfsmount from which this vfsmount
+                receives propagation.
+        ->mnt_flags takes two more flags to indicate the propagation status of
+                the vfsmount.  MNT_SHARE indicates that the vfsmount is a shared
+                vfsmount.  MNT_UNCLONABLE indicates that the vfsmount cannot be
+                replicated.
+        All the shared vfsmounts in a peer group form a cyclic list through
+        ->mnt_share.
+        All vfsmounts with the same ->mnt_master form on a cyclic list anchored
+        in ->mnt_master->mnt_slave_list and going through ->mnt_slave.
+         ->mnt_master can point to arbitrary (and possibly different) members
+         of master peer group.  To find all immediate slaves of a peer group
+         you need to go through _all_ ->mnt_slave_list of its members.
+         Conceptually it's just a single set - distribution among the
+         individual lists does not affect propagation or the way propagation
+         tree is modified by operations.
+        A example propagation tree looks as shown in the figure below.
+        [ NOTE: Though it looks like a forest, if we consider all the shared
+        mounts as a conceptual entity called 'pnode', it becomes a tree]
+                        A <--> B <--> C <---> D
+                       /|\            /|      |\
+                      / F G          J K      H I
+                     /
+                    E<-->K
+                        /|\
+                       M L N
+        In the above figure  A,B,C and D all are shared and propagate to each
+        other.   'A' has got 3 slave mounts 'E' 'F' and 'G' 'C' has got 2 slave
+        mounts 'J' and 'K'  and  'D' has got two slave mounts 'H' and 'I'.
+        'E' is also shared with 'K' and they propagate to each other.  And
+        'K' has 3 slaves 'M', 'L' and 'N'
+        A's ->mnt_share links with the ->mnt_share of 'B' 'C' and 'D'
+        A's ->mnt_slave_list links with ->mnt_slave of 'E', 'K', 'F' and 'G'
+        E's ->mnt_share links with ->mnt_share of K
+        'E', 'K', 'F', 'G' have their ->mnt_master point to struct
+                                vfsmount of 'A'
+        'M', 'L', 'N' have their ->mnt_master point to struct vfsmount of 'K'
+        K's ->mnt_slave_list links with ->mnt_slave of 'M', 'L' and 'N'
+        C's ->mnt_slave_list links with ->mnt_slave of 'J' and 'K'
+        J and K's ->mnt_master points to struct vfsmount of C
+        and finally D's ->mnt_slave_list links with ->mnt_slave of 'H' and 'I'
+        'H' and 'I' have their ->mnt_master pointing to struct vfsmount of 'D'.
+        NOTE: The propagation tree is orthogonal to the mount tree.
+8B Algorithm:
+        The crux of the implementation resides in rbind/move operation.
+        The overall algorithm breaks the operation into 3 phases: (look at
+        attach_recursive_mnt() and propagate_mnt())
+        1. prepare phase.
+        2. commit phases.
+        3. abort phases.
+        Prepare phase:
+        for each mount in the source tree:
+                   a) Create the necessary number of mount trees to
+                        be attached to each of the mounts that receive
+                        propagation from the destination mount.
+                   b) Do not attach any of the trees to its destination.
+                      However note down its ->mnt_parent and ->mnt_mountpoint
+                   c) Link all the new mounts to form a propagation tree that
+                      is identical to the propagation tree of the destination
+                      mount.
+                   If this phase is successful, there should be 'n' new
+                   propagation trees; where 'n' is the number of mounts in the
+                   source tree.  Go to the commit phase
+                   Also there should be 'm' new mount trees, where 'm' is
+                   the number of mounts to which the destination mount
+                   propagates to.
+                   if any memory allocations fail, go to the abort phase.
+        Commit phase
+                attach each of the mount trees to their corresponding
+                destination mounts.
+        Abort phase
+                delete all the newly created trees.
+        NOTE: all the propagation related functionality resides in the file
+        pnode.c
+------------------------------------------------------------------------
+version 0.1  (created the initial document, Ram Pai linuxram@us.ibm.com)
+version 0.2  (Incorporated comments from Al Viro)
diff --git a/Documentation/sound/alsa/ALSA-Configuration.txt b/Documentation/sound/alsa/ALSA-Configuration.txt
index 13cba955cb5a..2f27f391c7cc 100644
--- a/Documentation/sound/alsa/ALSA-Configuration.txt
+++ b/Documentation/sound/alsa/ALSA-Configuration.txt
@@ -167,7 +167,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
    spdif           - Support SPDIF I/O
                    - Default: disabled
-    Module supports autoprobe and multiple chips (max 8).
+    This module supports one chip and autoprobe.
    The power-management is supported.
@@ -206,7 +206,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
                          See "AC97 Quirk Option" section below.
    spdif_aclink        - S/PDIF transfer over AC-link (default = 1)
-    This module supports up to 8 cards and autoprobe.
+    This module supports one card and autoprobe.
    ATI IXP has two different methods to control SPDIF output.  One is
    over AC-link and another is over the "direct" SPDIF output.  The
@@ -218,7 +218,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
    Module for ATI IXP 150/200/250 AC97 modem controllers.
-    Module supports up to 8 cards.
+    This module supports one card and autoprobe.
    Note: The default index value of this module is -2, i.e. the first
          slot is excluded.
@@ -637,7 +637,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
    model       - force the model name
    position_fix - Fix DMA pointer (0 = auto, 1 = none, 2 = POSBUF, 3 = FIFO size)
-    Module supports up to 8 cards.
+    This module supports one card and autoprobe.
    Each codec may have a model table for different configurations.
    If your machine isn't listed there, the default (usually minimal)
@@ -663,6 +663,10 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
                        adjusted.  Appearing only when compiled with
                        $CONFIG_SND_DEBUG=y
+        ALC260
+          hp            HP machines
+          fujitsu       Fujitsu S7020
        CMI9880
          minimal       3-jack in back
          min_fp        3-jack in back, 2-jack in front
@@ -811,7 +815,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
                    semaphores (e.g. on some ASUS laptops)
                    (default off)
-    Module supports autoprobe and multiple bus-master chips (max 8).
+    This module supports one chip and autoprobe.
    Note: the latest driver supports auto-detection of chip clock.
    if you still encounter too fast playback, specify the clock
@@ -830,7 +834,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
    ac97_clock    - AC'97 codec clock base (0 = auto-detect)
-    This module supports up to 8 cards and autoprobe.
+    This module supports one card and autoprobe.
    Note: The default index value of this module is -2, i.e. the first
          slot is excluded.
@@ -950,8 +954,10 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
    use_cache        - 0 or 1 (disabled by default)
    vaio_hack        - alias buffer_top=0x25a800
    reset_workaround - enable AC97 RESET workaround for some laptops
+    reset_workaround2 - enable extended AC97 RESET workaround for some
+                      other laptops
-    Module supports autoprobe and multiple chips (max 8).
+    This module supports one chip and autoprobe.
    The power-management is supported.
@@ -980,6 +986,11 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
    workaround is enabled automatically.  For other laptops with a
    hard freeze, you can try reset_workaround=1 option.
+    Note: Dell Latitude CSx laptops have another problem regarding
+    AC97 RESET.  On these laptops, reset_workaround2 option is
+    turned on as default.  This option is worth to try if the
+    previous reset_workaround option doesn't help.
    Note: This driver is really crappy.  It's a porting from the
    OSS driver, which is a result of black-magic reverse engineering.
    The detection of codec will fail if the driver is loaded *after*
@@ -1310,7 +1321,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
    ac97_quirk  - AC'97 workaround for strange hardware
                  See "AC97 Quirk Option" section below.
-    Module supports autoprobe and multiple bus-master chips (max 8).
+    This module supports one chip and autoprobe.
    Note: on some SMP motherboards like MSI 694D the interrupts might
          not be generated properly.  In such a case, please try to
@@ -1352,7 +1363,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
    ac97_clock  - AC'97 codec clock base (default 48000Hz)
-    Module supports up to 8 cards.
+    This module supports one card and autoprobe.
    Note: The default index value of this module is -2, i.e. the first
          slot is excluded.
diff --git a/Documentation/sound/alsa/DocBook/writing-an-alsa-driver.tmpl b/Documentation/sound/alsa/DocBook/writing-an-alsa-driver.tmpl
index 24e85520890b..260334c98d95 100644
--- a/Documentation/sound/alsa/DocBook/writing-an-alsa-driver.tmpl
+++ b/Documentation/sound/alsa/DocBook/writing-an-alsa-driver.tmpl
@@ -18,8 +18,8 @@
      </affiliation>
     </author>
-     <date>March 6, 2005</date>
+     <date>October 6, 2005</date>
-     <edition>0.3.4</edition>
+     <edition>0.3.5</edition>
    <abstract>
      <para>
@@ -30,7 +30,7 @@
    <legalnotice>
    <para>
-    Copyright (c) 2002-2004  Takashi Iwai <email>tiwai@suse.de</email>
+    Copyright (c) 2002-2005  Takashi Iwai <email>tiwai@suse.de</email>
    </para>
    <para>
@@ -1433,25 +1433,10 @@
        <informalexample>
          <programlisting>
 <![CDATA[
-  if (chip->res_port) {
+  release_and_free_resource(chip->res_port);
-          release_resource(chip->res_port);
-          kfree_nocheck(chip->res_port);
-  }
 ]]>
          </programlisting>
        </informalexample>
-      As you can see, the resource pointer is also to be freed
-      via <function>kfree_nocheck()</function> after
-      <function>release_resource()</function> is called. You
-      cannot use <function>kfree()</function> here, because on ALSA,
-      <function>kfree()</function> may be a wrapper to its own
-      allocator with the memory debugging. Since the resource pointer
-      is allocated externally outside the ALSA, it must be released
-      via the native
-      <function>kfree()</function>.
-      <function>kfree_nocheck()</function> is used for that; it calls
-      the native <function>kfree()</function> without wrapper. 
      </para>
      <para>
@@ -2190,8 +2175,7 @@ struct _snd_pcm_runtime {
        unsigned int rate_den;
        /* -- SW params -- */
-        int tstamp_timespec;            /* use timeval (0) or timespec (1) */
+        struct timespec tstamp_mode;    /* mmap timestamp is updated */
-        snd_pcm_tstamp_t tstamp_mode;   /* mmap timestamp is updated */
        unsigned int period_step;
        unsigned int sleep_min;         /* min ticks to sleep */
        snd_pcm_uframes_t xfer_align;   /* xfer size need to be a multiple */
@@ -3709,8 +3693,7 @@ struct _snd_pcm_runtime {
        <para>
          Here, the chip instance is retrieved via
        <function>snd_kcontrol_chip()</function> macro.  This macro
-        converts from kcontrol-&gt;private_data to the type defined by
+        just accesses to kcontrol-&gt;private_data. The
-        <type>chip_t</type>. The
        kcontrol-&gt;private_data field is 
        given as the argument of <function>snd_ctl_new()</function>
        (see the later subsection
@@ -5998,32 +5981,23 @@ struct _snd_pcm_runtime {
        The first argument is the expression to evaluate, and the
      second argument is the action if it fails. When
      <constant>CONFIG_SND_DEBUG</constant>, is set, it will show an
-      error message such as <computeroutput>BUG? (xxx) (called from
+      error message such as <computeroutput>BUG? (xxx)</computeroutput>
-      yyy)</computeroutput>. When no debug flag is set, this is
+      together with stack trace.
-      ignored. 
      </para>
-    </section>
-    <section id="useful-functions-snd-runtime-check">
-      <title><function>snd_runtime_check()</function></title>
      <para>
-        This macro is quite similar with
+         When no debug flag is set, this macro is ignored. 
-      <function>snd_assert()</function>. Unlike
-      <function>snd_assert()</function>, the expression is always
-      evaluated regardless of
-      <constant>CONFIG_SND_DEBUG</constant>. When
-      <constant>CONFIG_SND_DEBUG</constant> is set, the macro will
-      show a message like <computeroutput>ERROR (xx) (called from
-      yyy)</computeroutput>. 
      </para>
    </section>
    <section id="useful-functions-snd-bug">
      <title><function>snd_BUG()</function></title>
      <para>
-        It calls <function>snd_assert(0,)</function> -- that is, just
+        It shows <computeroutput>BUG?</computeroutput> message and
-      prints the error message at the point. It's useful to show that
+      stack trace as well as <function>snd_assert</function> at the point.
-      a fatal error happens there. 
+      It's useful to show that a fatal error happens there. 
+      </para>
+      <para>
+         When no debug flag is set, this macro is ignored. 
      </para>
    </section>
  </chapter>
diff --git a/Documentation/sparse.txt b/Documentation/sparse.txt
index 1829009db771..3f1c5464b1c9 100644
--- a/Documentation/sparse.txt
+++ b/Documentation/sparse.txt
@@ -41,9 +41,9 @@ sure that bitwise types don't get mixed up (little-endian vs big-endian
 vs cpu-endian vs whatever), and there the constant "0" really _is_
 special.
-Modify top-level Makefile to say
+Use
-CHECK           = sparse -Wbitwise
+        make C=[12] CF=-Wbitwise
 or you don't get any checking at all.
diff --git a/Documentation/video4linux/bttv/README.freeze b/Documentation/video4linux/bttv/README.freeze
index 51f8d4379a94..4259dccc8287 100644
--- a/Documentation/video4linux/bttv/README.freeze
+++ b/Documentation/video4linux/bttv/README.freeze
@@ -27,9 +27,9 @@ information out of a register+stack dump printed by the kernel on
 protection faults (so-called "kernel oops").
 If you run into some kind of deadlock, you can try to dump a call trace
-for each process using sysrq-t (see Documentation/sysrq.txt).  ksymoops
+for each process using sysrq-t (see Documentation/sysrq.txt).
-will translate these dumps into kernel symbols too.  This way it is
+This way it is possible to figure where *exactly* some process in "D"
-possible to figure where *exactly* some process in "D" state is stuck.
+state is stuck.
 I've seen reports that bttv 0.7.x crashes whereas 0.8.x works rock solid
 for some people.  Thus probably a small buglet left somewhere in bttv
diff --git a/Documentation/vm/hugetlbpage.txt b/Documentation/vm/hugetlbpage.txt
index 1b9bcd1fe98b..1ad9af1ca4d0 100644
--- a/Documentation/vm/hugetlbpage.txt
+++ b/Documentation/vm/hugetlbpage.txt
@@ -13,12 +13,13 @@ This optimization is more critical now as bigger and bigger physical memories
 Users can use the huge page support in Linux kernel by either using the mmap
 system call or standard SYSv shared memory system calls (shmget, shmat).
-First the Linux kernel needs to be built with CONFIG_HUGETLB_PAGE (present
+First the Linux kernel needs to be built with the CONFIG_HUGETLBFS
-under Processor types and feature)  and CONFIG_HUGETLBFS (present under file
+(present under "File systems") and CONFIG_HUGETLB_PAGE (selected
-system option on config menu) config options.
+automatically when CONFIG_HUGETLBFS is selected) configuration
+options.
 The kernel built with hugepage support should show the number of configured
-hugepages in the system by running the "cat /proc/meminfo" command.  
+hugepages in the system by running the "cat /proc/meminfo" command.
 /proc/meminfo also provides information about the total number of hugetlb
 pages configured in the kernel.  It also displays information about the
@@ -38,19 +39,19 @@ in the kernel.
 /proc/sys/vm/nr_hugepages indicates the current number of configured hugetlb
 pages in the kernel.  Super user can dynamically request more (or free some
-pre-configured) hugepages. 
+pre-configured) hugepages.
-The allocation( or deallocation) of hugetlb pages is posible only if there are
+The allocation (or deallocation) of hugetlb pages is possible only if there are
 enough physically contiguous free pages in system (freeing of hugepages is
-possible only if there are enough hugetlb pages free that can be transfered 
+possible only if there are enough hugetlb pages free that can be transfered
 back to regular memory pool).
 Pages that are used as hugetlb pages are reserved inside the kernel and can
-not be used for other purposes. 
+not be used for other purposes.
 Once the kernel with Hugetlb page support is built and running, a user can
 use either the mmap system call or shared memory system calls to start using
 the huge pages.  It is required that the system administrator preallocate
-enough memory for huge page purposes.  
+enough memory for huge page purposes.
 Use the following command to dynamically allocate/deallocate hugepages:
@@ -80,9 +81,9 @@ memory (huge pages) allowed for that filesystem (/mnt/huge). The size is
 rounded down to HPAGE_SIZE.  The option nr_inode sets the maximum number of
 inodes that /mnt/huge can use.  If the size or nr_inode options are not
 provided on command line then no limits are set.  For size and nr_inodes
-options, you can use [G|g]/[M|m]/[K|k] to represent giga/mega/kilo. For 
+options, you can use [G|g]/[M|m]/[K|k] to represent giga/mega/kilo. For
-example, size=2K has the same meaning as size=2048. An example is given at 
+example, size=2K has the same meaning as size=2048. An example is given at
-the end of this document. 
+the end of this document.
 read and write system calls are not supported on files that reside on hugetlb
 file systems.