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

The recursive build used to do the following: On entering a directory,
we would first call make in the subdirectories listed in $(subdir-y),
and then call make in the current directory again, with the target
'all_targets'.

The second invocation was used to make sure that the subdir makes completed
before trying to build the O_TARGET/L_TARGET in the current dir, since
this would link in objects in these subdirectories.

However, using correct dependencies achieves the same, i.e. just
make the objects in $(obj-y) which are not in the local subdirectory
depend on 'sub_dirs', which is the rule to descend into subdirs.

This patch actually halves the time "make vmlinux" takes when there's
nothing to do (which makes sense, as we save half of the make invocations)

There's no good reason to build the objects in init/ explicitly from
the top-level Makefile. Instead, handle init/ like every other
subdir, which also provides the automatic checks for a changed
command line etc.

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

Fix some trivial variable/functions/label defined (static) but not used
warnings.

Removal of locks.h broke the build due to missing definition of capable()
and current.

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

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

ips driver update ( version 5.10.13-BETA )

The lock.h header contained some hand-crafted lcoking routines from
the pre-SMP days.  In 2.5 only lock_super/unlock_super are left,
guarded by a number of completly unrelated (!) includes.

This patch moves lock_super/unlock_super to fs.h, which defined
struct super_block that is needed for those to operate it, removes
locks.h and updates all caller to not include it and add the missing,
previously nested includes where needed.

This patch implements ioctl() for getting space used by file.
I agree it's ioctl() abuse, it doesn't work on links and has
other ugly properties. Better would be to change 'struct stat'
but changing it just due to this is overkill and it will take
some time before there will be enough changes which will provoke
yet another struct stat :). So this is temporary solution...
If you don't like it, simply reject it. The function it provides
is not fundamental...

So that should be all patches. Any comments (or decision about
including/not including) welcome.
								Honza

This patch implements configurable backward compatible quota interface.
Maybe this isn't needed in 2.5 but as some people want to use patches
in 2.4 where it's necessary I have implemented it.

Implemented proper syncing of dquots - ie. also global information
about quota files are synced. We find info to sync by walking through
all superblocks...

Remove use of 'short' in parameters of functions. 'int' is used instead.

Implementation of new quota format. The code is almost the same
as in -ac versions of kernel. All the code for new format is in
quota_v2.c

Implementation of old quota format. All the code for old format is now in
quota_v1.c. Code mostly remained the same as in older kernels (just minor
changes were needed to bind it with quota interface).

This is probably the largest chunk in quota patches. It removes old quotactl interface
and implements new one. New interface should not need arch specific conversions so they
are removed. All quota interface stuff is moved to quota.c so we can
easily separate things which should be compiled even if quota is disabled (mainly
because XFS needs some interface even if standard VFS quota is disabled).
Callbacks to filesystem on quota_on() and quota_off() are implemented (needed by Ext3),
quota operations callbacks are now set in super.c on superblock initialization and
not on quota_on(). This way it starts to make sense to have callbacks on alloc_space(),
alloc_inode() etc. as filesystem can override them on read_super(). This will be used
later for implementing journalled quota.

This patch implements counting of used space in inodes in bytes.
New field i_bytes is added and used space modulo 512 is kept in
it (rest is still kept in i_blocks). Functions manipulating both
i_blocks and i_bytes are implemented (inode_add_bytes(), inode_sub_bytes()
and inode_set_bytes()). Filesystems allocating only in whole blocks
can safely ignore i_bytes field and continue using i_blocks...

This patch implements accounting of used space in bytes.

  This patch moves reporting of quota statistics from Q_GETSTATS call to
/proc/fs/quota. Also reporting of registered quota formats is added.

  This patch implements list 'quota_formats' with registered quota formats
and functions register_quota_format() and unregister_quota_format() for
manipulating the list.

This patch removes most format dependent code from dquot.c and quota.h
and puts calls of callback functions instead.

  This patch adds dq_dup_ref to struct dquot. Functions altering just usage of
quota take just this duplicated reference, inodes, quotactl() helpers take real
dq_count reference. dqput() blocks if there are some duplicated references and
put reference is last 'real one'. This way is assured that quota IO is not
done from functions altering quota usage (quota structure is written on last dqput()).

As of the last patch the inode_hashtable doesn't really need to be
indexed by i_ino anymore, the only reason we still have to keep the
hashvalue and i_ino identical is because of insert_inode_hash.

If at some point a FS specific getattr method is implemented it will be
possible to completely remove any use of i_ino by the VFS.

This patch starts taking i_ino dependencies out of the VFS. The FS
provided test and set callbacks become responsible for testing and
setting inode->i_ino.

Because most filesystems are based on 32-bit unique inode numbers
several functions are duplicated to keep iget_locked as a fast path. We
can avoid unnecessary pointer dereferences and function calls for this
specific case.

Now that we have no more users of iget4 we can kill the function and the
associated read_inode2 callback (i.e. the 'reiserfs specific hack').

Document iget5_locked as the replacement for iget4 in filesystems/porting.

Convert existing filesystems (Coda/NFS/ReiserFS) that currently use
iget4 to iget5_locked.

Now we introduce iget_locked and iget5_locked. These are similar to
iget, but return a locked inode and read_inode has not been called. So
the FS has to call read_inode to initialize the inode and then unlock
it with unlock_new_inode().

This patch is based on the icreate patch from the XFS group, i.e.
it is pretty much identical except for function naming.

Fix a race in iget4. The fs specific data that is used to find an inode
should be initialized while still holding the inode lock.

It adds a 'set' callback function that should be a non-blocking FS
provided function which initializes the private parts of the inode so
that the 'test' callback function can correctly match new inodes.

Touches all filesystems that use iget4 (Coda/NFS/ReiserFS).

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

	- fix copy_{to,from}_user error handling, thanks to Rusty to pointing this out on lkml

  - fix copy_{to,from}_user error handling, thanks to Rusty for
    pointing this out on lkml

Removal of PG_launder.

It's not obvious (to me) why this ever existed.  If it's to prevent
deadlocks then I'd like to know who was performing __GFP_FS allocations
while holding a page lock?

But in 2.5, the only memory allocations which are performed when the
caller holds PG_writeback against an unsubmitted page are those which
occur inside submit_bh().  There will be no __GFS_FS allocations in
that call chain.

Removing PG_launder means that memory allocators can block on any
PageWriteback() page at all, which reduces the risk of very long list
walks inside pagemap_lru_lock in shrink_cache().

The ext3-no-steal patch has exposed a long-standing race in ext3.  It
has been there all the time in 2.4, but never triggered until some
timing change in the ext3-no-steal patch exposed it.  The race was not
present in 2.2 because 2.2's bdflush runs inside lock_kernel().

The problem is that when ext3 is shuffling a buffer between journalling
lists there is a small window where the buffer is marked BH_dirty.
Aonther CPU can grab it, mark it clean and write it out.  Then ext3
puts the buffer onto a list of buffers which are expected to be dirty,
and gets confused later on when the buffer turns out to be clean.

The patch from Stephen records the expected dirtiness of the buffer in
a local variable, so BH_dirty is not transiently set while ext3
shuffles.