apm_driver_version() isn't an __init function, but is called from the
asynchronous APM driver thread (which might run after the init sequence
has finished).

This trivial fix stops APM from oopsing when compiled as module.

This changes /proc/modules to have fixed space-separated format,
independent of CONFIG options or how many module dependencies there
are.

 Old format: modname modsize [refcount [dep1] [dep2] ...]

 New format: modname modsize refcount deps1,[dep2,]...

The module-init-tools have understood this format for over a month now.
This change allows us to add new fields, ie.  module state, module
address, etc.

This patch combines the common exception table searching functionality
for various architectures, to avoid unneccessary (and currently buggy)
duplication, and so that the exception table list and lock can be kept
private to module.c.

The archs provide "struct exception_table" and "search_extable": the
generic infrastructure drives the rest.

This implements EXPORT_SYMBOL_GPL and MODULE_LICENSE properly (so
restrictions are enforced).  Also fixes "proprietory" spelling.

I told someone to do "make htmldocs" and just to be sure
checked myself. Below two fixes.

Patch from Bill Irwin.   Prodding from me.

The hashtables in kernel/pid.c are 128 kbytes, which is far too large for
very small machines.

So we dynamically size them and allocate them from bootmem.  From 16 buckets
on the very smallest machine up to 4096 buckets (effectively half the current
size) with one gigabyte of memory or more.

The patch also switches the hashing from a custom hash over to the more
powerful hash_long().

Patch from Manfred Spraul <manfred@colorfullife.com>

Effectively adds another 24 megabytes of ia32 KVA.

kmap uses a 4 MB (2 MB if PAE is enabled) area for the persistant mappings.
But PKMAP_BASE is 4GB-32MB, i.e.  around 28 MB are reserved for kmap (4 MB
for fixmappings).

The attached patch shrink that to 4 MB (+4MB for fixmappings) and adds a test
to check for an overlap between fixmap and kmap areas.

slab redzoning errors are very hard to decrypt.

The patch adds a human-readable interpretation to each error and changes it
to not go BUG() when an error is detected.

David Brownell noticed this.  mempool_resize() is calling kfree on a rare
path when it should be calling the pool's free function.

The patch fixes that up, and then disables mempool_resize() compilation - it
has no callers at present.

This patch uses the radix_tree_preload() API in add_to_page_cache().

A new gfp_mask argument is added to add_to_page_cache(), which is then passed
on to radix_tree_preload().   It's pretty simple.

In the case of adding pages to swapcache we're still using GFP_ATOMIC, so
these addition attempts can still fail.  That's OK, because the error is
handled and, unlike file pages, it will not cause user applicaton failures.
This codepath (radix-tree node exhaustion on swapout) was well tested in the
days when the swapper_space radix tree was fragmented all over the place due
to unfortunate swp_entry bit layout.

radix_tree_node_alloc() uses GFP_ATOMIC, under spinlocking.  If the
allocation fails then userspace sees ENOMEM and application failure occurs.

A single add_to_page_cache() will require up to six radix_tree_nodes on
32-bit machines, twice this on 64-bit machines (quadruple the worst-case
storage on 64-bit).

My approach to solving this problem is to create a per-cpu pool of
preallocated radix_tree_nodes, private to the radix-tree code.

The radix-tree user will call the new radix-tree API function
radix_tree_preload() to ensure that this pool has sufficient nodes to cover
the worst-case.  radix_tree_preload() should be called outside locks, with
GFP_KERNEL so that it can run page reclaim.

If it succeeds, radix_tree_preload() will return with preemption disabled so
that the per-cpu radix_tree_node pool is protected.  The user must call
radix_tree_preload_end() to terminate the transaction.

In the common case, the per-cpu pools will never be touched:
radix_tree_insert() will only dip into the pool if kmem_cache_alloc() fails.
The pools will remain full at all times.  This is to optimise the fastpath -
it is just a few instructions.

This patch also removes the now-unneeded radix-tree mempool.  This saves 130
kbytes of permanently allocated kernel memory.  260k on 64-bit platforms.

Update page_add_rmap() callers to allocate their own pte_chain structures,
and to pass those into page_add_rmap().

The swapoff path has not yet been updated and is still oopsable.  The locking
there is tricky.

The VM allocates pte_chains with GFP_ATOMIC, under deep locking.  If that
allocation fails, we oops.

My approach to solving this is to require that the caller of page_add_rmap()
pass in a pte_chain structure for page_add_rmap() to use.  Then, callers can
arrange to allocate that structure outside locks with GFP_KERNEL.

This patch provides the base infrastructure.

A common case is that page_add_rmap() will in fact not consume the pte_chain,
because an empty slot was found within one of the page's existing pte_chain
structures.  So this patch provides for a special one-deep per-cpu pte_chain
cache to optimise this case of taking just one pte_chain and then immediately
putting it back.

