9 files changed, 836 insertions, 465 deletions
diff --git a/Documentation/connector/ucon.c b/Documentation/connector/ucon.c
new file mode 100644
index 000000000000..d738cde2a8d5
--- /dev/null
+++ b/Documentation/connector/ucon.c
@@ -0,0 +1,206 @@
+/*
+ *      ucon.c
+ *
+ * Copyright (c) 2004+ Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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.
+ *
+ * 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
+ */
+#include <asm/types.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/poll.h>
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+#include <arpa/inet.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <time.h>
+#include <linux/connector.h>
+#define DEBUG
+#define NETLINK_CONNECTOR       11
+#ifdef DEBUG
+#define ulog(f, a...) fprintf(stdout, f, ##a)
+#else
+#define ulog(f, a...) do {} while (0)
+#endif
+static int need_exit;
+static __u32 seq;
+static int netlink_send(int s, struct cn_msg *msg)
+{
+        struct nlmsghdr *nlh;
+        unsigned int size;
+        int err;
+        char buf[128];
+        struct cn_msg *m;
+        size = NLMSG_SPACE(sizeof(struct cn_msg) + msg->len);
+        nlh = (struct nlmsghdr *)buf;
+        nlh->nlmsg_seq = seq++;
+        nlh->nlmsg_pid = getpid();
+        nlh->nlmsg_type = NLMSG_DONE;
+        nlh->nlmsg_len = NLMSG_LENGTH(size - sizeof(*nlh));
+        nlh->nlmsg_flags = 0;
+        m = NLMSG_DATA(nlh);
+#if 0
+        ulog("%s: [%08x.%08x] len=%u, seq=%u, ack=%u.\n",
+               __func__, msg->id.idx, msg->id.val, msg->len, msg->seq, msg->ack);
+#endif
+        memcpy(m, msg, sizeof(*m) + msg->len);
+        err = send(s, nlh, size, 0);
+        if (err == -1)
+                ulog("Failed to send: %s [%d].\n",
+                        strerror(errno), errno);
+        return err;
+}
+int main(int argc, char *argv[])
+{
+        int s;
+        char buf[1024];
+        int len;
+        struct nlmsghdr *reply;
+        struct sockaddr_nl l_local;
+        struct cn_msg *data;
+        FILE *out;
+        time_t tm;
+        struct pollfd pfd;
+        if (argc < 2)
+                out = stdout;
+        else {
+                out = fopen(argv[1], "a+");
+                if (!out) {
+                        ulog("Unable to open %s for writing: %s\n",
+                                argv[1], strerror(errno));
+                        out = stdout;
+                }
+        }
+        memset(buf, 0, sizeof(buf));
+        s = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_CONNECTOR);
+        if (s == -1) {
+                perror("socket");
+                return -1;
+        }
+        l_local.nl_family = AF_NETLINK;
+        l_local.nl_groups = 0x123; /* bitmask of requested groups */
+        l_local.nl_pid = 0;
+        if (bind(s, (struct sockaddr *)&l_local, sizeof(struct sockaddr_nl)) == -1) {
+                perror("bind");
+                close(s);
+                return -1;
+        }
+#if 0
+        {
+                int on = 0x57; /* Additional group number */
+                setsockopt(s, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP, &on, sizeof(on));
+        }
+#endif
+        if (0) {
+                int i, j;
+                memset(buf, 0, sizeof(buf));
+                data = (struct cn_msg *)buf;
+                data->id.idx = 0x123;
+                data->id.val = 0x456;
+                data->seq = seq++;
+                data->ack = 0;
+                data->len = 0;
+                for (j=0; j<10; ++j) {
+                        for (i=0; i<1000; ++i) {
+                                len = netlink_send(s, data);
+                        }
+                        ulog("%d messages have been sent to %08x.%08x.\n", i, data->id.idx, data->id.val);
+                }
+                return 0;
+        }
+        pfd.fd = s;
+        while (!need_exit) {
+                pfd.events = POLLIN;
+                pfd.revents = 0;
+                switch (poll(&pfd, 1, -1)) {
+                        case 0:
+                                need_exit = 1;
+                                break;
+                        case -1:
+                                if (errno != EINTR) {
+                                        need_exit = 1;
+                                        break;
+                                }
+                                continue;
+                }
+                if (need_exit)
+                        break;
+                memset(buf, 0, sizeof(buf));
+                len = recv(s, buf, sizeof(buf), 0);
+                if (len == -1) {
+                        perror("recv buf");
+                        close(s);
+                        return -1;
+                }
+                reply = (struct nlmsghdr *)buf;
+                switch (reply->nlmsg_type) {
+                case NLMSG_ERROR:
+                        fprintf(out, "Error message received.\n");
+                        fflush(out);
+                        break;
+                case NLMSG_DONE:
+                        data = (struct cn_msg *)NLMSG_DATA(reply);
+                        time(&tm);
+                        fprintf(out, "%.24s : [%x.%x] [%08u.%08u].\n",
+                                ctime(&tm), data->id.idx, data->id.val, data->seq, data->ack);
+                        fflush(out);
+                        break;
+                default:
+                        break;
+                }
+        }
+        close(s);
+        return 0;
+}
diff --git a/Documentation/cpusets.txt b/Documentation/cpusets.txt
index 159e2a0c3e80..76b44290c154 100644
--- a/Documentation/cpusets.txt
+++ b/Documentation/cpusets.txt
@@ -217,6 +217,12 @@ exclusive cpuset.  Also, the use of a Linux virtual file system (vfs)
 to represent the cpuset hierarchy provides for a familiar permission
 and name space for cpusets, with a minimum of additional kernel code.
+The cpus file in the root (top_cpuset) cpuset is read-only.
+It automatically tracks the value of cpu_online_map, using a CPU
+hotplug notifier.  If and when memory nodes can be hotplugged,
+we expect to make the mems file in the root cpuset read-only
+as well, and have it track the value of node_online_map.
 1.4 What are exclusive cpusets ?
 --------------------------------
diff --git a/Documentation/filesystems/00-INDEX b/Documentation/filesystems/00-INDEX
index 66fdc0744fe0..16dec61d7671 100644
--- a/Documentation/filesystems/00-INDEX
+++ b/Documentation/filesystems/00-INDEX
@@ -62,8 +62,8 @@ ramfs-rootfs-initramfs.txt
        - info on the 'in memory' filesystems ramfs, rootfs and initramfs.
 reiser4.txt
        - info on the Reiser4 filesystem based on dancing tree algorithms.
