into home.transmeta.com:/home/torvalds/v2.5/linux

into tp1.ruhr-uni-bochum.de:/home/kai/kernel/v2.5/linux-2.5.make

into home.transmeta.com:/home/torvalds/v2.5/linux

So the missing EXPORT_SYMBOL() for ioremap_nocache at least found
some ISDN drivers which shouldn't have been using it in the first
place.

into tp1.ruhr-uni-bochum.de:/home/kai/kernel/v2.5/linux-2.5.isdn

This patch adds the PCMCIA client driver for the AVM A1/Fritz!PCMCIA
ISDN cards, which has been in 2.4 for some time already.

This fixes linux/tqueue.h compile errors in 2.5.23 that were
found by Andy Pfiffer, Matthew Harrell and me.

into home.transmeta.com:/home/torvalds/v2.5/linux

Submitted by Thunder

fsync is allowed to return early if datasync is set and the I_DIRTY_DATASYNC
flags is cleared, not if either of those is true.

Submitted by Christoph Hellwig

I've got to keep my 2.4 and 2.5 patches straight!

Use bd_claim/bd_release to guarentee exclusive access to the external
log device.  I also fixed a struct block_device leak once I touched
that code (missing bdput() both in lmLogClose and the lmLogOpen
error path) and sanitized the failure path labels.

Submitted by Christoph Hellwig

into kleikamp.austin.ibm.com:/home/shaggy/bk/jfs-2.5

The pcmcia drivers haven't been updated to include the new
tqueue.h header when using tq_structs.

I noticed the breakage when compiling i82365.c for my laptop, and
took the time to modify all the drivers in that directory.

I suppose one can argue whether that is ugly or rather nice for
documentary purposes, but make on its own cannot figure out where a file
is supposed to live, so we have to help it.

(For the targets handled by Rules.make the situation is different, there
 Rules.make knows what's source and what's object and can add prefixes
 as necessary, so the most of the Makefiles are actually not affected by
 this kind of change)

For now, as $(obj) = $(src) = ., we only add "./", so the potential for
breakage is rather small.

This wasn't quite merged up to the current kbuild.

into tp1.ruhr-uni-bochum.de:/home/kai/kernel/v2.5/linux-2.5.make

akpm pointed out that an EXPORT_SYMBOL is missing for default_wake_function.

into home.transmeta.com:/home/torvalds/v2.5/linux

into mandrakesoft.com:/home/jgarzik/repo/net-drivers-2.5

into tp1.ruhr-uni-bochum.de:/home/kai/kernel/v2.5/linux-2.5.make-net

Submitted by Manfred Spraul.

Cset exclude: torvalds@penguin.transmeta.com|ChangeSet|20020619003306|07760
Cset exclude: ak@muc.de|ChangeSet|20020618172743|19150

into penguin.transmeta.com:/home/penguin/torvalds/repositories/kernel/linux

Previously each raid personality (Well, 1 and 5) started their
own thread to do resync, but md.c had a single common thread to do
reconstruct.  Apart from being untidy, this means that you cannot
have two arrays reconstructing at the same time, though you can have
to array resyncing at the same time..

This patch changes the personalities so they don't start the resync,
but just leave a flag to say that it is needed.
The common thread (mdrecoveryd) now just monitors things and starts a
separate per-array thread whenever resync or recovery (or both) is
needed.
When the recovery finishes, mdrecoveryd will be woken up to re-lock
the device and activate the spares or whatever.

raid1 needs to know when resync/recovery starts and ends so it can
allocate and release resources.
It allocated when a resync request for stripe 0 is received.
Previously it deallocated for resync in it's own thread, and
deallocated for recovery when the spare is made active or inactive
(depending on success).

As raid1 doesn't own a thread anymore this needed to change.  So to
match the "alloc on 0", the md_do_resync now calls sync_request one
last time asking to sync one block past the end.  This is a signal to
release any resources.

1/ don't free the rdev->sb on an error -- it might be
   accessed again later.  Just wait for the device to be
   exported.
2/ Change md_update_sb to __md_update_sb and have it
   clear the sb_dirty flag.
   New md_update_sb locks the device and calls __md_update_sb
   if sb_dirty.  This avoids any possbile races around
   updating the superblock

Provide SMP safe locking for all_mddevs list.

the all_mddevs_lock is added to protect all_mddevs and mddev_map.

ITERATE_MDDEV is moved to md.c (it isn't needed elsewhere) and enhanced
to take the lock appropriately and always have a refcount on the object
that is given to the body of the loop.

mddev_find is changed so that the structure is allocated outside a lock,
but test-and-set is done inside the lock.

If two md arrays which share real devices (i.e they each own a partition
on some device) need to sync/reconstruct at the same time, it is much
more efficient to have one wait while the other completes.

The current code uses interruptible_sleep_on which isn't SMP safe (without the BKL).
This patch re-does this code to make it more secure.  Even it two start simultaneously,
one will reliably get priority, and the other wont wait for ever.

More mddev tidyup - remove recovery_sem and resync_sem

recovery_sem and resync_sem get replaced by careful use
of recovery_running protected by reconfig_sem.

As part of this, the creative:
	down(&mddev->recovery_sem);
	up(&mddev->recovery_sem);

when stopping an array gets replaced by a more obvious

	wait_event(resync_wait, mddev->recovery_running <= 0);

Strengthen the locking of mddev.

mddev is only ever locked in md.c, so we move {,un}lock_mddev
out of the header and into md.c, and rename to mddev_{,un}lock
for consistancy with mddev_{get,put,find}.

When building arrays (typically at boot time) we now lock, and unlock
as it is the "right" thing to do.  The lock should never fail.

When generating /proc/mdstat, we lock each array before inspecting it.

In md_ioctl, we lock the mddev early and unlock at the end, rather than
locking in two different places.

In md_open we make sure we can get a lock before completing the open.  This
ensures that we sync with do_md_stop properly.

In md_do_recovery, we lock each mddev before checking it's status.

md_do_recovery must unlock while recovery happens, and a do_md_stop at this
point will deadlock when md_do_recovery tries to regain the lock.  This will be
fixed in a later patch.

md_ioctl doesn't need to mddev_find, as the mddev must
be in the bd_inode->u.generic_ip.  This means we don't need
to mddev_put either.

Only two users of kdev_to_mddev remain, md_release and
md_queue_proc.

For md_release we can store the mddev in the md_inode
at md_open time so we can find it easily.

For md_queue_proc, we use mddev_find because we only have the
device number to work with.  Hopefully the ->queue function
will get more arguements one day...

This patch gets md_open to use mddev_find instead of kdev_to_mddev, thus
creating the mddev if necessary.
This guarantees that md_release will be able to find an mddev to
mddev_put.

Now that we are certain of getting the refcount right at open/close time,
we don't need the "countdev" stuff.  If START_ARRAY happens to start and
array other than that the one that is currently opened, it won't confuse
things at all.

First step to tidying mddev recounting and locking.

This patches introduces
  mddev_get   which incs the refcount on an mddev
  mddev_put   which decs it and, if it becomes unused, frees it
  mddev_find  which finds or allocated an mddev for a given minor
              This is mostly the old alloc_mddev


free_mddev no longer actually frees it.  It just disconnects all drives
so that mddev_put will do the free.

Now the test for "does an mddev exist" is not "mddev != NULL"
but involves checking if the mddev has disks or a superblock
attached.

This makes the semantics of do_md_stop a bit cleaner.  Previously
if do_md_stop succeed for a real stop (not a read-only stop) then
you didn't have to unlock the mddev, otherwise you did.  Now
you always unlock the mddev after do_md_stop.