The attached patch does the following:

1. Remove blkdev_release_request(Request); it was an unnecessary wrapper
    around blk_put_request(Request). Likely some leftover from pre-BIO
    time...

2. Abstract out the fine __scsi_insert_special() function out from
    the SCSI code.

    Now that I have finally managed to kill all those IDE 'specific'
    REQ_BLAH request types, we can do this final step, and it will be
    used soon at least by ATA code as well. The goal is that
    scsi_request_fn and do_ide_request should start to look similar
    like silblings.

    Its called blk_insert_request() now and even documented in code.

3. Change some stuff over from extern inline to static inline in
    blkdev.h. (trivia...)

This patch doesn't change *any* functionality, so its not exposing
SCSI to any danger :-).

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

The following two patches seem to be needed to export the requisite
symbols needed for fully modular builds of the new serial drivers in
2.5.28.

The old form of designated initializers are obsolete: we need to
replace them with the ISO C forms before 2.6.  Gcc has always
supported both forms anyway.

From Rusty's Trivial Patch - thanks.

Trying to open a non-present port (for configuration) causes us to
to endlessly loop (by returning -ERESTARTSYS).  We should be returning
success.  This cset fixes this.

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

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

Add full support for the NFSv3 permissions checking. Ensures that we
work properly with NFSv3 servers that do uid/gid mapping and/or have
support for ACLs.

Permissions are cached in the struct nfs_inode in order to reduce the
number of RPC calls. The cache timeout period is given by the ordinary
attribute timeout.

Reduce the number of getattr/lookup calls in nfs_lookup_revalidate()
by making the latter rely on the ordinary attribute cache, and moving
the close-to-open data consistency checking into nfs_open().

This does mean that we can end up calling GETATTR twice: once in
nfs_lookup_revalidate() then immediately after in nfs_open(), however
it also means that sys_stat() and friends now use cached attributes.

Make RPC over UDP use a socket buffer size that is large enough to fit
all the messages. Congestion control is in any case handled by the Van
Jacobson algoritm, and we need to work around a bug in
ip_build_xmit_slow() w.r.t. fragmentation when there is insufficient
buffer memory to fit the entire message.

Make the RPC write_space() algoritm use the standard socket flags
SOCK_ASYNC_NOSPACE and SOCK_NOSPACE instead of its own custom flag.

This updates the F00F bug workaround code to the IDT changes in the TLS
patch.

Tested it on a non-Pentium box on which i triggered the workaround
artificially.

This fixes the ACPI_DEBUG compile issue that turned up.

  + cleanup init.c and split into pgtable.c
  + split declaration of _text, _etext outside into sections.h

* handle another cardbus unplug misbehavior
     - root hub kept polling, never stopped
     - starts to update hcd->state to match internal state
* code to count/queue TDs for interrupt/bulk is now shared
     - removes (low level) interrupt transfer size limitation
     - both types already handled urb queueing
     - re-indents some TD queuing code (most of patch, by volume)
* cleanup
     - use new container_of() macro, not list_entry()
     - report a previously unreported error (control data >4K)
     - simplify intr/bulk toggle reset
     - tweak TD debug dump
     - more object code shrinkage (often fits in 3 pages)

Note that the control data size error is just a long-standing
limitation of this driver, not a USB limitation!  It could be
fixed, if anyone starts to run into it.

  Here's a patch for extra designated initializer conversions in
  drivers/usb/input/wacom.c. Patch is against 2.5.27.

  Here's a patch for additional designated initializers for
  drivers/usb/storage/usb.c. Patch is against 2.5.27.

  Here's an patch for additional designated initializers for
  drivers/usb/input/hid-core.c. Patch is against 2.5.27.

  Symbols CONFIG_USB_STORAGE_DATAFAB, CONFIG_USB_STORAGE_HP8200e,
  CONFIG_USB_STORAGE_SDDR09, CONFIG_USB_STORAGE_SDDR55, and
  CONFIG_USB_STORAGE_JUMPSHOT depend on CONFIG_EXPERIMENTAL but
  do not say so in their banners.

  Here's a patch for additional designated initializers in
  drivers/usb/class/audio.c. Patch is against 2.5.27.

  Here's a patch for additional designated initializers for
  drivers/usb/net/pegasus.c. Patch is against 2.5.27.

  Here's a patch for additional designated initializers for
  drivers/usb/net/usbnet.c. Patch is against 2.5.27.

  Here's a patch for additional designated initializers in
  drivers/usb/misc/emi26.c. Patch is against 2.5.27.

Some fixes from Johann Deneux:
  Fixes needed to get WingMan Force 3D running. (Fix in fixp_cos
  and hid_init_reports).

Here is a patch wich moves hid-lg3d.c into hid-lgff.c. This allows to
share the init code.
A side-effect of this merge is that rumble pads are now handled the same
way joysticks are. Instead of having one timer per effect, executing
only when needed, we have one timer executing at regular intervals going
over each effect.