-relayfs.txt
+relay.txt
-        - info on relayfs, for efficient streaming from kernel to user space.
+        - info on relay, for efficient streaming from kernel to user space.
 romfs.txt
        - description of the ROMFS filesystem.
 smbfs.txt
diff --git a/Documentation/filesystems/relay.txt b/Documentation/filesystems/relay.txt
new file mode 100644
index 000000000000..d6788dae0349
--- /dev/null
+++ b/Documentation/filesystems/relay.txt
@@ -0,0 +1,479 @@
+relay interface (formerly relayfs)
+==================================
+The relay interface provides a means for kernel applications to
+efficiently log and transfer large quantities of data from the kernel
+to userspace via user-defined 'relay channels'.
+A 'relay channel' is a kernel->user data relay mechanism implemented
+as a set of per-cpu kernel buffers ('channel buffers'), each
+represented as a regular file ('relay file') in user space.  Kernel
+clients write into the channel buffers using efficient write
+functions; these automatically log into the current cpu's channel
+buffer.  User space applications mmap() or read() from the relay files
+and retrieve the data as it becomes available.  The relay files
+themselves are files created in a host filesystem, e.g. debugfs, and
+are associated with the channel buffers using the API described below.
+The format of the data logged into the channel buffers is completely
+up to the kernel client; the relay interface does however provide
+hooks which allow kernel clients to impose some structure on the
+buffer data.  The relay interface doesn't implement any form of data
+filtering - this also is left to the kernel client.  The purpose is to
+keep things as simple as possible.
+This document provides an overview of the relay interface API.  The
+details of the function parameters are documented along with the
+functions in the relay interface code - please see that for details.
+Semantics
+=========
+Each relay channel has one buffer per CPU, each buffer has one or more
+sub-buffers.  Messages are written to the first sub-buffer until it is
+too full to contain a new message, in which case it it is written to
+the next (if available).  Messages are never split across sub-buffers.
+At this point, userspace can be notified so it empties the first
+sub-buffer, while the kernel continues writing to the next.
+When notified that a sub-buffer is full, the kernel knows how many
+bytes of it are padding i.e. unused space occurring because a complete
+message couldn't fit into a sub-buffer.  Userspace can use this
+knowledge to copy only valid data.
+After copying it, userspace can notify the kernel that a sub-buffer
+has been consumed.
+A relay channel can operate in a mode where it will overwrite data not
+yet collected by userspace, and not wait for it to be consumed.
+The relay channel itself does not provide for communication of such
+data between userspace and kernel, allowing the kernel side to remain
+simple and not impose a single interface on userspace.  It does
+provide a set of examples and a separate helper though, described
+below.
+The read() interface both removes padding and internally consumes the
+read sub-buffers; thus in cases where read(2) is being used to drain
+the channel buffers, special-purpose communication between kernel and
+user isn't necessary for basic operation.
+One of the major goals of the relay interface is to provide a low
+overhead mechanism for conveying kernel data to userspace.  While the
+read() interface is easy to use, it's not as efficient as the mmap()
+approach; the example code attempts to make the tradeoff between the
+two approaches as small as possible.
+klog and relay-apps example code
+================================
+The relay interface itself is ready to use, but to make things easier,
+a couple simple utility functions and a set of examples are provided.
+The relay-apps example tarball, available on the relay sourceforge
+site, contains a set of self-contained examples, each consisting of a
+pair of .c files containing boilerplate code for each of the user and
+kernel sides of a relay application.  When combined these two sets of
+boilerplate code provide glue to easily stream data to disk, without
+having to bother with mundane housekeeping chores.
+The 'klog debugging functions' patch (klog.patch in the relay-apps
+tarball) provides a couple of high-level logging functions to the
+kernel which allow writing formatted text or raw data to a channel,
+regardless of whether a channel to write into exists or not, or even
+whether the relay interface is compiled into the kernel or not.  These
+functions allow you to put unconditional 'trace' statements anywhere
+in the kernel or kernel modules; only when there is a 'klog handler'
+registered will data actually be logged (see the klog and kleak
+examples for details).
+It is of course possible to use the relay interface from scratch,
+i.e. without using any of the relay-apps example code or klog, but
+you'll have to implement communication between userspace and kernel,
+allowing both to convey the state of buffers (full, empty, amount of
+padding).  The read() interface both removes padding and internally
+consumes the read sub-buffers; thus in cases where read(2) is being
+used to drain the channel buffers, special-purpose communication
+between kernel and user isn't necessary for basic operation.  Things
+such as buffer-full conditions would still need to be communicated via
+some channel though.
+klog and the relay-apps examples can be found in the relay-apps
+tarball on http://relayfs.sourceforge.net
+The relay interface user space API
+==================================
+The relay interface implements basic file operations for user space
+access to relay channel buffer data.  Here are the file operations
+that are available and some comments regarding their behavior:
+open()      enables user to open an _existing_ channel buffer.
+mmap()      results in channel buffer being mapped into the caller's
+            memory space. Note that you can't do a partial mmap - you
+            must map the entire file, which is NRBUF * SUBBUFSIZE.
+read()      read the contents of a channel buffer.  The bytes read are
+            'consumed' by the reader, i.e. they won't be available
+            again to subsequent reads.  If the channel is being used
+            in no-overwrite mode (the default), it can be read at any
+            time even if there's an active kernel writer.  If the
+            channel is being used in overwrite mode and there are
+            active channel writers, results may be unpredictable -
+            users should make sure that all logging to the channel has
+            ended before using read() with overwrite mode.  Sub-buffer
+            padding is automatically removed and will not be seen by
+            the reader.
+sendfile()  transfer data from a channel buffer to an output file
+            descriptor. Sub-buffer padding is automatically removed
+            and will not be seen by the reader.
+poll()      POLLIN/POLLRDNORM/POLLERR supported.  User applications are
+            notified when sub-buffer boundaries are crossed.
+close()     decrements the channel buffer's refcount.  When the refcount
+            reaches 0, i.e. when no process or kernel client has the
+            buffer open, the channel buffer is freed.
+In order for a user application to make use of relay files, the
+host filesystem must be mounted.  For example,
+        mount -t debugfs debugfs /debug
+NOTE:   the host filesystem doesn't need to be mounted for kernel
+        clients to create or use channels - it only needs to be
+        mounted when user space applications need access to the buffer
+        data.
+The relay interface kernel API
+==============================
+Here's a summary of the API the relay interface provides to in-kernel clients:
+TBD(curr. line MT:/API/)
+  channel management functions:
+    relay_open(base_filename, parent, subbuf_size, n_subbufs,
+               callbacks)
+    relay_close(chan)
+    relay_flush(chan)
+    relay_reset(chan)
+  channel management typically called on instigation of userspace:
+    relay_subbufs_consumed(chan, cpu, subbufs_consumed)
+  write functions:
+    relay_write(chan, data, length)
+    __relay_write(chan, data, length)
+    relay_reserve(chan, length)
+  callbacks:
+    subbuf_start(buf, subbuf, prev_subbuf, prev_padding)
+    buf_mapped(buf, filp)
+    buf_unmapped(buf, filp)
+    create_buf_file(filename, parent, mode, buf, is_global)
+    remove_buf_file(dentry)
+  helper functions:
+    relay_buf_full(buf)
+    subbuf_start_reserve(buf, length)
+Creating a channel
+------------------
+relay_open() is used to create a channel, along with its per-cpu
+channel buffers.  Each channel buffer will have an associated file
+created for it in the host filesystem, which can be and mmapped or
+read from in user space.  The files are named basename0...basenameN-1
+where N is the number of online cpus, and by default will be created
+in the root of the filesystem (if the parent param is NULL).  If you
+want a directory structure to contain your relay files, you should
+create it using the host filesystem's directory creation function,
+e.g. debugfs_create_dir(), and pass the parent directory to
+relay_open().  Users are responsible for cleaning up any directory
+structure they create, when the channel is closed - again the host
+filesystem's directory removal functions should be used for that,
+e.g. debugfs_remove().
+In order for a channel to be created and the host filesystem's files
+associated with its channel buffers, the user must provide definitions
+for two callback functions, create_buf_file() and remove_buf_file().
+create_buf_file() is called once for each per-cpu buffer from
+relay_open() and allows the user to create the file which will be used
+to represent the corresponding channel buffer.  The callback should
+return the dentry of the file created to represent the channel buffer.
+remove_buf_file() must also be defined; it's responsible for deleting
+the file(s) created in create_buf_file() and is called during
+relay_close().
+Here are some typical definitions for these callbacks, in this case
+using debugfs:
+/*
+ * create_buf_file() callback.  Creates relay file in debugfs.
+ */
+static struct dentry *create_buf_file_handler(const char *filename,
+                                              struct dentry *parent,
+                                              int mode,
+                                              struct rchan_buf *buf,
+                                              int *is_global)
+{
+        return debugfs_create_file(filename, mode, parent, buf,
+                                   &relay_file_operations);
+}
+/*
+ * remove_buf_file() callback.  Removes relay file from debugfs.
+ */
+static int remove_buf_file_handler(struct dentry *dentry)
+{
+        debugfs_remove(dentry);
+        return 0;
+}
+/*
+ * relay interface callbacks
+ */
+static struct rchan_callbacks relay_callbacks =
+{
+        .create_buf_file = create_buf_file_handler,
+        .remove_buf_file = remove_buf_file_handler,
+};
+And an example relay_open() invocation using them:
+  chan = relay_open("cpu", NULL, SUBBUF_SIZE, N_SUBBUFS, &relay_callbacks);
+If the create_buf_file() callback fails, or isn't defined, channel
+creation and thus relay_open() will fail.
+The total size of each per-cpu buffer is calculated by multiplying the
+number of sub-buffers by the sub-buffer size passed into relay_open().
+The idea behind sub-buffers is that they're basically an extension of
+double-buffering to N buffers, and they also allow applications to
+easily implement random-access-on-buffer-boundary schemes, which can
+be important for some high-volume applications.  The number and size
+of sub-buffers is completely dependent on the application and even for
+the same application, different conditions will warrant different
+values for these parameters at different times.  Typically, the right
+values to use are best decided after some experimentation; in general,
+though, it's safe to assume that having only 1 sub-buffer is a bad
+idea - you're guaranteed to either overwrite data or lose events
+depending on the channel mode being used.
+The create_buf_file() implementation can also be defined in such a way
+as to allow the creation of a single 'global' buffer instead of the
+default per-cpu set.  This can be useful for applications interested
+mainly in seeing the relative ordering of system-wide events without
+the need to bother with saving explicit timestamps for the purpose of
+merging/sorting per-cpu files in a postprocessing step.
+To have relay_open() create a global buffer, the create_buf_file()
+implementation should set the value of the is_global outparam to a
+non-zero value in addition to creating the file that will be used to
+represent the single buffer.  In the case of a global buffer,
+create_buf_file() and remove_buf_file() will be called only once.  The
+normal channel-writing functions, e.g. relay_write(), can still be
+used - writes from any cpu will transparently end up in the global
+buffer - but since it is a global buffer, callers should make sure
+they use the proper locking for such a buffer, either by wrapping
+writes in a spinlock, or by copying a write function from relay.h and
+creating a local version that internally does the proper locking.
+Channel 'modes'
+---------------
+relay channels can be used in either of two modes - 'overwrite' or
+'no-overwrite'.  The mode is entirely determined by the implementation
+of the subbuf_start() callback, as described below.  The default if no
+subbuf_start() callback is defined is 'no-overwrite' mode.  If the
+default mode suits your needs, and you plan to use the read()
+interface to retrieve channel data, you can ignore the details of this
+section, as it pertains mainly to mmap() implementations.
+In 'overwrite' mode, also known as 'flight recorder' mode, writes
+continuously cycle around the buffer and will never fail, but will
+unconditionally overwrite old data regardless of whether it's actually
+been consumed.  In no-overwrite mode, writes will fail, i.e. data will
+be lost, if the number of unconsumed sub-buffers equals the total
+number of sub-buffers in the channel.  It should be clear that if
+there is no consumer or if the consumer can't consume sub-buffers fast
+enough, data will be lost in either case; the only difference is
+whether data is lost from the beginning or the end of a buffer.
+As explained above, a relay channel is made of up one or more
+per-cpu channel buffers, each implemented as a circular buffer
+subdivided into one or more sub-buffers.  Messages are written into
+the current sub-buffer of the channel's current per-cpu buffer via the
+write functions described below.  Whenever a message can't fit into
+the current sub-buffer, because there's no room left for it, the
+client is notified via the subbuf_start() callback that a switch to a
+new sub-buffer is about to occur.  The client uses this callback to 1)
+initialize the next sub-buffer if appropriate 2) finalize the previous
+sub-buffer if appropriate and 3) return a boolean value indicating
+whether or not to actually move on to the next sub-buffer.
+To implement 'no-overwrite' mode, the userspace client would provide
+an implementation of the subbuf_start() callback something like the
+following:
+static int subbuf_start(struct rchan_buf *buf,
+                        void *subbuf,
+                        void *prev_subbuf,
+                        unsigned int prev_padding)
+{
+        if (prev_subbuf)
+                *((unsigned *)prev_subbuf) = prev_padding;
+        if (relay_buf_full(buf))
+                return 0;
+        subbuf_start_reserve(buf, sizeof(unsigned int));
+        return 1;
+}
+If the current buffer is full, i.e. all sub-buffers remain unconsumed,
+the callback returns 0 to indicate that the buffer switch should not
+occur yet, i.e. until the consumer has had a chance to read the
+current set of ready sub-buffers.  For the relay_buf_full() function
+to make sense, the consumer is reponsible for notifying the relay
+interface when sub-buffers have been consumed via
+relay_subbufs_consumed().  Any subsequent attempts to write into the
+buffer will again invoke the subbuf_start() callback with the same
+parameters; only when the consumer has consumed one or more of the
+ready sub-buffers will relay_buf_full() return 0, in which case the
+buffer switch can continue.
+The implementation of the subbuf_start() callback for 'overwrite' mode
+would be very similar:
+static int subbuf_start(struct rchan_buf *buf,
+                        void *subbuf,
+                        void *prev_subbuf,
+                        unsigned int prev_padding)
+{
+        if (prev_subbuf)
+                *((unsigned *)prev_subbuf) = prev_padding;
+        subbuf_start_reserve(buf, sizeof(unsigned int));
+        return 1;
+}
+In this case, the relay_buf_full() check is meaningless and the
+callback always returns 1, causing the buffer switch to occur
+unconditionally.  It's also meaningless for the client to use the
+relay_subbufs_consumed() function in this mode, as it's never
+consulted.
+The default subbuf_start() implementation, used if the client doesn't
+define any callbacks, or doesn't define the subbuf_start() callback,
+implements the simplest possible 'no-overwrite' mode, i.e. it does
+nothing but return 0.
+Header information can be reserved at the beginning of each sub-buffer
+by calling the subbuf_start_reserve() helper function from within the
+subbuf_start() callback.  This reserved area can be used to store
+whatever information the client wants.  In the example above, room is
+reserved in each sub-buffer to store the padding count for that
+sub-buffer.  This is filled in for the previous sub-buffer in the
+subbuf_start() implementation; the padding value for the previous
+sub-buffer is passed into the subbuf_start() callback along with a
+pointer to the previous sub-buffer, since the padding value isn't
+known until a sub-buffer is filled.  The subbuf_start() callback is
+also called for the first sub-buffer when the channel is opened, to
+give the client a chance to reserve space in it.  In this case the
+previous sub-buffer pointer passed into the callback will be NULL, so
+the client should check the value of the prev_subbuf pointer before
+writing into the previous sub-buffer.
+Writing to a channel
+--------------------
+Kernel clients write data into the current cpu's channel buffer using
+relay_write() or __relay_write().  relay_write() is the main logging
+function - it uses local_irqsave() to protect the buffer and should be
+used if you might be logging from interrupt context.  If you know
+you'll never be logging from interrupt context, you can use
+__relay_write(), which only disables preemption.  These functions
+don't return a value, so you can't determine whether or not they
+failed - the assumption is that you wouldn't want to check a return
+value in the fast logging path anyway, and that they'll always succeed
+unless the buffer is full and no-overwrite mode is being used, in
+which case you can detect a failed write in the subbuf_start()
+callback by calling the relay_buf_full() helper function.
+relay_reserve() is used to reserve a slot in a channel buffer which
+can be written to later.  This would typically be used in applications
+that need to write directly into a channel buffer without having to
+stage data in a temporary buffer beforehand.  Because the actual write
+may not happen immediately after the slot is reserved, applications
+using relay_reserve() can keep a count of the number of bytes actually
+written, either in space reserved in the sub-buffers themselves or as
+a separate array.  See the 'reserve' example in the relay-apps tarball
+at http://relayfs.sourceforge.net for an example of how this can be
+done.  Because the write is under control of the client and is
+separated from the reserve, relay_reserve() doesn't protect the buffer
+at all - it's up to the client to provide the appropriate
+synchronization when using relay_reserve().
+Closing a channel
+-----------------
+The client calls relay_close() when it's finished using the channel.
+The channel and its associated buffers are destroyed when there are no
+longer any references to any of the channel buffers.  relay_flush()
+forces a sub-buffer switch on all the channel buffers, and can be used
+to finalize and process the last sub-buffers before the channel is
+closed.
+Misc
+----
+Some applications may want to keep a channel around and re-use it
+rather than open and close a new channel for each use.  relay_reset()
+can be used for this purpose - it resets a channel to its initial
+state without reallocating channel buffer memory or destroying
+existing mappings.  It should however only be called when it's safe to
+do so, i.e. when the channel isn't currently being written to.
+Finally, there are a couple of utility callbacks that can be used for
+different purposes.  buf_mapped() is called whenever a channel buffer
+is mmapped from user space and buf_unmapped() is called when it's
+unmapped.  The client can use this notification to trigger actions
+within the kernel application, such as enabling/disabling logging to
+the channel.
+Resources
+=========
+For news, example code, mailing list, etc. see the relay interface homepage:
+    http://relayfs.sourceforge.net
+Credits
+=======
+The ideas and specs for the relay interface came about as a result of
+discussions on tracing involving the following:
+Michel Dagenais         <michel.dagenais@polymtl.ca>
+Richard Moore           <richardj_moore@uk.ibm.com>
+Bob Wisniewski          <bob@watson.ibm.com>
+Karim Yaghmour          <karim@opersys.com>
+Tom Zanussi             <zanussi@us.ibm.com>
+Also thanks to Hubertus Franke for a lot of useful suggestions and bug
+reports.
diff --git a/Documentation/filesystems/relayfs.txt b/Documentation/filesystems/relayfs.txt
deleted file mode 100644
index 5832377b7340..000000000000
--- a/Documentation/filesystems/relayfs.txt
+++ /dev/null
@@ -1,442 +0,0 @@
-relayfs - a high-speed data relay filesystem
-============================================
-relayfs is a filesystem designed to provide an efficient mechanism for
-tools and facilities to relay large and potentially sustained streams
-of data from kernel space to user space.
-The main abstraction of relayfs is the 'channel'.  A channel consists
-of a set of per-cpu kernel buffers each represented by a file in the
-relayfs filesystem.  Kernel clients write into a channel using
-efficient write functions which automatically log to the current cpu's
-channel buffer.  User space applications mmap() the per-cpu files and
-retrieve the data as it becomes available.
-The format of the data logged into the channel buffers is completely
-up to the relayfs client; relayfs does however provide hooks which
-allow clients to impose some structure on the buffer data.  Nor does
-relayfs implement any form of data filtering - this also is left to
-the client.  The purpose is to keep relayfs as simple as possible.
-This document provides an overview of the relayfs API.  The details of
-the function parameters are documented along with the functions in the
-filesystem code - please see that for details.
-Semantics
-=========
-Each relayfs channel has one buffer per CPU, each buffer has one or
-more sub-buffers. Messages are written to the first sub-buffer until
-it is too full to contain a new message, in which case it it is
-written to the next (if available).  Messages are never split across
-sub-buffers.  At this point, userspace can be notified so it empties
-the first sub-buffer, while the kernel continues writing to the next.
-When notified that a sub-buffer is full, the kernel knows how many
-bytes of it are padding i.e. unused.  Userspace can use this knowledge
-to copy only valid data.
-After copying it, userspace can notify the kernel that a sub-buffer
-has been consumed.
-relayfs can operate in a mode where it will overwrite data not yet
-collected by userspace, and not wait for it to consume it.
-relayfs itself does not provide for communication of such data between
-userspace and kernel, allowing the kernel side to remain simple and
-not impose a single interface on userspace. It does provide a set of
-examples and a separate helper though, described below.
-klog and relay-apps example code
-================================
-relayfs itself is ready to use, but to make things easier, a couple
-simple utility functions and a set of examples are provided.
-The relay-apps example tarball, available on the relayfs sourceforge
-site, contains a set of self-contained examples, each consisting of a
-pair of .c files containing boilerplate code for each of the user and
-kernel sides of a relayfs application; combined these two sets of
-boilerplate code provide glue to easily stream data to disk, without
-having to bother with mundane housekeeping chores.
-The 'klog debugging functions' patch (klog.patch in the relay-apps
-tarball) provides a couple of high-level logging functions to the
-kernel which allow writing formatted text or raw data to a channel,
-regardless of whether a channel to write into exists or not, or
-whether relayfs is compiled into the kernel or is configured as a
-module.  These functions allow you to put unconditional 'trace'
-statements anywhere in the kernel or kernel modules; only when there
-is a 'klog handler' registered will data actually be logged (see the
-klog and kleak examples for details).
-It is of course possible to use relayfs from scratch i.e. without
-using any of the relay-apps example code or klog, but you'll have to
-implement communication between userspace and kernel, allowing both to
-convey the state of buffers (full, empty, amount of padding).
-klog and the relay-apps examples can be found in the relay-apps
-tarball on http://relayfs.sourceforge.net
-The relayfs user space API
-==========================
-relayfs implements basic file operations for user space access to
-relayfs channel buffer data.  Here are the file operations that are
-available and some comments regarding their behavior:
-open()   enables user to open an _existing_ buffer.
-mmap()   results in channel buffer being mapped into the caller's
-         memory space. Note that you can't do a partial mmap - you must
-         map the entire file, which is NRBUF * SUBBUFSIZE.
-read()   read the contents of a channel buffer.  The bytes read are
-         'consumed' by the reader i.e. they won't be available again
-         to subsequent reads.  If the channel is being used in
-         no-overwrite mode (the default), it can be read at any time
-         even if there's an active kernel writer.  If the channel is
-         being used in overwrite mode and there are active channel
-         writers, results may be unpredictable - users should make
-         sure that all logging to the channel has ended before using
-         read() with overwrite mode.
-poll()   POLLIN/POLLRDNORM/POLLERR supported.  User applications are
-         notified when sub-buffer boundaries are crossed.
-close() decrements the channel buffer's refcount.  When the refcount
-        reaches 0 i.e. when no process or kernel client has the buffer
-        open, the channel buffer is freed.
-In order for a user application to make use of relayfs files, the
-relayfs filesystem must be mounted.  For example,
-        mount -t relayfs relayfs /mnt/relay
-NOTE:   relayfs doesn't need to be mounted for kernel clients to create
-        or use channels - it only needs to be mounted when user space
-        applications need access to the buffer data.
-The relayfs kernel API
-======================
-Here's a summary of the API relayfs provides to in-kernel clients:
-  channel management functions:
-    relay_open(base_filename, parent, subbuf_size, n_subbufs,
-               callbacks)
-    relay_close(chan)
-    relay_flush(chan)
-    relay_reset(chan)
-    relayfs_create_dir(name, parent)
-    relayfs_remove_dir(dentry)
-    relayfs_create_file(name, parent, mode, fops, data)
-    relayfs_remove_file(dentry)
-  channel management typically called on instigation of userspace:
-    relay_subbufs_consumed(chan, cpu, subbufs_consumed)
-  write functions:
-    relay_write(chan, data, length)
-    __relay_write(chan, data, length)
-    relay_reserve(chan, length)
-  callbacks:
-    subbuf_start(buf, subbuf, prev_subbuf, prev_padding)
-    buf_mapped(buf, filp)
-    buf_unmapped(buf, filp)
-    create_buf_file(filename, parent, mode, buf, is_global)
-    remove_buf_file(dentry)
-  helper functions:
-    relay_buf_full(buf)
-    subbuf_start_reserve(buf, length)
-Creating a channel
------------------
-relay_open() is used to create a channel, along with its per-cpu
-channel buffers.  Each channel buffer will have an associated file
-created for it in the relayfs filesystem, which can be opened and
-mmapped from user space if desired.  The files are named
-basename0...basenameN-1 where N is the number of online cpus, and by
-default will be created in the root of the filesystem.  If you want a
-directory structure to contain your relayfs files, you can create it
-with relayfs_create_dir() and pass the parent directory to
-relay_open().  Clients are responsible for cleaning up any directory
-structure they create when the channel is closed - use
-relayfs_remove_dir() for that.
-The total size of each per-cpu buffer is calculated by multiplying the
-number of sub-buffers by the sub-buffer size passed into relay_open().
-The idea behind sub-buffers is that they're basically an extension of
-double-buffering to N buffers, and they also allow applications to
-easily implement random-access-on-buffer-boundary schemes, which can
-be important for some high-volume applications.  The number and size
-of sub-buffers is completely dependent on the application and even for
-the same application, different conditions will warrant different
-values for these parameters at different times.  Typically, the right
-values to use are best decided after some experimentation; in general,
-though, it's safe to assume that having only 1 sub-buffer is a bad
-idea - you're guaranteed to either overwrite data or lose events
-depending on the channel mode being used.
-Channel 'modes'
---------------
-relayfs channels can be used in either of two modes - 'overwrite' or
-'no-overwrite'.  The mode is entirely determined by the implementation
-of the subbuf_start() callback, as described below.  In 'overwrite'
-mode, also known as 'flight recorder' mode, writes continuously cycle
-around the buffer and will never fail, but will unconditionally
-overwrite old data regardless of whether it's actually been consumed.
-In no-overwrite mode, writes will fail i.e. data will be lost, if the
-number of unconsumed sub-buffers equals the total number of
-sub-buffers in the channel.  It should be clear that if there is no
-consumer or if the consumer can't consume sub-buffers fast enought,
-data will be lost in either case; the only difference is whether data
-is lost from the beginning or the end of a buffer.
-As explained above, a relayfs channel is made of up one or more
-per-cpu channel buffers, each implemented as a circular buffer
-subdivided into one or more sub-buffers.  Messages are written into
-the current sub-buffer of the channel's current per-cpu buffer via the
-write functions described below.  Whenever a message can't fit into
-the current sub-buffer, because there's no room left for it, the
-client is notified via the subbuf_start() callback that a switch to a
-new sub-buffer is about to occur.  The client uses this callback to 1)
-initialize the next sub-buffer if appropriate 2) finalize the previous
-sub-buffer if appropriate and 3) return a boolean value indicating
-whether or not to actually go ahead with the sub-buffer switch.
-To implement 'no-overwrite' mode, the userspace client would provide
-an implementation of the subbuf_start() callback something like the
-following:
-static int subbuf_start(struct rchan_buf *buf,
-                        void *subbuf,
-                        void *prev_subbuf,
-                        unsigned int prev_padding)
-{
-        if (prev_subbuf)
-                *((unsigned *)prev_subbuf) = prev_padding;
-        if (relay_buf_full(buf))
-                return 0;
-        subbuf_start_reserve(buf, sizeof(unsigned int));
-        return 1;
-}
-If the current buffer is full i.e. all sub-buffers remain unconsumed,
-the callback returns 0 to indicate that the buffer switch should not
-occur yet i.e. until the consumer has had a chance to read the current
-set of ready sub-buffers.  For the relay_buf_full() function to make
-sense, the consumer is reponsible for notifying relayfs when
-sub-buffers have been consumed via relay_subbufs_consumed().  Any
-subsequent attempts to write into the buffer will again invoke the
-subbuf_start() callback with the same parameters; only when the
-consumer has consumed one or more of the ready sub-buffers will
-relay_buf_full() return 0, in which case the buffer switch can
-continue.
-The implementation of the subbuf_start() callback for 'overwrite' mode
-would be very similar:
-static int subbuf_start(struct rchan_buf *buf,
-                        void *subbuf,
-                        void *prev_subbuf,
-                        unsigned int prev_padding)
-{
-        if (prev_subbuf)
-                *((unsigned *)prev_subbuf) = prev_padding;
-        subbuf_start_reserve(buf, sizeof(unsigned int));
-        return 1;
-}
-In this case, the relay_buf_full() check is meaningless and the
-callback always returns 1, causing the buffer switch to occur
-unconditionally.  It's also meaningless for the client to use the
-relay_subbufs_consumed() function in this mode, as it's never
-consulted.
-The default subbuf_start() implementation, used if the client doesn't
-define any callbacks, or doesn't define the subbuf_start() callback,
-implements the simplest possible 'no-overwrite' mode i.e. it does
-nothing but return 0.
-Header information can be reserved at the beginning of each sub-buffer
-by calling the subbuf_start_reserve() helper function from within the
-subbuf_start() callback.  This reserved area can be used to store
-whatever information the client wants.  In the example above, room is
-reserved in each sub-buffer to store the padding count for that
-sub-buffer.  This is filled in for the previous sub-buffer in the
-subbuf_start() implementation; the padding value for the previous
-sub-buffer is passed into the subbuf_start() callback along with a
-pointer to the previous sub-buffer, since the padding value isn't
-known until a sub-buffer is filled.  The subbuf_start() callback is
-also called for the first sub-buffer when the channel is opened, to
-give the client a chance to reserve space in it.  In this case the
-previous sub-buffer pointer passed into the callback will be NULL, so
-the client should check the value of the prev_subbuf pointer before
-writing into the previous sub-buffer.
-Writing to a channel
--------------------
-kernel clients write data into the current cpu's channel buffer using
-relay_write() or __relay_write().  relay_write() is the main logging
-function - it uses local_irqsave() to protect the buffer and should be
-used if you might be logging from interrupt context.  If you know
-you'll never be logging from interrupt context, you can use
-__relay_write(), which only disables preemption.  These functions
-don't return a value, so you can't determine whether or not they
-failed - the assumption is that you wouldn't want to check a return
-value in the fast logging path anyway, and that they'll always succeed
-unless the buffer is full and no-overwrite mode is being used, in
-which case you can detect a failed write in the subbuf_start()
-callback by calling the relay_buf_full() helper function.
-relay_reserve() is used to reserve a slot in a channel buffer which
-can be written to later.  This would typically be used in applications
-that need to write directly into a channel buffer without having to
-stage data in a temporary buffer beforehand.  Because the actual write
-may not happen immediately after the slot is reserved, applications
-using relay_reserve() can keep a count of the number of bytes actually
-written, either in space reserved in the sub-buffers themselves or as
-a separate array.  See the 'reserve' example in the relay-apps tarball
-at http://relayfs.sourceforge.net for an example of how this can be
-done.  Because the write is under control of the client and is
-separated from the reserve, relay_reserve() doesn't protect the buffer
-at all - it's up to the client to provide the appropriate
-synchronization when using relay_reserve().
-Closing a channel
-----------------
-The client calls relay_close() when it's finished using the channel.
-The channel and its associated buffers are destroyed when there are no
-longer any references to any of the channel buffers.  relay_flush()
-forces a sub-buffer switch on all the channel buffers, and can be used
-to finalize and process the last sub-buffers before the channel is
-closed.
-Creating non-relay files
------------------------
-relay_open() automatically creates files in the relayfs filesystem to
-represent the per-cpu kernel buffers; it's often useful for
-applications to be able to create their own files alongside the relay
-files in the relayfs filesystem as well e.g. 'control' files much like
-those created in /proc or debugfs for similar purposes, used to
-communicate control information between the kernel and user sides of a
-relayfs application.  For this purpose the relayfs_create_file() and
-relayfs_remove_file() API functions exist.  For relayfs_create_file(),
-the caller passes in a set of user-defined file operations to be used
-for the file and an optional void * to a user-specified data item,
-which will be accessible via inode->u.generic_ip (see the relay-apps
-tarball for examples).  The file_operations are a required parameter
-to relayfs_create_file() and thus the semantics of these files are
-completely defined by the caller.
-See the relay-apps tarball at http://relayfs.sourceforge.net for
-examples of how these non-relay files are meant to be used.
-Creating relay files in other filesystems
-----------------------------------------
-By default of course, relay_open() creates relay files in the relayfs
-filesystem.  Because relay_file_operations is exported, however, it's
-also possible to create and use relay files in other pseudo-filesytems
-such as debugfs.
-For this purpose, two callback functions are provided,
-create_buf_file() and remove_buf_file().  create_buf_file() is called
-once for each per-cpu buffer from relay_open() to allow the client to
-create a file to be used to represent the corresponding buffer; if
-this callback is not defined, the default implementation will create
-and return a file in the relayfs filesystem to represent the buffer.
-The callback should return the dentry of the file created to represent
-the relay buffer.  Note that the parent directory passed to
-relay_open() (and passed along to the callback), if specified, must
-exist in the same filesystem the new relay file is created in.  If
-create_buf_file() is defined, remove_buf_file() must also be defined;
-it's responsible for deleting the file(s) created in create_buf_file()
-and is called during relay_close().
-The create_buf_file() implementation can also be defined in such a way
-as to allow the creation of a single 'global' buffer instead of the
-default per-cpu set.  This can be useful for applications interested
-mainly in seeing the relative ordering of system-wide events without
-the need to bother with saving explicit timestamps for the purpose of
-merging/sorting per-cpu files in a postprocessing step.
-To have relay_open() create a global buffer, the create_buf_file()
-implementation should set the value of the is_global outparam to a
-non-zero value in addition to creating the file that will be used to
-represent the single buffer.  In the case of a global buffer,
-create_buf_file() and remove_buf_file() will be called only once.  The
-normal channel-writing functions e.g. relay_write() can still be used
- writes from any cpu will transparently end up in the global buffer -
-but since it is a global buffer, callers should make sure they use the
-proper locking for such a buffer, either by wrapping writes in a
-spinlock, or by copying a write function from relayfs_fs.h and
-creating a local version that internally does the proper locking.
-See the 'exported-relayfile' examples in the relay-apps tarball for
-examples of creating and using relay files in debugfs.
-Misc
----
-Some applications may want to keep a channel around and re-use it
-rather than open and close a new channel for each use.  relay_reset()
-can be used for this purpose - it resets a channel to its initial
-state without reallocating channel buffer memory or destroying
-existing mappings.  It should however only be called when it's safe to
-do so i.e. when the channel isn't currently being written to.
-Finally, there are a couple of utility callbacks that can be used for
-different purposes.  buf_mapped() is called whenever a channel buffer
-is mmapped from user space and buf_unmapped() is called when it's
-unmapped.  The client can use this notification to trigger actions
-within the kernel application, such as enabling/disabling logging to
-the channel.
-Resources
-=========
-For news, example code, mailing list, etc. see the relayfs homepage:
-    http://relayfs.sourceforge.net
-Credits
-=======
-The ideas and specs for relayfs came about as a result of discussions
-on tracing involving the following:
-Michel Dagenais         <michel.dagenais@polymtl.ca>
-Richard Moore           <richardj_moore@uk.ibm.com>
-Bob Wisniewski          <bob@watson.ibm.com>
-Karim Yaghmour          <karim@opersys.com>
-Tom Zanussi             <zanussi@us.ibm.com>
-Also thanks to Hubertus Franke for a lot of useful suggestions and bug
-reports.
diff --git a/Documentation/input/joystick.txt b/Documentation/input/joystick.txt
index d53b857a3710..841c353297e6 100644
--- a/Documentation/input/joystick.txt
+++ b/Documentation/input/joystick.txt
@@ -39,7 +39,6 @@ them. Bug reports and success stories are also welcome.
  The input project website is at:
