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

Many Makefiles did a put an own rule in front of 
"include $(TOPDIR)/Rules.make" for no good reason at all,
the only places where it made sense are converted to using
EXTRA_TARGETS now.

Remove obsolete NFS and RPC routines.
Remove 'inline' attribute from xdr_decode_fattr().

Remove another class of rpciod deadlocks on HIGHMEM systems. Kick habit of
keeping pages kmap()ed for the entire duration of NFS
read/readdir/readlink operations.

Use struct page directly in RPC client data receive buffer. TCP and UDP
sk->data_ready() bottom-halves copy (and checksum when needed) data into
pages rather than iovecs. atomic_kmap() of single pages is used for the
copy.

include/linux/xdr.h
   Declare structure for copying an sk_buff here rather than in xprt.c.
   Forward declaration of new functions.

include/linux/sunrpc/xprt.h
   RPC client receive buffer changed to use new format 'struct xdr_buf'.

net/sunrpc/clnt.c
   Initialize new format receive buffer.

net/sunrpc/sunrpc_syms.c
   Export xdr_inline_pages(), xdr_shift_buf()

net/sunrpc/xdr.c
   xdr_inline_pages() inlines pages into the receive buffer.
   xdr_partial_copy_from_skb() replaces csum_partial_copy_to_page_cache()
	and copy code in tcp_read_request(). Provides sendfile()-style
	method for copying data from an skb into a struct xdr_buf.
   xdr_shift_buf() replaces xdr_shift_iovec() for when we overestimate
	the size of the RPC/NFS header.

net/sunrpc/xprt.c
   Adapt UDP and TCP receive routines to use new format xdr_buf.

include/linux/nfs_xdr.h
   struct nfs_readargs, nfs_readdirargs, nfs_readlinkargs,
	nfs3_readdirargs, nfs3_readlinkargs all transmit page information.
   struct nfs_readdirres, nfs_readlinkres, nfs3_readlinkres obsoleted.
   struct nfs_rpc_ops->readlink(), readdir(), read() now send pages

fs/nfs/dir.c
   Adapt to new format ->readdir().
   Avoid kmap() around the RPC call.

fs/nfs/read.c
   Adapt to new format ->read() and struct nfs_readargs.

fs/nfs/symlink.c
   Adapt to new format ->readlink().

fs/nfs/proc.c
   Convert nfs_proc_readlink(), nfs_proc_readdir(), nfs_proc_read()

fs/nfs/nfs2xdr.c
   Convert XDR routines to transmit page information.
   Remove duplicate zeroing of pages when server returns a short read.

fs/nfs/nfs3proc.c
   Convert nfs3_proc_readlink(),nfs3_proc_readdir(),nfs3_proc_read()

fs/nfs/nfs3xdr.c
   Convert XDR routines to transmit page information.
   Remove duplicate zeroing of pages when server returns a short read.

Cheers,
  Trond

Stop rpciod from deadlocking against itself in map_new_virtual() on HIGHMEM
systems. RPC client currently has to keep all pages that are scheduled for
transmission kmap()ed into an iovec for the entire duration of the call.
We only actually need to kmap() pages while making the (non-blocking)
call to sock_sendmsg().

NOTE: When transmitting several pages in one RPC call, sock_sendmsg()
requires us to kmap() *all* those pages at the same time. Opens for
deadlocks between rpciod and some other process that also kmaps more
than 1 page at a time.
For the TCP case we can solve later by converting to TCP_CORK+sendpage().

include/linux/sunrpc/xdr.h
   Introduce 'struct xdr_buf' in order to allow RPC layer to handle
   pages directly.

include/linux/sunrpc/xprt.h:
   Convert the RPC client send-buffer to the new format.

net/sunrpc/clnt.c
   Initialize the new format RPC send-buffer.

net/sunrpc/sunrpc_syms.c
   Export xdr_encode_pages()

net/sunrpc/xdr.c
   xdr_kmap() kmap()+copy a struct xdr_buf into an iovec array.
   xdr_kunmap() clean up after xdr_kmap().
   xdr_encode_pages() used to inline pages for transmission.

net/sunrpc/xprt.c
   xprt_sendmsg() needs to kmap() the pages into an iovec for transmission.

include/linux/nfs_xdr.h
   struct nfs_writeargs transmits full page information.
   Convert nfs_rpc_ops->write() to send pages.

fs/nfs/write.c
   Adapt to new format nfs_writeargs / nfs_rpc_ops->write()

fs/nfs/proc.c
   Convert nfs_proc_write().

fs/nfs/nfs2xdr.c
   Convert nfs_xdr_writeargs()

fs/nfs/nfs3proc.c
   Convert nfs3_proc_write().

