We can't now use make -C in conjunction with Rules.make because
the rules for making .o files break if we do.  This updates the
boot wrapper Makefiles so that we don't use make -C, instead we
use call descend plus various other new features in Rules.make.

Previously we had xchg_u32 both inline in system.h and out-of-line
in arch/ppc/kernel/misc.S, and it was exported for good measure.
We only need the inline definition.

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

This does the following three things:

 (1) Makes the functions in mm/readahead.c only use struct file* to pass to
     readpage(). address_mapping* and file_ra_state* are used instead to keep
     track of readahead stuff.

 (2) Adds a new function do_generic_mapping_read() that is similar to
     do_generic_file_read(), except that it uses a mapping pointer and a
     readahead state pointer to access a file. The file* is only used to pass
     to readpage().

 (3) Turns do_generic_file_read() into an inline function in linux/fs.h that
     simply wraps do_generic_mapping_read().

This should mean that it is no longer necessary to have a struct file to
access a file in this manner. Just an inode or address space should be
sufficient.

It also means alternate read-ahead structures can be maintained.

The reason I want this is that I'm writing a general cache manager for
filesystems such as AFS, NFSv4, and Lustre. Block devices are made available
to the "cache manager" by means of a filesystem that can be mounted. I'm
storing meta data in an inode in the cache, but to scan this at the moment I
need to gain a "struct file" to use with do_generic_file_read().

This involves either creating a dummy dentry and struct file (which will cause
Al Viro to come looking for me with a shotgun), or to use an extra auxilliary
filesystem mounted with do_kern_mount(), neither of which are particularly
appealing.

This patch is the alternative... it provides a function that I can pass an
address_space to. This also allows me to make use of readahead semantics
without having to reinvent them for myself.

In the initial discussion LSM folks agreed on this, the
rationale is that lsseek itself makes no sense to
project as mmap() and pread/pwrite() allow access to any
area of the file anyway.

These exports have the power to change the implementations of all
syscalls and I've seen people exploiting this "feature".

Make the exports GPLonly (which some LSM folks agreed to
when it was merged initially to avoid that).

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

Modid: 2.5.x-xfs:slinx:130142a

Modid: 2.5.x-xfs:slinx:130135a

Modid: 2.5.x-xfs:slinx:130071a

Modid: 2.5.x-xfs:slinx:130045a

xfs_alloc_put_freelist marks the blocks it gets as "busy".  However, this
function is used in two different ways:
   
  1.  xfs_alloc_fix_freelist calls xfs_alloc_put_freelist to add new
  blocks to the freelist (that is, blocks it allocated with
  xfs_alloc_ag_vextent).
   
  2.  xfs_alloc_delrec calls xfs_alloc_put_freelist to free deleted
  b+tree blocks.  
   
In case 1, the blocks should not be on the busy list; in case 2, they
should.

Modid: 2.5.x-xfs:slinx:129987a

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

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

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

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

plus other small cleanups, in particular getting rid of
isdn_ppp_{receive,send}_ccp() and calling into the CCP code directly.

No (well, hardly any ;) code changes, only moving all /dev/ipppX related
code next to each other and some indenting changes.

o Now that all the infrastructure is in place, struct ipppd can
  easily be allocated when /dev/ipppX is opened and freed
  in the destructor.
o Separate the mix of state and flags in struct ipppd::state.
  We only have three states, open, assigned and connected, and
  additionally two flags to jump out of poll(), returning POLLHUP /
  POLLIN.

Instead of just recording the slot number and then retrieving
the ipppd via that, we can now just keep a pointer and get a
reference which makes sure that it does not go away until
we drop the reference.

We had introduced ipppd_get/put() earlier, so now add a real reference
count.

Basically, all what was missing was a common way to xmit frames
given the isdn_net_dev / isdn_net_local. We have this now by means
of function pointers (still room for improvement there, though), so
now let's do things from isdn_ppp_ccp.c.

Let isdn_ppp_ccp.c take care of keeping state / flags by itself.

Use a shared function for generating the PPP header, use the
{put,get}_u{8,16,32} helpers for endian-safe access.

I cannot see now reason why ISDN PPP devices should have a fake
::header routine which reserves a couple of bytes just to reclaim them
later during hard_start_xmit(), and since it works just as well without
it...

Fix missed STAT_BSENT acks and don't use skb_clone() for the skb which is
sent back, the network layer gets confused by that.

Create the new files isdn_ppp_ccp.[hc] which deal with PPP CCP
(compression control protocol) related stuff. Move most of the CCP
related stuff from isdn_ppp.c into isdn_ppp_ccp.c, putting CCP
state into a new "struct ippp_ccp".

A lot of the state in struct ipppd actually belongs to
isdn_net_dev or isdn_net_local, making it more easily accessible at a
most places, and also removing the ambiguity whether it's link-
or bundle-specific.

and move the declaration from include/linux/isdn_ppp.h
into drivers/isdn/i4l/isdn_ppp.c

Make sync PPP compile with the latest changes to the ISDN net device
layer - PPP negotiations work again after this patch.

Definitions which is only needed in one source file should go there and not
in a common header.

Last step in separating generic / interface-type specific code,
the former is now all in isdn_net_lib.c, the specific code in
isdn_net.c / isdn_ppp.c / isdn_concap.c

Instead of using locking per-channel, just lock the entire ISDN net work
interface as an entity, getting rid of weird locking.
  
Basically, ::hard_start_xmit() is already serialized by the network core,
so we could just rely on that. However, we want to send keep alive
frames, PPP messages from ipppd and such things directly without going
through the network stack, so we additionally lock
isdn_net_local->xmit_lock in hard_start_xmit(), which is taken in
the other paths dealing with transmitting frames as well.

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