-        http://www.suse.cz/development/input/
        http://atrey.karlin.mff.cuni.cz/~vojtech/input/
  There is also a mailing list for the driver at:
diff --git a/Documentation/scsi/ChangeLog.megaraid b/Documentation/scsi/ChangeLog.megaraid
index c173806c91fa..a056bbe67c7e 100644
--- a/Documentation/scsi/ChangeLog.megaraid
+++ b/Documentation/scsi/ChangeLog.megaraid
@@ -1,3 +1,126 @@
+Release Date    : Fri May 19 09:31:45 EST 2006 - Seokmann Ju <sju@lsil.com>
+Current Version : 2.20.4.9 (scsi module), 2.20.2.6 (cmm module)
+Older Version   : 2.20.4.8 (scsi module), 2.20.2.6 (cmm module)
+1.      Fixed a bug in megaraid_init_mbox().
+        Customer reported "garbage in file on x86_64 platform".
+        Root Cause: the driver registered controllers as 64-bit DMA capable
+        for those which are not support it.
+        Fix: Made change in the function inserting identification machanism
+        identifying 64-bit DMA capable controllers.
+        > -----Original Message-----
+        > From: Vasily Averin [mailto:vvs@sw.ru]
+        > Sent: Thursday, May 04, 2006 2:49 PM
+        > To: linux-scsi@vger.kernel.org; Kolli, Neela; Mukker, Atul;
+        > Ju, Seokmann; Bagalkote, Sreenivas;
+        > James.Bottomley@SteelEye.com; devel@openvz.org
+        > Subject: megaraid_mbox: garbage in file
+        >
+        > Hello all,
+        >
+        > I've investigated customers claim on the unstable work of
+        > their node and found a
+        > strange effect: reading from some files leads to the
+        >  "attempt to access beyond end of device" messages.
+        >
+        > I've checked filesystem, memory on the node, motherboard BIOS
+        > version, but it
+        > does not help and issue still has been reproduced by simple
+        > file reading.
+        >
+        > Reproducer is simple:
+        >
+        > echo 0xffffffff >/proc/sys/dev/scsi/logging_level ;
+        > cat /vz/private/101/root/etc/ld.so.cache >/tmp/ttt  ;
+        > echo 0 >/proc/sys/dev/scsi/logging
+        >
+        > It leads to the following messages in dmesg
+        >
+        > sd_init_command: disk=sda, block=871769260, count=26
+        > sda : block=871769260
+        > sda : reading 26/26 512 byte blocks.
+        > scsi_add_timer: scmd: f79ed980, time: 7500, (c02b1420)
+        > sd 0:1:0:0: send 0xf79ed980                  sd 0:1:0:0:
+        >         command: Read (10): 28 00 33 f6 24 ac 00 00 1a 00
+        > buffer = 0xf7cfb540, bufflen = 13312, done = 0xc0366b40,
+        > queuecommand 0xc0344010
+        > leaving scsi_dispatch_cmnd()
+        > scsi_delete_timer: scmd: f79ed980, rtn: 1
+        > sd 0:1:0:0: done 0xf79ed980 SUCCESS        0 sd 0:1:0:0:
+        >         command: Read (10): 28 00 33 f6 24 ac 00 00 1a 00
+        > scsi host busy 1 failed 0
+        > sd 0:1:0:0: Notifying upper driver of completion (result 0)
+        > sd_rw_intr: sda: res=0x0
+        > 26 sectors total, 13312 bytes done.
+        > use_sg is 4
+        > attempt to access beyond end of device
+        > sda6: rw=0, want=1044134458, limit=951401367
+        > Buffer I/O error on device sda6, logical block 522067228
+        > attempt to access beyond end of device
+2.      When INQUIRY with EVPD bit set issued to the MegaRAID controller,
+        system memory gets corrupted.
+        Root Cause: MegaRAID F/W handle the INQUIRY with EVPD bit set
+        incorrectly.
+        Fix: MegaRAID F/W has fixed the problem and being process of release,
+        soon. Meanwhile, driver will filter out the request.
+3.      One of member in the data structure of the driver leads unaligne
+        issue on 64-bit platform.
+        Customer reporeted "kernel unaligned access addrss" issue when
+        application communicates with MegaRAID HBA driver.
+        Root Cause: in uioc_t structure, one of member had misaligned and it
+        led system to display the error message.
+        Fix: A patch submitted to community from following folk.
+        > -----Original Message-----
+        > From: linux-scsi-owner@vger.kernel.org
+        > [mailto:linux-scsi-owner@vger.kernel.org] On Behalf Of Sakurai Hiroomi
+        > Sent: Wednesday, July 12, 2006 4:20 AM
+        > To: linux-scsi@vger.kernel.org; linux-kernel@vger.kernel.org
+        > Subject: Re: Help: strange messages from kernel on IA64 platform
+        >
+        > Hi,
+        >
+        > I saw same message.
+        >
+        > When GAM(Global Array Manager) is started, The following
+        > message output.
+        > kernel: kernel unaligned access to 0xe0000001fe1080d4,
+        > ip=0xa000000200053371
+        >
+        > The uioc structure used by ioctl is defined by packed,
+        > the allignment of each member are disturbed.
+        > In a 64 bit structure, the allignment of member doesn't fit 64 bit
+        > boundary. this causes this messages.
+        > In a 32 bit structure, we don't see the message because the allinment
+        > of member fit 32 bit boundary even if packed is specified.
+        >
+        > patch
+        > I Add 32 bit dummy member to fit 64 bit boundary. I tested.
+        > We confirmed this patch fix the problem by IA64 server.
+        >
+        > **************************************************************
+        > ****************
+        > --- linux-2.6.9/drivers/scsi/megaraid/megaraid_ioctl.h.orig
+        > 2006-04-03 17:13:03.000000000 +0900
+        > +++ linux-2.6.9/drivers/scsi/megaraid/megaraid_ioctl.h
+        > 2006-04-03 17:14:09.000000000 +0900
+        > @@ -132,6 +132,10 @@
+        >  /* Driver Data: */
+        >          void __user *           user_data;
+        >          uint32_t                user_data_len;
+        > +
+        > +        /* 64bit alignment */
+        > +        uint32_t                pad_0xBC;
+        > +
+        >          mraid_passthru_t        __user *user_pthru;
+        >
+        >          mraid_passthru_t        *pthru32;
+        > **************************************************************
+        > ****************
 Release Date    : Mon Apr 11 12:27:22 EST 2006 - Seokmann Ju <sju@lsil.com>
 Current Version : 2.20.4.8 (scsi module), 2.20.2.6 (cmm module)
 Older Version   : 2.20.4.7 (scsi module), 2.20.2.6 (cmm module)