fs/nfs/nfs3xdr.c
   Convert nfs3_xdr_writeargs()

Cheers,
   Trond

PPPoATM uses tasklet_disable() on a tasklet inside a struct and then
frees the struct, leaving a pointer to the freed tasklet inside tasklet
lists.

This patch replaces tasklet_disable() with tasklet_kill().

Just remove duplicates among the asm-*/errno.h.

11 out of our 17 architectures have basically the same code
in arch/../kernel/signal.c:do_signal.  This patch creates a
common function for that bit of code and uses it in the places
it can be.

The 2.5.15 version of this patch builds and runs on i386 and PPC and has
been briefly looked at by the CRIS, PARISC, PPC64 and x86_64 maintainers.

As a bonus, this fixes the "ignore SIGURG" bug for 9 more architectures
(i386 and PPC already were fixed).

This patch creates asm-generic/siginfo.h and uses it to remove a
lot of duplicate code in the various asm-*/siginfo.h files.  Some
if it is a little ugly, but I think it will be worth it just to
help us eliminate some of the bugs that have come from code copying.

This patch moves a version of copy_siginfo_to_user that is common to
ten of our architectures into the gerneic code and allows the other
architectures to override it.  I suspect more of the remaining
architectures will be able to use it as well once it is fixed (patch
to follow).

- alpha_using_srm is #define'd for machine specific kernels, but
  is a real integer variable for generic Alpha kernels. Export
  it...

- The callback_* functions are _always_ there (they might be NOP
  functions owith generic kernels on non-SRM machines).

- srm_env can now be compiled on generic alpha kernels. An
  explicit check for SRM capability was always there:-)

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

This patch provides the ability for a block driver to signal it's too
busy to receive more work and temporarily halt the request queue. In
concept it's similar to the networking netif_{start,stop}_queue helpers.

To do this cleanly, I've ripped out the old tq_disk task queue. Instead
an internal list of plugged queues is maintained which will honor the
current queue state (see QUEUE_FLAG_STOPPED bit). Execution of
request_fn has been moved to tasklet context. blk_run_queues() provides
similar functionality to the old run_task_queue(&tq_disk).

Now, this only works at the request_fn level and not at the
make_request_fn level. This is on purpose: drivers working at the
make_request_fn level are essentially providing a piece of the block
level infrastructure themselves. There are basically two reasons for
doing make_request_fn style setups:

o block remappers. start/stop functionality will be done at the target
  device in this case, which is the level that will signal hardware full
  (or continue) anyways.

o drivers who wish to receive single entities of "buffers" and not
  merged requests etc. This could use the start/stop functionality. I'd
  suggest _still_ using a request_fn for these, but set the queue
  options so that no merging etc ever takes place. This has the added
  bonus of providing the usual request depletion throttling at the block
  level.

It looks like a race betwen exec_mmap and access_process_vm in
proc_pid_cmdline (or any other procfs functions that uses
access_process_vm).

o blk_get_request() and blk_put_request() needs exporting
o blk_max_pfn is used by BLOCK_BOUNCE_ANY, which modular SCSI needs

> Hmm. That patch does not compile. "p->cpu" does not exist, it's
> "p->thread_info->cpu". Tssk.

Ouch, I am bad.  Sorry.

Make the ChangeLog entry something really defamatory.

	Robert Love

This is William Irwin's algorithmically O(1) version of
count_active_tasks (which is currently O(n) for n total tasks on the
system).

I like it a lot: we become O(1) because now we count uninterruptible
tasks, so we can return (nr_uninterruptible + nr_running).  It does not
introduce any overhead or hurt the case for small n, so I have no
complaints.

This copy has a small optimization over the original posting, but is
otherwise the same thing wli posted earlier.  I have tested to make sure
this returns accurate results and that the kernel profile improves.

Previously assigned resources are perfectly valid - just silently
ignore them.

Attached patch adds output of rt_priority and policy to
/proc/<pid>/stats.

This will not break compatibility with existing applications and will
allow ps(1) and friends to display pertinent scheduling information.

Please apply this patch to let binfmt_em86.c compile again.

As pointed out by Russell King, resource name pointers
of the secondary PCI buses are left uninitialized in the
non-x86 PCI allocation path.

Assigning these pointers in pci_add_new_bus() fixes the problem.

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

 - Eliminate all usages of the obscure QUEUE_EMPTY macro.

 - Eliminate all unneccessary checks for RQ_INACTIVE, this can't happen during
   the time we run the request strategy routine of a single major number block
   device. Perhaps the still remaining usage in scsi and i2o_block.c should be
   killed as well, since the upper ll_rw_blk layer shouldn't pass inactive
   requests down.