We end up adding maybe 20-30 instructions to the pagefault path to handle the
eventuality of pte_chain allocation failures.

Lots of other design ideas were considered.  This is the best I could come up
with.

 - Don't evaluate pfn_to_page(pte_pfn(pte)) twice.

 - adjust whitespace

 - rename inner variable `ptepage' to `page'.  It's more logical, and
   reduces collisions with the shared pagetable patch (which has to rename it
   anyway, because it adds a `ptepage' which really is "the page which holds
   ptes").

Patch from Urban Widmark <Urban.Widmark@enlight.net>

Adds support for the 3c920, which appears to be the same as a 3c905C.

 - fix starfire.c printk compile warning (dma_addr_t can be 64 bit) (Martin
   Bligh)

 - Remove an ifdef from the scheduler

Patch from Adam J. Richter <adam@yggdrasil.com> and
           Milton Miller <miltonm@bga.com>

There's some init-time code which is supposed to read a devfs directory by
expanding the bufer until the whole directory fits.  But the logic is wrong
and it only works if the whole directory fits into 512 bytes.

So fix that up, and also clean up some coding in there, and rationalise the
duplicated definition of linux_dirent64.

Patch from "Randy.Dunlap" <rddunlap@osdl.org>

Convert the selection of LOG_BUF_SIZE from an ifdef tangle in
printk.c into config logic.

Add a new field to the md superblock, in an used area, to record where
resync was up-to on a clean shutdown while resync is active.  Restart from
this point.

The extra field is verified by having a second copy of the event counter.
If the second event counter is wrong, we ignore the extra field.

This patch thanks to  Angus Sawyer <angus.sawyer@dsl.pipex.com>

When resyncing an array, md will back off if it detects other
activity on the device.  This used to be based on the whole
device, not the partition, but recent changes made it only
check IO on the partition.

This patch causes all sync_io accounting to be done on the
whole device (bdev->bd_contains).

Assorted fixes particularly related to handling the new style
xdr_buf buffers for NFSv4 server

It works much better than my little toy hash functions.

This uses the read-without-write style transaction files in nfsctl.
We can write a number of threads, and then read back the number of
threads that resulted, or we can just open and read in which case
we read back the number of threads without changing it.

The getfh system call takes an IP address, which is only
really appropriate for AUTH_UNIX authentication.

With this interface, you call can ask for a filehandle for a
particular domain.

You write
 domainname pathname maxlength
to the file, and then read back the filehandle

All strings a qword quoted.

The nfsd filesystem provides an interface to nfsd.
Most of the current files should be considered legacy
interfaces as they are not particularly suitable for
filesystem interaction, but are required to support the
syscall interface.
This patch puts a '.' in front of all the names so they
appear as hidden names when the directory is listed.

The transaction files in the 'nfsd' filesystem
stores the per-transaction response size in the per-inode
i_size, which is wrong.
With this patch a page is allocated for holding size and
request and response, so routines don't need to
copy_fromuser.

Also, some routines were allocating rather large (>1024 bytes)
stuctures on the stack for copy_fromuser into, which was not
nice and is now not needed.

Also, writeonly and write_read methods are unified in a single
transaction style interface.
Write then read performs and action and returns a response.
Write without read just performs the action and ignores response.
Read without write triggers an empty transaction which can still have
a response.  That functionality will be used in a later patch.

Userspace can with a time (seconds since epoch) to
  /proc/net/rpc/*/epoch
and all entries created earlier than that time will be flushed.

This provides a /proc/sunrpc/*/content seq_file for caches to display
their content.

This code is based on the code for /proc/fs/nfs/exports

Get auth_unix_lookup (maps IP address to clientname)
to use cache_check instead of checking the various state
bits manually.

Each cache channel remembers if there was a reader recently.
If there wasn't, then it doesn't bother with an up-call.
Currently, it initialises thinking there was a reader
recently incase the reader starts shortly afterwards.  However
this causes problems when a reader doesn't start soon, and
isn't necessary as the reader can easily be started before
the cache is initialised (e.g. before nfsd is started).

1/ converting to hex wasn't quite right
2/ make sure that decoding into the buffer holding
   original message works ok.

If an NFSv3 request claims an enourmous filehandle, we can believe
it and oops.  The test should be unsigned...

This patch introduces a new flag called TIF_IRET and uses it in place
of TIF_SIGPENDING when that flag is used to force return via iret.

This avoids the overhead of calling do_signal and makes the code
easier to understand.

Currently syscall_badsys is called to handle faults when reading the
sixth parameter in sysenter; however that routine assumes that
registers have already been pushed on the stack, and this is not the
case (in other words, it will currently try to pop beyond the end of
the thread stack).

This patch adds a new "function", syscall_fault, that saves register
and returns.

The return value is changed to EFAULT, which seems more appropriate
than ENOSYS.