diff --git a/Documentation/sysctl/fs.txt b/Documentation/sysctl/fs.txt
index 0b62c62142cf..5c3a51905969 100644
--- a/Documentation/sysctl/fs.txt
+++ b/Documentation/sysctl/fs.txt
@@ -25,6 +25,7 @@ Currently, these files are in /proc/sys/fs:
 - inode-state
 - overflowuid
 - overflowgid
+- suid_dumpable
 - super-max
 - super-nr
@@ -131,6 +132,25 @@ The default is 65534.
 ==============================================================
+suid_dumpable:
+This value can be used to query and set the core dump mode for setuid
+or otherwise protected/tainted binaries. The modes are
+0 - (default) - traditional behaviour. Any process which has changed
+        privilege levels or is execute only will not be dumped
+1 - (debug) - all processes dump core when possible. The core dump is
+        owned by the current user and no security is applied. This is
+        intended for system debugging situations only. Ptrace is unchecked.
+2 - (suidsafe) - any binary which normally would not be dumped is dumped
+        readable by root only. This allows the end user to remove
+        such a dump but not access it directly. For security reasons
+        core dumps in this mode will not overwrite one another or
+        other files. This mode is appropriate when adminstrators are
+        attempting to debug problems in a normal environment.
+==============================================================
 super-max & super-nr:
 These numbers control the maximum number of superblocks, and