Allocate positive instead of negative line numbers when 8250.c
registers a new port with the core.  This bug could cause
registrations to erroneously fail, or oopsen when the pcmcia
serial device is ejected.

Add irq_enter/exit to smp_call_function_interrupt():
arch/i386/kernel/microcode.c:do_microcode_update() calls
smp_call_function(do_update_one).  do_update_one() does
spin_lock/unlock.

Remove unneeded GET_THREAD_INFO(%ebx) in device_not_available() trap in
entry.S

At least it compiles now.

interrupt probing

This is no better or worse than the cli/sti the cmd640 driver
used to have, but at least it compiles and works in the new
scheme of things.

Perfection can wait. Especially since that probably involves
removing the PCI-related code, and just trusting the native
Linux direct PCI accesses.

These drivers are now part of drivers/serial

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

the following patch implements proper x86 TLS support in the Linux kernel,
via a new system-call, sys_set_thread_area():

   http://redhat.com/~mingo/tls-patches/tls-2.5.28-C6

a TLS test utility can be downloaded from:

    http://redhat.com/~mingo/tls-patches/tls_test.c

what is TLS? Thread Local Storage is a concept used by threading
abstractions - fast an efficient way to store per-thread local (but not
on-stack local) data. The __thread extension is already supported by gcc.

proper TLS support in compilers (and glibc/pthreads) is a bit problematic
on the x86 platform. There's only 8 general purpose registers available,
so on x86 we have to use segments to access the TLS. The approach used by
glibc so far was to set up a per-thread LDT entry to describe the TLS.
Besides the generic unrobustness of LDTs, this also introduced a limit:
the maximum number of LDT entries is 8192, so the maximum number of
threads per application is 8192.

this patch does it differently - the kernel keeps a specific per-thread
GDT entry that can be set up and modified by each thread:

     asmlinkage int sys_set_thread_area(unsigned int base,
               unsigned int limit, unsigned int flags)

the kernel, upon context-switch, modifies this GDT entry to match that of
the thread's TLS setting. This way user-space threaded code can access
per-thread data via this descriptor - by using the same, constant %gs (or
%gs) selector. The number of TLS areas is unlimited, and there is no
additional allocation overhead associated with TLS support.


the biggest problem preventing the introduction of this concept was
Linux's global shared GDT on SMP systems. The patch fixes this by
implementing a per-CPU GDT, which is also a nice context-switch speedup,
2-task lat_ctx context-switching got faster by about 5% on a dual Celeron
testbox. [ Could it be that a shared GDT is fundamentally suboptimal on
SMP? perhaps updating the 'accessed' bit in the DS/CS descriptors causes
some sort locked memory cycle overhead? ]

the GDT layout got simplified:

 *   0 - null
 *   1 - Thread-Local Storage (TLS) segment
 *   2 - kernel code segment
 *   3 - kernel data segment
 *   4 - user code segment              <==== new cacheline
 *   5 - user data segment
 *   6 - TSS
 *   7 - LDT
 *   8 - APM BIOS support               <==== new cacheline
 *   9 - APM BIOS support
 *  10 - APM BIOS support
 *  11 - APM BIOS support
 *  12 - PNPBIOS support                <==== new cacheline
 *  13 - PNPBIOS support
 *  14 - PNPBIOS support
 *  15 - PNPBIOS support
 *  16 - PNPBIOS support                <==== new cacheline
 *  17 - not used
 *  18 - not used
 *  19 - not used

set_thread_area() currently recognizes the following flags:

  #define TLS_FLAG_LIMIT_IN_PAGES         0x00000001
  #define TLS_FLAG_WRITABLE               0x00000002
  #define TLS_FLAG_CLEAR                  0x00000004

- in theory we could avoid the 'limit in pages' bit, but i wanted to
  preserve the flexibility to potentially enable the setting of
  byte-granularity stack segments for example. And unlimited segments
  (granularity = pages, limit = 0xfffff) might have a performance
  advantage on some CPUs. We could also automatically figure out the best
  possible granularity for a given limit - but i wanted to avoid this kind
  of guesswork. Some CPUs might have a plus for page-limit segments - who
  knows.

- The 'writable' flag is straightforward and could be useful to some
  applications.

- The 'clear' flag clears the TLS. [note that a base 0 limit 0 TLS is in
  fact legal, it's a single-byte segment at address 0.]

(the system-call does not expose any other segment options to user-space,
priviledge level is 3, the segment is 32-bit, etc. - it's using safe and
sane defaults.)

NOTE: the interface does not allow the changing of the TLS of another
thread on purpose - that would just complicate the interface (and
implementation) unnecesserily. Is there any good reason to allow the
setting of another thread's TLS?

NOTE2: non-pthreads glibc applications can call set_thread_area() to set
up a GDT entry just below the end of stack. We could use some sort of
default TLS area as well, but that would hard-code a given segment.