Return nfserr_nofilehandle (v4 only) in fh_verify() if the filehandle
has not been set.

In a few places on the server, I had to change code that looked like:

   if (rqstp->rq_vers == 3)
       /* NFSv3 behavior */
   else
       /* NFSv2 behavior */

to:

   if (rqstp->rq_vers > 2)
       /* NFSv3 behavior */
   else
       /* NFSv2 behavior */

so that we would get the NFSv3 behavior, not the NFSv2 behavior,
in NFSv4.  This patch collects all changes of this type.

Change the type checking in fh_verify().  This fixes a bug which
I reported on the mailing list a few days ago, and also adds a
new error code nfserr_symlink (v4 only).  This is returned whenever
an operation which is illegal for symlinks is attempted on a symlink,
and takes precedence over ERR_NOTDIR or ERR_INVAL.

Add some new NFSv4-only error codes to include/linux/nfsd/nfsd.h

This patch adds new NFSv4-only error codes to include/linux/nfs.h,
and also indicates which of the old error codes still exist in NFSv4.

If we get here, then bio->bi_bdev isn't set, so we really
shouldn't de-reference it.

..as some standard ioctls expect the per-device ioctl routine
to return EINVAL and then fall back on a standard implementation.

raid1, raid5 and multipath maintain their own
'operational' flag.  This is equivalent to
   !rdev->faulty
and so isn't needed.
Similarly raid1 and raid1 maintain a "write_only" flag
that is equivalnt to
   !rdev->in_sync
so it isn't needed either.

As part of implementing this change, we introduce some extra
flag bit in raid5 that are meaningful only inside 'handle_stripe'.
Some of these replace the "action" array which recorded what
actions were required (and would be performed after the stripe
spinlock was released).  This has the advantage of reducing our
dependance on MD_SB_DISKS which personalities shouldn't need
to know about.

This flag was used by multipath to make sure only
one superblock was written, as there is only one
real device.

The relevant test is now more explicitly dependant on multipath,
and the flag is gone.

Instread of the 'skip' variable, just test if rdev is NULL or not.

1/ Personalities only know about raid_disks devices.
   Some might be not in_sync and so cannot be read from,
   but must be written to.
	- change MD_SB_DISKS to ->raid_disks
	- add tests for .write_only

2/ rdev->raid_disk is now -1 for spares.  desc_nr is maintained
   by analyse_sbs and sync_sbs.

3/ spare_inactive method is subsumed into hot_remove_disk
   spare_writable is subsumed into hot_add_disk.
   hot_add_disk decides which slot a new device will hold.

4/ spare_active now finds all non-in_sync devices and marks them
   in_sync.

5/ faulty devices are removed by the md recovery thread as soon
   as they are idle.  Any spares that are available are then added.

This is equivalent to ->rdev != NULL, so it isn't needed.

This will allow us to know, in the event of a device failure, when the
device is completely unused and so can be disconnected from the
array.  Currently this isn't a problem as drives aren't normally disconnect
until after a repacement has been rebuilt, which is a LONG TIME, but that
will change shortly...

We always increment the count under a spinlock after checking that
it hasn't been disconnected already (rdev!= NULL).
We disconnect under the same spinlock after checking that the
count is zero.

This simplifies the error handlers slighty, but allows for even more
simplification later.

Holding the rdev instead of the bdev does cause an extra
de-reference, but it is conceptually cleaner and will allow
lots more tidying up.

->major_name is "const char *" so we need to sprintf into the kmalloced
space *before* assigning that space to ->major_name.

1/ Raid0 should not be accessing rdev->sb.

2/ Don't unlock rdev (which releases bdev) until after last use of bdev

3/ Fix typo in a printk ( = should be -)

4/ i should be dd_idx in compute_block

bufsiz is re-evaluated on recv if SK_CHNGBUF is set,
but recv will never be reached if the buffers are too small.
So we have to set to to something vaguely reasonable
at init time.

1/ connect requests would be get lost...
  As the comment at the top of svcsock.c says when discussing
  SK_CONN:
 *		after a set, svc_sock_enqueue must be called.

  We didn't and so lost conneciton requests.

2/ set the max accept backlog to a more reasonable number to cope
   with bursts of lots of connection requests.

__page_cache_release() needs to check PG_lru inside the lock, because
page reclaim may have taken the page off the LRU while this CPU waits
on the lock.

That's three bugs in a single twenty-line function.  So far.

This fixes some problems in vmalloc.c.  The two first parts of the diff
fix a spinlock being held if an error occurs in map_vm_area, and the
last part fixes the error path of __vmalloc.

but some files still did (and got the wrong results on UP).

Since they didn't actually _use_ the BKL anyway, remove the
include.

since it was generic.

Remove all architecture-specific <asm/smplock.h> files.

 - Use req->rq_received to determine the message length instead of
   assuming that it goes to the end of the page.

 - If the server returned an illegal record so that we cannot make
   progress by retrying the request on a fresh page, truncate the
   entire listing and return a syslog error.

 - Fix the check for whether or not the received message length has
   somehow been truncated: we need to use req->rq_received rather
   than the receive buffer length (req->rq_rlen).

 - Ensure that we set res->eof correctly. In particular, we need to
   clear it if we find ourselves attempting to recover from a
   truncated READ.

 - Don't set PageUptodate() on those pages that are the victim of
   message truncation.

 - cleanup #defines: I do not follow the rationale behind the
   odd line-wrapped defines at the beginning of the file.  If
   we have to use multiple lines, then we might as well do so
   cleanly and according to normal practice...

 - Remove a level of indirection: do not have spin_lock_foo
   use spin_lock - just explicitly call what is needed.

 - we do not need to define the spin_lock functions twice, once
   for CONFIG_PREEMPT and once for !CONFIG_PREEMPT.  Defining
   them once with the preempt macros will optimize away fine.

 - cleanup preempt.h too

 - other misc. cleanup, improved comments, reordering, etc.

This fixes the ptrace wait4() anomaly that can be observed in any
previous Linux kernel i could get my hands at.

If the parent still has other children (that are being traced by
somebody), we wait for them or return immediately without an error in
case of WNOHANG.

Finally, this chunk removes the references to the UFS & ROMFS
entries in struct superblock, leaving just ext3 and hpfs as
the only remaining fs's to be fixed up.

This one from Brian Gerst seperates UFS from
the struct superblock union.

This patch from Christoph Hellwig divorces ROMFS
from the struct superblock union, as has been done
to various other filesystems during 2.5

try_to_unmap() dies if the to-be-unmapped page has a non-NULL ->mapping.

But the preceding logic in shrink_cache() forgot about the
rarely-occurring pages which have buffers and no ->mapping.

I have a test_and_set_bit(PG_chainlock, page->flags) in page reclaim.
Which works fine on SMP.  But on uniprocessor, we made
pte_chain_unlock() a no-op, so all pages end up with PG_chainlock set.
refill_inactive() cannot move any pages onto the inactive list and the
machine dies.

The patch removes the test_and_set_bit optimisation in there and just
uses pte_chain_lock().  If we want that (dubious) optimisation back
then let's do it right and create pte_chain_trylock().

__page_cache_release() needs to recheck the page count inside the LRU
lock, because shrink_cache() may have found the page on the LRU and
incremented its refcount again.

Which is carefully documented over __pagevec_release().  Duh.

Here's a patch from Andrea's tree that uses IRQ_BALANCE_INTERVAL to
define how often interrupts are balanced, staying independent from HZ.

  It also makes sure that there _is_ a change to the configuration
before it actually writes it.  It reminds me of the mod_timer
optimization.