diff --git a/Documentation/sysctl/kernel.txt b/Documentation/sysctl/kernel.txt
index 7345c338080a..89bf8c20a586 100644
--- a/Documentation/sysctl/kernel.txt
+++ b/Documentation/sysctl/kernel.txt
@@ -50,7 +50,6 @@ show up in /proc/sys/kernel:
 - shmmax                      [ sysv ipc ]
 - shmmni
 - stop-a                      [ SPARC only ]
- suid_dumpable
 - sysrq                       ==> Documentation/sysrq.txt
 - tainted
 - threads-max
@@ -310,25 +309,6 @@ kernel.  This value defaults to SHMMAX.
 ==============================================================
-suid_dumpable:
-This value can be used to query and set the core dump mode for setuid
-or otherwise protected/tainted binaries. The modes are
-0 - (default) - traditional behaviour. Any process which has changed
-        privilege levels or is execute only will not be dumped
-1 - (debug) - all processes dump core when possible. The core dump is
-        owned by the current user and no security is applied. This is
-        intended for system debugging situations only. Ptrace is unchecked.
-2 - (suidsafe) - any binary which normally would not be dumped is dumped
-        readable by root only. This allows the end user to remove
-        such a dump but not access it directly. For security reasons
-        core dumps in this mode will not overwrite one another or
-        other files. This mode is appropriate when adminstrators are
-        attempting to debug problems in a normal environment.
-==============================================================
 tainted: 
 Non-zero if the kernel has been tainted.  Numeric values, which