Those are all places where we have deeply burried and hidden major number
indexed arrays. Let's deal with them slowly...

Since apparently no body else did care thus far, and since I'm using
this driver, well here it comes:

 - Adjust the airo wireless LAN card driver for the fact that modules
   don't export symbols by default any longer.

 - Make some stuff which obivously should be static there static as well.
   (Plenty of code in Linux actually deserves a review for this
   far too common bug...)

 - Replace ide_delay_50m with mdelay(50). There is absolutely no reason we
   should behave different behaviors whatever IDECS support is enabled or not.

 - Kill last parameter of ide_register_hw(). It should return a pointer to the
   interface registered later.

 - pdc202xx patches by Bartomiej onierkiewicz.

 - ServerWorks chi pset support cleanup by Andrej Panin.

 - Move temporarily ide_setup_ports to main.c unfold it in ide-pnp.c.

This fixes three locations in net/ where per-CPU data could bite us
under preemption.  This is the result of an audit I did and should
constitute all of the unsafe code in net/.

In net/core/skbuff.c I did not have to introduce any code - just
rearrange the grabbing of smp_processor_id() to be in the interrupt off
region.  Pretty clean fixes.

Note in the future we can use put_cpu() and get_cpu() to grab the CPU#
safely.  I will send a patch to Marcelo so we can have a 2.4 version
(which doesn't do the preempt stuff), too...

This adds an optimization to set_cpus_allowed: if the task is not
running, there is no sense in kicking the migration_threads into action,
we just need to update task->cpu.  This was suggested by Mike Kravetz.

Besides being an optimization, this would prevent any future race
between set_cpus_allowed and the migration_threads.

This adds documentation about the O(1) scheduler to Documentation/.  The
new scheduler is complicated and providing future scheduler hackers some
background seems a Good Thing to me.

Specifically:

- add Documentation/sched-coding.txt: an overview of the functions,
  magic numbers, and variables in the scheduler as well as (most
  importantly) a review of the locking semantics.

- add Documentation/sched-design.txt: an edited version of Ingo's
  initial email to lkml about his scheduler.  Goes over the design,
  implementation, and goals of the scheduler.  I tried to edit it where
  needed to bring it in line with the scheduler as it is today.

- modify kernel/sched.c: update your copyright and add a change entry
  for the new scheduler.

The attached trivial patch simply changes the printk debug statement in
do_exit when preempt_count!=0 to say "note" instead of "error" and log
at KERN_INFO in lieu of KERN_ERR.

I want to keep the message around a bit, but people get too paranoid
when things like nfsd legitimately exit with a preempt_count=1.

Use "make BUILD_MODULES=1 {,bzImage,zImage,vmlinux,...}" to build
your kernel - and it'll also build the modules as you go.

99% of the Makefiles are very simple target-wise:

o build modules as listed in $(obj-m) and 
o build $(L_TARGET)/$(O_TARGET) as a composite object containing $(obj-y)

However, there is one exception: typically arch/$ARCH/kernel Makefile
wants the same as above, plus
o build init_task.o, head.o, using the standard rules for built-in
  targets - i.e. they are supposed to be built in the same way as all
  the other targets listed in $(obj-y), but they should not be linked
  into arch/$ARCH/kernel/$(O_TARGET). Instead they'll be linked in
  directly in the final vmlinux link.

Currently this is achieved by overriding Rules.make's first_rule in 
arch/$ARCH/kernel/Makefile. This rather ad-hoc way relies on the knowing
how Rules.make works internally and at the same time does things behind
Rules.make's back. 

To clean this up, I'm introducing a new variable, supposed to be only
used in arch/$ARCH/kernel/Makefile:

$(EXTRA_TARGETS) can be used to declare additional objects which shall
be built in the current directory (using the flags for built-in objects),
but not linked into $(O_TARGET)/$(L_TARGET)

This patch only converts arch/i386/kernel/Makefile at this time, other
archs work the same way as before.

Apart from this, this patch also removes some "unexport ..." statements,
which are unnecessary since not exporting variables is the default and
renames the internal "all_targets" to "vmlinux", since it's actually
need for building vmlinux.

include/linux/compile.h is a generated file, only init/Makefile knows 
about it - including it outside of init/* will cause trouble on
parallel builds.

Also, when compile.h already exists when 'make dep' is run, that'll pick
up a dependency on $(TOPDIR)/include/linux/compile.h. So init/Makefile
needs to tell make that this is actually the same file as 
../include/linux.compile.h

This makes sure that sys_sync() will terminate.  It counts up the
number of dirty pages in the machine and will refuse to write out more
than 1.25 times this number of pages.  This function is called twice
on the sys_sync() path, so the kernel will actually write 2.5x the number
of initially-dirty pages before giving up.