[kernel] r11594 - in dists/sid/linux-2.6/debian: . patches/bugfix/all/stable patches/series
Maximilian Attems
maks at alioth.debian.org
Mon Jun 9 23:16:06 UTC 2008
Author: maks
Date: Mon Jun 9 23:16:05 2008
New Revision: 11594
Log:
add stable 2.6.25.6
long awaited, with long list of fixes.
vserver fails to apply:
1 out of 8 hunks FAILED -- saving rejects to file fs/proc/array.c.rej
(+) FAIL features/all/vserver/vs2.3.0.34.11.patch
please fix
Added:
dists/sid/linux-2.6/debian/patches/bugfix/all/stable/2.6.25.6.patch
Modified:
dists/sid/linux-2.6/debian/changelog
dists/sid/linux-2.6/debian/patches/series/5
Modified: dists/sid/linux-2.6/debian/changelog
==============================================================================
--- dists/sid/linux-2.6/debian/changelog (original)
+++ dists/sid/linux-2.6/debian/changelog Mon Jun 9 23:16:05 2008
@@ -6,6 +6,64 @@
[ maximilian attems ]
* Add stable release 2.6.25.5:
- asn1: additional sanity checking during BER decoding (CVE-2008-1673)
+ * Add stable release 2.6.25.6:
+ - atl1: fix 4G memory corruption bug
+ - capabilities: remain source compatible with 32-bit raw legacy capability
+ support.
+ - usb-serial: Use ftdi_sio driver for RATOC REX-USB60F
+ - cpufreq: fix null object access on Transmeta CPU
+ - Smack: fuse mount hang fix
+ - cgroups: remove node_ prefix_from ns subsystem
+ - XFS: Fix memory corruption with small buffer reads
+ - x86: don't read maxlvt before checking if APIC is mapped
+ - USB: option: add new Dell 5520 HSDPA variant
+ - md: do not compute parity unless it is on a failed drive
+ - md: fix uninitialized use of mddev->recovery_wait
+ - md: fix prexor vs sync_request race
+ - HID: split Numlock emulation quirk from HID_QUIRK_APPLE_HAS_FN.
+ - USB: do not handle device 1410:5010 in 'option' driver
+ - USB: unusual_devs: Add support for GI 0401 SD-Card interface
+ - USB: add Telstra NextG CDMA id to option driver
+ - USB: fix build errors in ohci-omap.c and ohci-sm501.c
+ - USB: add TELIT HDSPA UC864-E modem to option driver
+ - memory_hotplug: always initialize pageblock bitmap
+ - x86: fix bad pmd ffff810000207xxx(9090909090909090)
+ - USB: add Zoom Telephonics Model 3095F V.92 USB Mini External modem to
+ cdc-acm
+ - x86: prevent PGE flush from interruption/preemption
+ - IPoIB: Test for NULL broadcast object in ipiob_mcast_join_finish()
+ - i386: fix asm constraint in do_IRQ()
+ - i2c-nforce2: Disable the second SMBus channel on the DFI Lanparty NF4
+ Expert
+ - i2c/max6875: Really prevent 24RF08 corruption
+ - brk: make sys_brk() honor COMPAT_BRK when computing lower bound
+ - Revert "PCI: remove default PCI expansion ROM memory allocation"
+ - PS3: gelic: fix memory leak
+ - eCryptfs: remove unnecessary page decrypt call
+ - netfilter: nf_conntrack_expect: fix error path unwind in
+ nf_conntrack_expect_init()
+ - netfilter: xt_connlimit: fix accouning when receive RST packet in
+ ESTABLISHED state
+ - netfilter: nf_conntrack_ipv6: fix inconsistent lock state in
+ nf_ct_frag6_gather()
+ - POWERPC Bolt in SLB entry for kernel stack on secondary cpus
+ - netfilter: xt_iprange: module aliases for xt_iprange
+ - x86: user_regset_view table fix for ia32 on 64-bit
+ - x86: if we cannot calibrate the TSC, we panic.
+ - CIFS: Fix UNC path prefix on QueryUnixPathInfo to have correct slash
+ - x86, fpu: fix CONFIG_PREEMPT=y corruption of application's FPU stack
+ - libata: force hardreset if link is in powersave mode
+ - x86: fix setup of cyc2ns in tsc_64.c
+ - x86: distangle user disabled TSC from unstable
+ - x86: disable TSC for sched_clock() when calibration failed
+ - pagemap: fix bug in add_to_pagemap, require aligned-length reads of
+ /proc/pid/pagemap
+ - ext3/4: fix uninitialized bs in ext3/4_xattr_set_handle()
+ - proc: calculate the correct /proc/<pid> link count
+ - CPUFREQ: Make acpi-cpufreq more robust against BIOS freq changes behind
+ our back.
+ - USB: remove PICDEM FS USB demo (04d8:000c) device from ldusb
+ - types.h: don't expose struct ustat to userspace
-- Bastian Blank <waldi at debian.org> Wed, 28 May 2008 23:55:43 +0200
Added: dists/sid/linux-2.6/debian/patches/bugfix/all/stable/2.6.25.6.patch
==============================================================================
--- (empty file)
+++ dists/sid/linux-2.6/debian/patches/bugfix/all/stable/2.6.25.6.patch Mon Jun 9 23:16:05 2008
@@ -0,0 +1,1803 @@
+diff --git a/arch/powerpc/kernel/smp.c b/arch/powerpc/kernel/smp.c
+index be35ffa..1457aa0 100644
+--- a/arch/powerpc/kernel/smp.c
++++ b/arch/powerpc/kernel/smp.c
+@@ -386,6 +386,8 @@ static void __init smp_create_idle(unsigned int cpu)
+ panic("failed fork for CPU %u: %li", cpu, PTR_ERR(p));
+ #ifdef CONFIG_PPC64
+ paca[cpu].__current = p;
++ paca[cpu].kstack = (unsigned long) task_thread_info(p)
++ + THREAD_SIZE - STACK_FRAME_OVERHEAD;
+ #endif
+ current_set[cpu] = task_thread_info(p);
+ task_thread_info(p)->cpu = cpu;
+diff --git a/arch/powerpc/mm/slb.c b/arch/powerpc/mm/slb.c
+index 906daed..a9626d6 100644
+--- a/arch/powerpc/mm/slb.c
++++ b/arch/powerpc/mm/slb.c
+@@ -44,13 +44,13 @@ static void slb_allocate(unsigned long ea)
+ slb_allocate_realmode(ea);
+ }
+
++#define slb_esid_mask(ssize) \
++ (((ssize) == MMU_SEGSIZE_256M)? ESID_MASK: ESID_MASK_1T)
++
+ static inline unsigned long mk_esid_data(unsigned long ea, int ssize,
+ unsigned long slot)
+ {
+- unsigned long mask;
+-
+- mask = (ssize == MMU_SEGSIZE_256M)? ESID_MASK: ESID_MASK_1T;
+- return (ea & mask) | SLB_ESID_V | slot;
++ return (ea & slb_esid_mask(ssize)) | SLB_ESID_V | slot;
+ }
+
+ #define slb_vsid_shift(ssize) \
+@@ -301,11 +301,16 @@ void slb_initialize(void)
+
+ create_shadowed_slbe(VMALLOC_START, mmu_kernel_ssize, vflags, 1);
+
++ /* For the boot cpu, we're running on the stack in init_thread_union,
++ * which is in the first segment of the linear mapping, and also
++ * get_paca()->kstack hasn't been initialized yet.
++ * For secondary cpus, we need to bolt the kernel stack entry now.
++ */
+ slb_shadow_clear(2);
++ if (raw_smp_processor_id() != boot_cpuid &&
++ (get_paca()->kstack & slb_esid_mask(mmu_kernel_ssize)) > PAGE_OFFSET)
++ create_shadowed_slbe(get_paca()->kstack,
++ mmu_kernel_ssize, lflags, 2);
+
+- /* We don't bolt the stack for the time being - we're in boot,
+- * so the stack is in the bolted segment. By the time it goes
+- * elsewhere, we'll call _switch() which will bolt in the new
+- * one. */
+ asm volatile("isync":::"memory");
+ }
+diff --git a/arch/x86/kernel/apic_64.c b/arch/x86/kernel/apic_64.c
+index d8d03e0..9629434 100644
+--- a/arch/x86/kernel/apic_64.c
++++ b/arch/x86/kernel/apic_64.c
+@@ -524,7 +524,7 @@ int setup_profiling_timer(unsigned int multiplier)
+ */
+ void clear_local_APIC(void)
+ {
+- int maxlvt = lapic_get_maxlvt();
++ int maxlvt;
+ u32 v;
+
+ /* APIC hasn't been mapped yet */
+diff --git a/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c b/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
+index a962dcb..404ff26 100644
+--- a/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
++++ b/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
+@@ -339,6 +339,7 @@ static unsigned int get_cur_freq_on_cpu(unsigned int cpu)
+ {
+ struct acpi_cpufreq_data *data = per_cpu(drv_data, cpu);
+ unsigned int freq;
++ unsigned int cached_freq;
+
+ dprintk("get_cur_freq_on_cpu (%d)\n", cpu);
+
+@@ -347,7 +348,16 @@ static unsigned int get_cur_freq_on_cpu(unsigned int cpu)
+ return 0;
+ }
+
++ cached_freq = data->freq_table[data->acpi_data->state].frequency;
+ freq = extract_freq(get_cur_val(cpumask_of_cpu(cpu)), data);
++ if (freq != cached_freq) {
++ /*
++ * The dreaded BIOS frequency change behind our back.
++ * Force set the frequency on next target call.
++ */
++ data->resume = 1;
++ }
++
+ dprintk("cur freq = %u\n", freq);
+
+ return freq;
+diff --git a/arch/x86/kernel/irq_32.c b/arch/x86/kernel/irq_32.c
+index cef054b..89bb5ee 100644
+--- a/arch/x86/kernel/irq_32.c
++++ b/arch/x86/kernel/irq_32.c
+@@ -134,7 +134,7 @@ unsigned int do_IRQ(struct pt_regs *regs)
+ : "=a" (arg1), "=d" (arg2), "=b" (bx)
+ : "0" (irq), "1" (desc), "2" (isp),
+ "D" (desc->handle_irq)
+- : "memory", "cc"
++ : "memory", "cc", "ecx"
+ );
+ } else
+ #endif
+diff --git a/arch/x86/kernel/process_32.c b/arch/x86/kernel/process_32.c
+index 43930e7..c8890b8 100644
+--- a/arch/x86/kernel/process_32.c
++++ b/arch/x86/kernel/process_32.c
+@@ -710,8 +710,11 @@ struct task_struct * __switch_to(struct task_struct *prev_p, struct task_struct
+ /* If the task has used fpu the last 5 timeslices, just do a full
+ * restore of the math state immediately to avoid the trap; the
+ * chances of needing FPU soon are obviously high now
++ *
++ * tsk_used_math() checks prevent calling math_state_restore(),
++ * which can sleep in the case of !tsk_used_math()
+ */
+- if (next_p->fpu_counter > 5)
++ if (tsk_used_math(next_p) && next_p->fpu_counter > 5)
+ math_state_restore();
+
+ /*
+diff --git a/arch/x86/kernel/process_64.c b/arch/x86/kernel/process_64.c
+index 46c4c54..1316f1c 100644
+--- a/arch/x86/kernel/process_64.c
++++ b/arch/x86/kernel/process_64.c
+@@ -696,8 +696,11 @@ __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
+ /* If the task has used fpu the last 5 timeslices, just do a full
+ * restore of the math state immediately to avoid the trap; the
+ * chances of needing FPU soon are obviously high now
++ *
++ * tsk_used_math() checks prevent calling math_state_restore(),
++ * which can sleep in the case of !tsk_used_math()
+ */
+- if (next_p->fpu_counter>5)
++ if (tsk_used_math(next_p) && next_p->fpu_counter > 5)
+ math_state_restore();
+ return prev_p;
+ }
+diff --git a/arch/x86/kernel/ptrace.c b/arch/x86/kernel/ptrace.c
+index eb92ccb..9003e0b 100644
+--- a/arch/x86/kernel/ptrace.c
++++ b/arch/x86/kernel/ptrace.c
+@@ -1382,6 +1382,9 @@ static const struct user_regset_view user_x86_64_view = {
+ #define genregs32_get genregs_get
+ #define genregs32_set genregs_set
+
++#define user_i387_ia32_struct user_i387_struct
++#define user32_fxsr_struct user_fxsr_struct
++
+ #endif /* CONFIG_X86_64 */
+
+ #if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
+@@ -1394,13 +1397,13 @@ static const struct user_regset x86_32_regsets[] = {
+ },
+ [REGSET_FP] = {
+ .core_note_type = NT_PRFPREG,
+- .n = sizeof(struct user_i387_struct) / sizeof(u32),
++ .n = sizeof(struct user_i387_ia32_struct) / sizeof(u32),
+ .size = sizeof(u32), .align = sizeof(u32),
+ .active = fpregs_active, .get = fpregs_get, .set = fpregs_set
+ },
+ [REGSET_XFP] = {
+ .core_note_type = NT_PRXFPREG,
+- .n = sizeof(struct user_i387_struct) / sizeof(u32),
++ .n = sizeof(struct user32_fxsr_struct) / sizeof(u32),
+ .size = sizeof(u32), .align = sizeof(u32),
+ .active = xfpregs_active, .get = xfpregs_get, .set = xfpregs_set
+ },
+diff --git a/arch/x86/kernel/tsc_32.c b/arch/x86/kernel/tsc_32.c
+index c2241e0..01e4f8b 100644
+--- a/arch/x86/kernel/tsc_32.c
++++ b/arch/x86/kernel/tsc_32.c
+@@ -14,7 +14,7 @@
+
+ #include "mach_timer.h"
+
+-static int tsc_enabled;
++static int tsc_disabled;
+
+ /*
+ * On some systems the TSC frequency does not
+@@ -28,8 +28,8 @@ EXPORT_SYMBOL_GPL(tsc_khz);
+ static int __init tsc_setup(char *str)
+ {
+ printk(KERN_WARNING "notsc: Kernel compiled with CONFIG_X86_TSC, "
+- "cannot disable TSC completely.\n");
+- mark_tsc_unstable("user disabled TSC");
++ "cannot disable TSC completely.\n");
++ tsc_disabled = 1;
+ return 1;
+ }
+ #else
+@@ -121,7 +121,7 @@ unsigned long long native_sched_clock(void)
+ * very important for it to be as fast as the platform
+ * can achive it. )
+ */
+- if (unlikely(!tsc_enabled && !tsc_unstable))
++ if (unlikely(tsc_disabled))
+ /* No locking but a rare wrong value is not a big deal: */
+ return (jiffies_64 - INITIAL_JIFFIES) * (1000000000 / HZ);
+
+@@ -310,7 +310,6 @@ void mark_tsc_unstable(char *reason)
+ {
+ if (!tsc_unstable) {
+ tsc_unstable = 1;
+- tsc_enabled = 0;
+ printk("Marking TSC unstable due to: %s.\n", reason);
+ /* Can be called before registration */
+ if (clocksource_tsc.mult)
+@@ -324,7 +323,7 @@ EXPORT_SYMBOL_GPL(mark_tsc_unstable);
+ static int __init dmi_mark_tsc_unstable(const struct dmi_system_id *d)
+ {
+ printk(KERN_NOTICE "%s detected: marking TSC unstable.\n",
+- d->ident);
++ d->ident);
+ tsc_unstable = 1;
+ return 0;
+ }
+@@ -391,14 +390,24 @@ void __init tsc_init(void)
+ {
+ int cpu;
+
+- if (!cpu_has_tsc)
+- goto out_no_tsc;
++ if (!cpu_has_tsc || tsc_disabled) {
++ /* Disable the TSC in case of !cpu_has_tsc */
++ tsc_disabled = 1;
++ return;
++ }
+
+ cpu_khz = calculate_cpu_khz();
+ tsc_khz = cpu_khz;
+
+- if (!cpu_khz)
+- goto out_no_tsc;
++ if (!cpu_khz) {
++ mark_tsc_unstable("could not calculate TSC khz");
++ /*
++ * We need to disable the TSC completely in this case
++ * to prevent sched_clock() from using it.
++ */
++ tsc_disabled = 1;
++ return;
++ }
+
+ printk("Detected %lu.%03lu MHz processor.\n",
+ (unsigned long)cpu_khz / 1000,
+@@ -427,13 +436,6 @@ void __init tsc_init(void)
+ if (check_tsc_unstable()) {
+ clocksource_tsc.rating = 0;
+ clocksource_tsc.flags &= ~CLOCK_SOURCE_IS_CONTINUOUS;
+- } else
+- tsc_enabled = 1;
+-
++ }
+ clocksource_register(&clocksource_tsc);
+-
+- return;
+-
+-out_no_tsc:
+- setup_clear_cpu_cap(X86_FEATURE_TSC);
+ }
+diff --git a/arch/x86/kernel/tsc_64.c b/arch/x86/kernel/tsc_64.c
+index d3bebaa..5153afc 100644
+--- a/arch/x86/kernel/tsc_64.c
++++ b/arch/x86/kernel/tsc_64.c
+@@ -227,14 +227,14 @@ void __init tsc_calibrate(void)
+ /* hpet or pmtimer available ? */
+ if (!hpet && !pm1 && !pm2) {
+ printk(KERN_INFO "TSC calibrated against PIT\n");
+- return;
++ goto out;
+ }
+
+ /* Check, whether the sampling was disturbed by an SMI */
+ if (tsc1 == ULONG_MAX || tsc2 == ULONG_MAX) {
+ printk(KERN_WARNING "TSC calibration disturbed by SMI, "
+ "using PIT calibration result\n");
+- return;
++ goto out;
+ }
+
+ tsc2 = (tsc2 - tsc1) * 1000000L;
+@@ -255,6 +255,7 @@ void __init tsc_calibrate(void)
+
+ tsc_khz = tsc2 / tsc1;
+
++out:
+ for_each_possible_cpu(cpu)
+ set_cyc2ns_scale(tsc_khz, cpu);
+ }
+diff --git a/arch/x86/mm/init_64.c b/arch/x86/mm/init_64.c
+index a02a14f..b2c5231 100644
+--- a/arch/x86/mm/init_64.c
++++ b/arch/x86/mm/init_64.c
+@@ -192,7 +192,7 @@ void __init cleanup_highmap(void)
+ pmd_t *last_pmd = pmd + PTRS_PER_PMD;
+
+ for (; pmd < last_pmd; pmd++, vaddr += PMD_SIZE) {
+- if (!pmd_present(*pmd))
++ if (pmd_none(*pmd))
+ continue;
+ if (vaddr < (unsigned long) _text || vaddr > end)
+ set_pmd(pmd, __pmd(0));
+diff --git a/arch/x86/pci/common.c b/arch/x86/pci/common.c
+index 05356ce..c7e2a44 100644
+--- a/arch/x86/pci/common.c
++++ b/arch/x86/pci/common.c
+@@ -130,19 +130,6 @@ static void __devinit pcibios_fixup_ghosts(struct pci_bus *b)
+ }
+ }
+
+-static void __devinit pcibios_fixup_device_resources(struct pci_dev *dev)
+-{
+- struct resource *rom_r = &dev->resource[PCI_ROM_RESOURCE];
+-
+- if (rom_r->parent)
+- return;
+- if (rom_r->start)
+- /* we deal with BIOS assigned ROM later */
+- return;
+- if (!(pci_probe & PCI_ASSIGN_ROMS))
+- rom_r->start = rom_r->end = rom_r->flags = 0;
+-}
+-
+ /*
+ * Called after each bus is probed, but before its children
+ * are examined.
+@@ -150,12 +137,8 @@ static void __devinit pcibios_fixup_device_resources(struct pci_dev *dev)
+
+ void __devinit pcibios_fixup_bus(struct pci_bus *b)
+ {
+- struct pci_dev *dev;
+-
+ pcibios_fixup_ghosts(b);
+ pci_read_bridge_bases(b);
+- list_for_each_entry(dev, &b->devices, bus_list)
+- pcibios_fixup_device_resources(dev);
+ }
+
+ /*
+diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
+index be95fdb..92da864 100644
+--- a/drivers/ata/libata-core.c
++++ b/drivers/ata/libata-core.c
+@@ -3947,6 +3947,7 @@ int ata_std_prereset(struct ata_link *link, unsigned long deadline)
+ struct ata_port *ap = link->ap;
+ struct ata_eh_context *ehc = &link->eh_context;
+ const unsigned long *timing = sata_ehc_deb_timing(ehc);
++ u32 sstatus;
+ int rc;
+
+ /* handle link resume */
+@@ -3960,6 +3961,17 @@ int ata_std_prereset(struct ata_link *link, unsigned long deadline)
+ if (ap->flags & ATA_FLAG_PMP)
+ ehc->i.action |= ATA_EH_HARDRESET;
+
++ /* if link powersave is on, force hardreset */
++ if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0) {
++ u8 ipm = sstatus >> 8;
++
++ if (ipm == 2 || ipm == 6) {
++ ata_link_printk(link, KERN_INFO, "link in powersave "
++ "mode (ipm=%d), forcing hardreset\n", ipm);
++ ehc->i.action |= ATA_EH_HARDRESET;
++ }
++ }
++
+ /* if we're about to do hardreset, nothing more to do */
+ if (ehc->i.action & ATA_EH_HARDRESET)
+ return 0;
+diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
+index 35a26a3..99aa5f5 100644
+--- a/drivers/cpufreq/cpufreq.c
++++ b/drivers/cpufreq/cpufreq.c
+@@ -607,7 +607,7 @@ static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
+ unsigned int freq = 0;
+ unsigned int ret;
+
+- if (!policy->governor->store_setspeed)
++ if (!policy->governor || !policy->governor->store_setspeed)
+ return -EINVAL;
+
+ ret = sscanf(buf, "%u", &freq);
+@@ -621,7 +621,7 @@ static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
+
+ static ssize_t show_scaling_setspeed(struct cpufreq_policy *policy, char *buf)
+ {
+- if (!policy->governor->show_setspeed)
++ if (!policy->governor || !policy->governor->show_setspeed)
+ return sprintf(buf, "<unsupported>\n");
+
+ return policy->governor->show_setspeed(policy, buf);
+diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
+index c3eb3f1..452b94d 100644
+--- a/drivers/hid/hid-input.c
++++ b/drivers/hid/hid-input.c
+@@ -218,8 +218,9 @@ int hidinput_apple_event(struct hid_device *hid, struct input_dev *input,
+ }
+ }
+
+- if (test_bit(usage->code, hid->pb_pressed_numlock) ||
+- test_bit(LED_NUML, input->led)) {
++ if (hid->quirks & HID_QUIRK_APPLE_NUMLOCK_EMULATION && (
++ test_bit(usage->code, hid->pb_pressed_numlock) ||
++ test_bit(LED_NUML, input->led))) {
+ trans = find_translation(powerbook_numlock_keys, usage->code);
+
+ if (trans) {
+diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
+index e29a057..7fbe08c 100644
+--- a/drivers/hid/usbhid/hid-quirks.c
++++ b/drivers/hid/usbhid/hid-quirks.c
+@@ -613,28 +613,28 @@ static const struct hid_blacklist {
+
+ { USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SMARTJOY_DUAL_PLUS, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT },
+
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_ISO_KEYBOARD},
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_ISO_KEYBOARD},
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_ISO_KEYBOARD},
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_ISO_KEYBOARD},
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_ISO_KEYBOARD},
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_ISO_KEYBOARD},
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
+ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ANSI, HID_QUIRK_APPLE_HAS_FN },
+ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ISO, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_APPLE_ISO_KEYBOARD },
+ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_JIS, HID_QUIRK_APPLE_HAS_FN },
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI, HID_QUIRK_APPLE_HAS_FN },
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_APPLE_ISO_KEYBOARD },
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS, HID_QUIRK_APPLE_HAS_FN },
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
+- { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN },
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_APPLE_ISO_KEYBOARD },
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN },
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
++ { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
+
+ { USB_VENDOR_ID_DELL, USB_DEVICE_ID_DELL_W7658, HID_QUIRK_RESET_LEDS },
+ { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_KBD, HID_QUIRK_RESET_LEDS },
+diff --git a/drivers/i2c/busses/i2c-nforce2.c b/drivers/i2c/busses/i2c-nforce2.c
+index 3dac920..43c9f8d 100644
+--- a/drivers/i2c/busses/i2c-nforce2.c
++++ b/drivers/i2c/busses/i2c-nforce2.c
+@@ -50,6 +50,7 @@
+ #include <linux/init.h>
+ #include <linux/i2c.h>
+ #include <linux/delay.h>
++#include <linux/dmi.h>
+ #include <asm/io.h>
+
+ MODULE_LICENSE("GPL");
+@@ -109,6 +110,18 @@ struct nforce2_smbus {
+ /* Misc definitions */
+ #define MAX_TIMEOUT 100
+
++/* We disable the second SMBus channel on these boards */
++static struct dmi_system_id __devinitdata nforce2_dmi_blacklist2[] = {
++ {
++ .ident = "DFI Lanparty NF4 Expert",
++ .matches = {
++ DMI_MATCH(DMI_BOARD_VENDOR, "DFI Corp,LTD"),
++ DMI_MATCH(DMI_BOARD_NAME, "LP UT NF4 Expert"),
++ },
++ },
++ { }
++};
++
+ static struct pci_driver nforce2_driver;
+
+ static void nforce2_abort(struct i2c_adapter *adap)
+@@ -367,10 +380,17 @@ static int __devinit nforce2_probe(struct pci_dev *dev, const struct pci_device_
+ smbuses[0].base = 0; /* to have a check value */
+ }
+ /* SMBus adapter 2 */
+- res2 = nforce2_probe_smb(dev, 5, NFORCE_PCI_SMB2, &smbuses[1], "SMB2");
+- if (res2 < 0) {
+- dev_err(&dev->dev, "Error probing SMB2.\n");
+- smbuses[1].base = 0; /* to have a check value */
++ if (dmi_check_system(nforce2_dmi_blacklist2)) {
++ dev_err(&dev->dev, "Disabling SMB2 for safety reasons.\n");
++ res2 = -EPERM;
++ smbuses[1].base = 0;
++ } else {
++ res2 = nforce2_probe_smb(dev, 5, NFORCE_PCI_SMB2, &smbuses[1],
++ "SMB2");
++ if (res2 < 0) {
++ dev_err(&dev->dev, "Error probing SMB2.\n");
++ smbuses[1].base = 0; /* to have a check value */
++ }
+ }
+ if ((res1 < 0) && (res2 < 0)) {
+ /* we did not find even one of the SMBuses, so we give up */
+diff --git a/drivers/i2c/chips/max6875.c b/drivers/i2c/chips/max6875.c
+index fb7ea56..cf507b3 100644
+--- a/drivers/i2c/chips/max6875.c
++++ b/drivers/i2c/chips/max6875.c
+@@ -207,9 +207,6 @@ static int max6875_detect(struct i2c_adapter *adapter, int address, int kind)
+ fake_client->flags = 0;
+ strlcpy(fake_client->name, "max6875 subclient", I2C_NAME_SIZE);
+
+- /* Prevent 24RF08 corruption (in case of user error) */
+- i2c_smbus_write_quick(real_client, 0);
+-
+ if ((err = i2c_attach_client(real_client)) != 0)
+ goto exit_kfree2;
+
+diff --git a/drivers/infiniband/ulp/ipoib/ipoib_multicast.c b/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
+index 31a53c5..ae7e6e7 100644
+--- a/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
++++ b/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
+@@ -194,7 +194,13 @@ static int ipoib_mcast_join_finish(struct ipoib_mcast *mcast,
+ /* Set the cached Q_Key before we attach if it's the broadcast group */
+ if (!memcmp(mcast->mcmember.mgid.raw, priv->dev->broadcast + 4,
+ sizeof (union ib_gid))) {
++ spin_lock_irq(&priv->lock);
++ if (!priv->broadcast) {
++ spin_unlock_irq(&priv->lock);
++ return -EAGAIN;
++ }
+ priv->qkey = be32_to_cpu(priv->broadcast->mcmember.qkey);
++ spin_unlock_irq(&priv->lock);
+ priv->tx_wr.wr.ud.remote_qkey = priv->qkey;
+ }
+
+diff --git a/drivers/md/md.c b/drivers/md/md.c
+index 9f6d228..ba34990 100644
+--- a/drivers/md/md.c
++++ b/drivers/md/md.c
+@@ -274,6 +274,7 @@ static mddev_t * mddev_find(dev_t unit)
+ atomic_set(&new->active, 1);
+ spin_lock_init(&new->write_lock);
+ init_waitqueue_head(&new->sb_wait);
++ init_waitqueue_head(&new->recovery_wait);
+ new->reshape_position = MaxSector;
+ new->resync_max = MaxSector;
+
+@@ -5559,7 +5560,6 @@ void md_do_sync(mddev_t *mddev)
+ window/2,(unsigned long long) max_sectors/2);
+
+ atomic_set(&mddev->recovery_active, 0);
+- init_waitqueue_head(&mddev->recovery_wait);
+ last_check = 0;
+
+ if (j>2) {
+diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
+index 18a1379..705fe47 100644
+--- a/drivers/md/raid5.c
++++ b/drivers/md/raid5.c
+@@ -1984,6 +1984,7 @@ static int __handle_issuing_new_read_requests5(struct stripe_head *sh,
+ * have quiesced.
+ */
+ if ((s->uptodate == disks - 1) &&
++ (s->failed && disk_idx == s->failed_num) &&
+ !test_bit(STRIPE_OP_CHECK, &sh->ops.pending)) {
+ set_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending);
+ set_bit(R5_Wantcompute, &dev->flags);
+@@ -2069,7 +2070,9 @@ static void handle_issuing_new_read_requests6(struct stripe_head *sh,
+ /* we would like to get this block, possibly
+ * by computing it, but we might not be able to
+ */
+- if (s->uptodate == disks-1) {
++ if ((s->uptodate == disks - 1) &&
++ (s->failed && (i == r6s->failed_num[0] ||
++ i == r6s->failed_num[1]))) {
+ pr_debug("Computing stripe %llu block %d\n",
+ (unsigned long long)sh->sector, i);
+ compute_block_1(sh, i, 0);
+@@ -2618,6 +2621,7 @@ static void handle_stripe5(struct stripe_head *sh)
+ struct stripe_head_state s;
+ struct r5dev *dev;
+ unsigned long pending = 0;
++ int prexor;
+
+ memset(&s, 0, sizeof(s));
+ pr_debug("handling stripe %llu, state=%#lx cnt=%d, pd_idx=%d "
+@@ -2737,9 +2741,11 @@ static void handle_stripe5(struct stripe_head *sh)
+ /* leave prexor set until postxor is done, allows us to distinguish
+ * a rmw from a rcw during biodrain
+ */
++ prexor = 0;
+ if (test_bit(STRIPE_OP_PREXOR, &sh->ops.complete) &&
+ test_bit(STRIPE_OP_POSTXOR, &sh->ops.complete)) {
+
++ prexor = 1;
+ clear_bit(STRIPE_OP_PREXOR, &sh->ops.complete);
+ clear_bit(STRIPE_OP_PREXOR, &sh->ops.ack);
+ clear_bit(STRIPE_OP_PREXOR, &sh->ops.pending);
+@@ -2773,6 +2779,8 @@ static void handle_stripe5(struct stripe_head *sh)
+ if (!test_and_set_bit(
+ STRIPE_OP_IO, &sh->ops.pending))
+ sh->ops.count++;
++ if (prexor)
++ continue;
+ if (!test_bit(R5_Insync, &dev->flags) ||
+ (i == sh->pd_idx && s.failed == 0))
+ set_bit(STRIPE_INSYNC, &sh->state);
+diff --git a/drivers/net/atl1/atl1_main.c b/drivers/net/atl1/atl1_main.c
+index 129b8b3..68be4e1 100644
+--- a/drivers/net/atl1/atl1_main.c
++++ b/drivers/net/atl1/atl1_main.c
+@@ -1334,6 +1334,7 @@ rrd_ok:
+ /* Good Receive */
+ pci_unmap_page(adapter->pdev, buffer_info->dma,
+ buffer_info->length, PCI_DMA_FROMDEVICE);
++ buffer_info->dma = 0;
+ skb = buffer_info->skb;
+ length = le16_to_cpu(rrd->xsz.xsum_sz.pkt_size);
+
+diff --git a/drivers/net/ps3_gelic_wireless.c b/drivers/net/ps3_gelic_wireless.c
+index c16de51..42daf85 100644
+--- a/drivers/net/ps3_gelic_wireless.c
++++ b/drivers/net/ps3_gelic_wireless.c
+@@ -2474,6 +2474,8 @@ static void gelic_wl_free(struct gelic_wl_info *wl)
+
+ pr_debug("%s: <-\n", __func__);
+
++ free_page((unsigned long)wl->buf);
++
+ pr_debug("%s: destroy queues\n", __func__);
+ destroy_workqueue(wl->eurus_cmd_queue);
+ destroy_workqueue(wl->event_queue);
+diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
+index 0147ea3..d8160fa 100644
+--- a/drivers/usb/class/cdc-acm.c
++++ b/drivers/usb/class/cdc-acm.c
+@@ -1242,6 +1242,9 @@ static struct usb_device_id acm_ids[] = {
+ { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
+ .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
+ },
++ { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
++ .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
++ },
+
+ /* control interfaces with various AT-command sets */
+ { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
+diff --git a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c
+index 611bc9f..d05375d 100644
+--- a/drivers/usb/host/ohci-omap.c
++++ b/drivers/usb/host/ohci-omap.c
+@@ -511,7 +511,8 @@ static int ohci_omap_suspend(struct platform_device *dev, pm_message_t message)
+
+ static int ohci_omap_resume(struct platform_device *dev)
+ {
+- struct ohci_hcd *ohci = hcd_to_ohci(platform_get_drvdata(dev));
++ struct usb_hcd *hcd = platform_get_drvdata(dev);
++ struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+
+ if (time_before(jiffies, ohci->next_statechange))
+ msleep(5);
+diff --git a/drivers/usb/host/ohci-sm501.c b/drivers/usb/host/ohci-sm501.c
+index c852f03..dd1a067 100644
+--- a/drivers/usb/host/ohci-sm501.c
++++ b/drivers/usb/host/ohci-sm501.c
+@@ -231,7 +231,8 @@ static int ohci_sm501_suspend(struct platform_device *pdev, pm_message_t msg)
+ static int ohci_sm501_resume(struct platform_device *pdev)
+ {
+ struct device *dev = &pdev->dev;
+- struct ohci_hcd *ohci = hcd_to_ohci(platform_get_drvdata(pdev));
++ struct usb_hcd *hcd = platform_get_drvdata(pdev);
++ struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+
+ if (time_before(jiffies, ohci->next_statechange))
+ msleep(5);
+diff --git a/drivers/usb/misc/ldusb.c b/drivers/usb/misc/ldusb.c
+index c730d20..7eb5f30 100644
+--- a/drivers/usb/misc/ldusb.c
++++ b/drivers/usb/misc/ldusb.c
+@@ -63,9 +63,6 @@
+ #define USB_DEVICE_ID_VERNIER_CYCLOPS 0x0004
+ #define USB_DEVICE_ID_VERNIER_LCSPEC 0x0006
+
+-#define USB_VENDOR_ID_MICROCHIP 0x04d8
+-#define USB_DEVICE_ID_PICDEM 0x000c
+-
+ #ifdef CONFIG_USB_DYNAMIC_MINORS
+ #define USB_LD_MINOR_BASE 0
+ #else
+@@ -92,7 +89,6 @@ static struct usb_device_id ld_usb_table [] = {
+ { USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP) },
+ { USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP) },
+ { USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS) },
+- { USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICDEM) },
+ { USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LCSPEC) },
+ { } /* Terminating entry */
+ };
+diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
+index 3abb3c8..af2bd47 100644
+--- a/drivers/usb/serial/ftdi_sio.c
++++ b/drivers/usb/serial/ftdi_sio.c
+@@ -366,6 +366,7 @@ static struct usb_device_id id_table_combined [] = {
+ .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
+ { USB_DEVICE(FTDI_VID, FTDI_OOCDLINK_PID),
+ .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
++ { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) },
+ { }, /* Optional parameter entry */
+ { } /* Terminating entry */
+ };
+diff --git a/drivers/usb/serial/ftdi_sio.h b/drivers/usb/serial/ftdi_sio.h
+index 6da539e..0e1c569 100644
+--- a/drivers/usb/serial/ftdi_sio.h
++++ b/drivers/usb/serial/ftdi_sio.h
+@@ -581,6 +581,12 @@
+ #define FIC_NEO1973_DEBUG_PID 0x5118
+
+ /*
++ * RATOC REX-USB60F
++ */
++#define RATOC_VENDOR_ID 0x0584
++#define RATOC_PRODUCT_ID_USB60F 0xb020
++
++/*
+ * BmRequestType: 1100 0000b
+ * bRequest: FTDI_E2_READ
+ * wValue: 0
+diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
+index d101025..4d7f357 100644
+--- a/drivers/usb/serial/option.c
++++ b/drivers/usb/serial/option.c
+@@ -154,8 +154,6 @@ static int option_send_setup(struct usb_serial_port *port);
+ #define NOVATELWIRELESS_PRODUCT_MC727 0x4100
+ #define NOVATELWIRELESS_PRODUCT_MC950D 0x4400
+
+-#define NOVATELWIRELESS_PRODUCT_U727 0x5010
+-
+ /* FUTURE NOVATEL PRODUCTS */
+ #define NOVATELWIRELESS_PRODUCT_EVDO_1 0x6000
+ #define NOVATELWIRELESS_PRODUCT_HSPA_1 0x7000
+@@ -195,6 +193,9 @@ static int option_send_setup(struct usb_serial_port *port);
+
+ #define MAXON_VENDOR_ID 0x16d8
+
++#define TELIT_VENDOR_ID 0x1bc7
++#define TELIT_PRODUCT_UC864E 0x1003
++
+ static struct usb_device_id option_ids[] = {
+ { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COLT) },
+ { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA) },
+@@ -269,7 +270,6 @@ static struct usb_device_id option_ids[] = {
+ { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EU870D) }, /* Novatel EU850D/EU860D/EU870D */
+ { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC950D) }, /* Novatel MC930D/MC950D */
+ { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC727) }, /* Novatel MC727/U727/USB727 */
+- { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_U727) }, /* Novatel U727 */
+ { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EVDO_1) }, /* Novatel EVDO product */
+ { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_1) }, /* Novatel HSPA product */
+ { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EMBEDDED_1) }, /* Novatel Embedded product */
+@@ -293,6 +293,7 @@ static struct usb_device_id option_ids[] = {
+ { USB_DEVICE(DELL_VENDOR_ID, 0x8133) }, /* Dell Wireless 5720 == Novatel EV620 CDMA/EV-DO */
+ { USB_DEVICE(DELL_VENDOR_ID, 0x8136) }, /* Dell Wireless HSDPA 5520 == Novatel Expedite EU860D */
+ { USB_DEVICE(DELL_VENDOR_ID, 0x8137) }, /* Dell Wireless HSDPA 5520 */
++ { USB_DEVICE(DELL_VENDOR_ID, 0x8138) }, /* Dell Wireless 5520 Voda I Mobile Broadband (3G HSDPA) Minicard */
+ { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_E100A) },
+ { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_500A) },
+ { USB_DEVICE(AXESSTEL_VENDOR_ID, AXESSTEL_PRODUCT_MV110H) },
+@@ -301,6 +302,8 @@ static struct usb_device_id option_ids[] = {
+ { USB_DEVICE(KYOCERA_VENDOR_ID, KYOCERA_PRODUCT_KPC680) },
+ { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x6613)}, /* Onda H600/ZTE MF330 */
+ { USB_DEVICE(MAXON_VENDOR_ID, 0x6280) }, /* BP3-USB & BP3-EXT HSDPA */
++ { USB_DEVICE(0x19d2, 0x0001) }, /* Telstra NextG CDMA */
++ { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_UC864E) },
+ { } /* Terminating entry */
+ };
+ MODULE_DEVICE_TABLE(usb, option_ids);
+diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
+index 2af7785..4c1a70a 100644
+--- a/drivers/usb/serial/pl2303.c
++++ b/drivers/usb/serial/pl2303.c
+@@ -66,7 +66,6 @@ static struct usb_device_id id_table [] = {
+ { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
+ { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
+ { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
+- { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) },
+ { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
+ { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
+ { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
+diff --git a/drivers/usb/serial/pl2303.h b/drivers/usb/serial/pl2303.h
+index 10cf872..3bdefe0 100644
+--- a/drivers/usb/serial/pl2303.h
++++ b/drivers/usb/serial/pl2303.h
+@@ -36,7 +36,6 @@
+
+ #define RATOC_VENDOR_ID 0x0584
+ #define RATOC_PRODUCT_ID 0xb000
+-#define RATOC_PRODUCT_ID_USB60F 0xb020
+
+ #define TRIPP_VENDOR_ID 0x2478
+ #define TRIPP_PRODUCT_ID 0x2008
+diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
+index 9125207..f1d14c9 100644
+--- a/drivers/usb/storage/unusual_devs.h
++++ b/drivers/usb/storage/unusual_devs.h
+@@ -1285,6 +1285,16 @@ UNUSUAL_DEV( 0x0ace, 0x20ff, 0x0101, 0x0101,
+ US_SC_DEVICE, US_PR_DEVICE, NULL,
+ US_FL_IGNORE_DEVICE ),
+
++/* Reported by F. Aben <f.aben at option.com>
++ * This device (wrongly) has a vendor-specific device descriptor.
++ * The entry is needed so usb-storage can bind to it's mass-storage
++ * interface as an interface driver */
++UNUSUAL_DEV( 0x0af0, 0x7401, 0x0000, 0x0000,
++ "Option",
++ "GI 0401 SD-Card",
++ US_SC_DEVICE, US_PR_DEVICE, NULL,
++ 0 ),
++
+ #ifdef CONFIG_USB_STORAGE_ISD200
+ UNUSUAL_DEV( 0x0bf6, 0xa001, 0x0100, 0x0110,
+ "ATI",
+diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
+index bc673c8..e1031b9 100644
+--- a/fs/cifs/inode.c
++++ b/fs/cifs/inode.c
+@@ -161,12 +161,14 @@ static void cifs_unix_info_to_inode(struct inode *inode,
+ spin_unlock(&inode->i_lock);
+ }
+
+-static const unsigned char *cifs_get_search_path(struct cifsTconInfo *pTcon,
+- const char *search_path)
++static const unsigned char *cifs_get_search_path(struct cifs_sb_info *cifs_sb,
++ const char *search_path)
+ {
+ int tree_len;
+ int path_len;
++ int i;
+ char *tmp_path;
++ struct cifsTconInfo *pTcon = cifs_sb->tcon;
+
+ if (!(pTcon->Flags & SMB_SHARE_IS_IN_DFS))
+ return search_path;
+@@ -180,6 +182,11 @@ static const unsigned char *cifs_get_search_path(struct cifsTconInfo *pTcon,
+ return search_path;
+
+ strncpy(tmp_path, pTcon->treeName, tree_len);
++ if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
++ for (i = 0; i < tree_len; i++) {
++ if (tmp_path[i] == '\\')
++ tmp_path[i] = '/';
++ }
+ strncpy(tmp_path+tree_len, search_path, path_len);
+ tmp_path[tree_len+path_len] = 0;
+ return tmp_path;
+@@ -199,7 +206,7 @@ int cifs_get_inode_info_unix(struct inode **pinode,
+ pTcon = cifs_sb->tcon;
+ cFYI(1, ("Getting info on %s", search_path));
+
+- full_path = cifs_get_search_path(pTcon, search_path);
++ full_path = cifs_get_search_path(cifs_sb, search_path);
+
+ try_again_CIFSSMBUnixQPathInfo:
+ /* could have done a find first instead but this returns more info */
+@@ -402,7 +409,7 @@ int cifs_get_inode_info(struct inode **pinode,
+ return -ENOMEM;
+ pfindData = (FILE_ALL_INFO *)buf;
+
+- full_path = cifs_get_search_path(pTcon, search_path);
++ full_path = cifs_get_search_path(cifs_sb, search_path);
+
+ try_again_CIFSSMBQPathInfo:
+ /* could do find first instead but this returns more info */
+diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
+index 5007f78..7c607af 100644
+--- a/fs/ecryptfs/ecryptfs_kernel.h
++++ b/fs/ecryptfs/ecryptfs_kernel.h
+@@ -626,8 +626,6 @@ int ecryptfs_get_tfm_and_mutex_for_cipher_name(struct crypto_blkcipher **tfm,
+ int ecryptfs_keyring_auth_tok_for_sig(struct key **auth_tok_key,
+ struct ecryptfs_auth_tok **auth_tok,
+ char *sig);
+-int ecryptfs_write_zeros(struct file *file, pgoff_t index, int start,
+- int num_zeros);
+ int ecryptfs_write_lower(struct inode *ecryptfs_inode, char *data,
+ loff_t offset, size_t size);
+ int ecryptfs_write_lower_page_segment(struct inode *ecryptfs_inode,
+diff --git a/fs/ecryptfs/read_write.c b/fs/ecryptfs/read_write.c
+index 0c49286..7cafdbc 100644
+--- a/fs/ecryptfs/read_write.c
++++ b/fs/ecryptfs/read_write.c
+@@ -157,20 +157,6 @@ int ecryptfs_write(struct file *ecryptfs_file, char *data, loff_t offset,
+ ecryptfs_page_idx, rc);
+ goto out;
+ }
+- if (start_offset_in_page) {
+- /* Read in the page from the lower
+- * into the eCryptfs inode page cache,
+- * decrypting */
+- rc = ecryptfs_decrypt_page(ecryptfs_page);
+- if (rc) {
+- printk(KERN_ERR "%s: Error decrypting "
+- "page; rc = [%d]\n",
+- __FUNCTION__, rc);
+- ClearPageUptodate(ecryptfs_page);
+- page_cache_release(ecryptfs_page);
+- goto out;
+- }
+- }
+ ecryptfs_page_virt = kmap_atomic(ecryptfs_page, KM_USER0);
+
+ /*
+@@ -349,14 +335,6 @@ int ecryptfs_read(char *data, loff_t offset, size_t size,
+ ecryptfs_page_idx, rc);
+ goto out;
+ }
+- rc = ecryptfs_decrypt_page(ecryptfs_page);
+- if (rc) {
+- printk(KERN_ERR "%s: Error decrypting "
+- "page; rc = [%d]\n", __FUNCTION__, rc);
+- ClearPageUptodate(ecryptfs_page);
+- page_cache_release(ecryptfs_page);
+- goto out;
+- }
+ ecryptfs_page_virt = kmap_atomic(ecryptfs_page, KM_USER0);
+ memcpy((data + data_offset),
+ ((char *)ecryptfs_page_virt + start_offset_in_page),
+diff --git a/fs/ext3/xattr.c b/fs/ext3/xattr.c
+index 4285654..84119af 100644
+--- a/fs/ext3/xattr.c
++++ b/fs/ext3/xattr.c
+@@ -1000,6 +1000,11 @@ ext3_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
+ i.value = NULL;
+ error = ext3_xattr_block_set(handle, inode, &i, &bs);
+ } else if (error == -ENOSPC) {
++ if (EXT3_I(inode)->i_file_acl && !bs.s.base) {
++ error = ext3_xattr_block_find(inode, &i, &bs);
++ if (error)
++ goto cleanup;
++ }
+ error = ext3_xattr_block_set(handle, inode, &i, &bs);
+ if (error)
+ goto cleanup;
+diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c
+index e9054c1..70d856b 100644
+--- a/fs/ext4/xattr.c
++++ b/fs/ext4/xattr.c
+@@ -1011,6 +1011,11 @@ ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
+ i.value = NULL;
+ error = ext4_xattr_block_set(handle, inode, &i, &bs);
+ } else if (error == -ENOSPC) {
++ if (EXT4_I(inode)->i_file_acl && !bs.s.base) {
++ error = ext4_xattr_block_find(inode, &i, &bs);
++ if (error)
++ goto cleanup;
++ }
+ error = ext4_xattr_block_set(handle, inode, &i, &bs);
+ if (error)
+ goto cleanup;
+diff --git a/fs/proc/array.c b/fs/proc/array.c
+index 07d6c48..6b1c67a 100644
+--- a/fs/proc/array.c
++++ b/fs/proc/array.c
+@@ -287,7 +287,7 @@ static void render_cap_t(struct seq_file *m, const char *header,
+ seq_printf(m, "%s", header);
+ CAP_FOR_EACH_U32(__capi) {
+ seq_printf(m, "%08x",
+- a->cap[(_LINUX_CAPABILITY_U32S-1) - __capi]);
++ a->cap[(_KERNEL_CAPABILITY_U32S-1) - __capi]);
+ }
+ seq_printf(m, "\n");
+ }
+diff --git a/fs/proc/base.c b/fs/proc/base.c
+index 81d7d14..d6f21bd 100644
+--- a/fs/proc/base.c
++++ b/fs/proc/base.c
+@@ -126,6 +126,25 @@ struct pid_entry {
+ NULL, &proc_single_file_operations, \
+ { .proc_show = &proc_##OTYPE } )
+
++/*
++ * Count the number of hardlinks for the pid_entry table, excluding the .
++ * and .. links.
++ */
++static unsigned int pid_entry_count_dirs(const struct pid_entry *entries,
++ unsigned int n)
++{
++ unsigned int i;
++ unsigned int count;
++
++ count = 0;
++ for (i = 0; i < n; ++i) {
++ if (S_ISDIR(entries[i].mode))
++ ++count;
++ }
++
++ return count;
++}
++
+ int maps_protect;
+ EXPORT_SYMBOL(maps_protect);
+
+@@ -2483,10 +2502,9 @@ static struct dentry *proc_pid_instantiate(struct inode *dir,
+ inode->i_op = &proc_tgid_base_inode_operations;
+ inode->i_fop = &proc_tgid_base_operations;
+ inode->i_flags|=S_IMMUTABLE;
+- inode->i_nlink = 5;
+-#ifdef CONFIG_SECURITY
+- inode->i_nlink += 1;
+-#endif
++
++ inode->i_nlink = 2 + pid_entry_count_dirs(tgid_base_stuff,
++ ARRAY_SIZE(tgid_base_stuff));
+
+ dentry->d_op = &pid_dentry_operations;
+
+@@ -2713,10 +2731,9 @@ static struct dentry *proc_task_instantiate(struct inode *dir,
+ inode->i_op = &proc_tid_base_inode_operations;
+ inode->i_fop = &proc_tid_base_operations;
+ inode->i_flags|=S_IMMUTABLE;
+- inode->i_nlink = 4;
+-#ifdef CONFIG_SECURITY
+- inode->i_nlink += 1;
+-#endif
++
++ inode->i_nlink = 2 + pid_entry_count_dirs(tid_base_stuff,
++ ARRAY_SIZE(tid_base_stuff));
+
+ dentry->d_op = &pid_dentry_operations;
+
+diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
+index 9dfb5ff..dca9b46 100644
+--- a/fs/proc/task_mmu.c
++++ b/fs/proc/task_mmu.c
+@@ -524,7 +524,7 @@ const struct file_operations proc_clear_refs_operations = {
+ };
+
+ struct pagemapread {
+- char __user *out, *end;
++ u64 __user *out, *end;
+ };
+
+ #define PM_ENTRY_BYTES sizeof(u64)
+@@ -547,21 +547,11 @@ struct pagemapread {
+ static int add_to_pagemap(unsigned long addr, u64 pfn,
+ struct pagemapread *pm)
+ {
+- /*
+- * Make sure there's room in the buffer for an
+- * entire entry. Otherwise, only copy part of
+- * the pfn.
+- */
+- if (pm->out + PM_ENTRY_BYTES >= pm->end) {
+- if (copy_to_user(pm->out, &pfn, pm->end - pm->out))
+- return -EFAULT;
+- pm->out = pm->end;
+- return PM_END_OF_BUFFER;
+- }
+-
+ if (put_user(pfn, pm->out))
+ return -EFAULT;
+- pm->out += PM_ENTRY_BYTES;
++ pm->out++;
++ if (pm->out >= pm->end)
++ return PM_END_OF_BUFFER;
+ return 0;
+ }
+
+@@ -662,7 +652,7 @@ static ssize_t pagemap_read(struct file *file, char __user *buf,
+
+ ret = -EINVAL;
+ /* file position must be aligned */
+- if (*ppos % PM_ENTRY_BYTES)
++ if ((*ppos % PM_ENTRY_BYTES) || (count % PM_ENTRY_BYTES))
+ goto out_task;
+
+ ret = 0;
+@@ -692,8 +682,8 @@ static ssize_t pagemap_read(struct file *file, char __user *buf,
+ goto out_pages;
+ }
+
+- pm.out = buf;
+- pm.end = buf + count;
++ pm.out = (u64 *)buf;
++ pm.end = (u64 *)(buf + count);
+
+ if (!ptrace_may_attach(task)) {
+ ret = -EIO;
+@@ -718,9 +708,9 @@ static ssize_t pagemap_read(struct file *file, char __user *buf,
+ if (ret == PM_END_OF_BUFFER)
+ ret = 0;
+ /* don't need mmap_sem for these, but this looks cleaner */
+- *ppos += pm.out - buf;
++ *ppos += (char *)pm.out - buf;
+ if (!ret)
+- ret = pm.out - buf;
++ ret = (char *)pm.out - buf;
+ }
+
+ out_pages:
+diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
+index e347bfd..9831c90 100644
+--- a/fs/xfs/linux-2.6/xfs_buf.c
++++ b/fs/xfs/linux-2.6/xfs_buf.c
+@@ -387,6 +387,8 @@ _xfs_buf_lookup_pages(
+ if (unlikely(page == NULL)) {
+ if (flags & XBF_READ_AHEAD) {
+ bp->b_page_count = i;
++ for (i = 0; i < bp->b_page_count; i++)
++ unlock_page(bp->b_pages[i]);
+ return -ENOMEM;
+ }
+
+@@ -416,17 +418,24 @@ _xfs_buf_lookup_pages(
+ ASSERT(!PagePrivate(page));
+ if (!PageUptodate(page)) {
+ page_count--;
+- if (blocksize < PAGE_CACHE_SIZE && !PagePrivate(page)) {
++ if (blocksize >= PAGE_CACHE_SIZE) {
++ if (flags & XBF_READ)
++ bp->b_flags |= _XBF_PAGE_LOCKED;
++ } else if (!PagePrivate(page)) {
+ if (test_page_region(page, offset, nbytes))
+ page_count++;
+ }
+ }
+
+- unlock_page(page);
+ bp->b_pages[i] = page;
+ offset = 0;
+ }
+
++ if (!(bp->b_flags & _XBF_PAGE_LOCKED)) {
++ for (i = 0; i < bp->b_page_count; i++)
++ unlock_page(bp->b_pages[i]);
++ }
++
+ if (page_count == bp->b_page_count)
+ bp->b_flags |= XBF_DONE;
+
+@@ -746,6 +755,7 @@ xfs_buf_associate_memory(
+ bp->b_count_desired = len;
+ bp->b_buffer_length = buflen;
+ bp->b_flags |= XBF_MAPPED;
++ bp->b_flags &= ~_XBF_PAGE_LOCKED;
+
+ return 0;
+ }
+@@ -1093,8 +1103,10 @@ _xfs_buf_ioend(
+ xfs_buf_t *bp,
+ int schedule)
+ {
+- if (atomic_dec_and_test(&bp->b_io_remaining) == 1)
++ if (atomic_dec_and_test(&bp->b_io_remaining) == 1) {
++ bp->b_flags &= ~_XBF_PAGE_LOCKED;
+ xfs_buf_ioend(bp, schedule);
++ }
+ }
+
+ STATIC void
+@@ -1125,6 +1137,9 @@ xfs_buf_bio_end_io(
+
+ if (--bvec >= bio->bi_io_vec)
+ prefetchw(&bvec->bv_page->flags);
++
++ if (bp->b_flags & _XBF_PAGE_LOCKED)
++ unlock_page(page);
+ } while (bvec >= bio->bi_io_vec);
+
+ _xfs_buf_ioend(bp, 1);
+@@ -1163,7 +1178,8 @@ _xfs_buf_ioapply(
+ * filesystem block size is not smaller than the page size.
+ */
+ if ((bp->b_buffer_length < PAGE_CACHE_SIZE) &&
+- (bp->b_flags & XBF_READ) &&
++ ((bp->b_flags & (XBF_READ|_XBF_PAGE_LOCKED)) ==
++ (XBF_READ|_XBF_PAGE_LOCKED)) &&
+ (blocksize >= PAGE_CACHE_SIZE)) {
+ bio = bio_alloc(GFP_NOIO, 1);
+
+diff --git a/fs/xfs/linux-2.6/xfs_buf.h b/fs/xfs/linux-2.6/xfs_buf.h
+index a3d207d..441f7c3 100644
+--- a/fs/xfs/linux-2.6/xfs_buf.h
++++ b/fs/xfs/linux-2.6/xfs_buf.h
+@@ -66,6 +66,25 @@ typedef enum {
+ _XBF_PAGES = (1 << 18), /* backed by refcounted pages */
+ _XBF_RUN_QUEUES = (1 << 19),/* run block device task queue */
+ _XBF_DELWRI_Q = (1 << 21), /* buffer on delwri queue */
++
++ /*
++ * Special flag for supporting metadata blocks smaller than a FSB.
++ *
++ * In this case we can have multiple xfs_buf_t on a single page and
++ * need to lock out concurrent xfs_buf_t readers as they only
++ * serialise access to the buffer.
++ *
++ * If the FSB size >= PAGE_CACHE_SIZE case, we have no serialisation
++ * between reads of the page. Hence we can have one thread read the
++ * page and modify it, but then race with another thread that thinks
++ * the page is not up-to-date and hence reads it again.
++ *
++ * The result is that the first modifcation to the page is lost.
++ * This sort of AGF/AGI reading race can happen when unlinking inodes
++ * that require truncation and results in the AGI unlinked list
++ * modifications being lost.
++ */
++ _XBF_PAGE_LOCKED = (1 << 22),
+ } xfs_buf_flags_t;
+
+ typedef enum {
+diff --git a/include/asm-x86/tlbflush.h b/include/asm-x86/tlbflush.h
+index 3998709..b7a6a08 100644
+--- a/include/asm-x86/tlbflush.h
++++ b/include/asm-x86/tlbflush.h
+@@ -22,12 +22,23 @@ static inline void __native_flush_tlb(void)
+
+ static inline void __native_flush_tlb_global(void)
+ {
+- unsigned long cr4 = read_cr4();
++ unsigned long flags;
++ unsigned long cr4;
+
++ /*
++ * Read-modify-write to CR4 - protect it from preemption and
++ * from interrupts. (Use the raw variant because this code can
++ * be called from deep inside debugging code.)
++ */
++ raw_local_irq_save(flags);
++
++ cr4 = read_cr4();
+ /* clear PGE */
+ write_cr4(cr4 & ~X86_CR4_PGE);
+ /* write old PGE again and flush TLBs */
+ write_cr4(cr4);
++
++ raw_local_irq_restore(flags);
+ }
+
+ static inline void __native_flush_tlb_single(unsigned long addr)
+diff --git a/include/linux/capability.h b/include/linux/capability.h
+index 7d50ff6..bb8d915 100644
+--- a/include/linux/capability.h
++++ b/include/linux/capability.h
+@@ -31,11 +31,11 @@ struct task_struct;
+ #define _LINUX_CAPABILITY_VERSION_1 0x19980330
+ #define _LINUX_CAPABILITY_U32S_1 1
+
+-#define _LINUX_CAPABILITY_VERSION_2 0x20071026
++#define _LINUX_CAPABILITY_VERSION_2 0x20071026 /* deprecated - use v3 */
+ #define _LINUX_CAPABILITY_U32S_2 2
+
+-#define _LINUX_CAPABILITY_VERSION _LINUX_CAPABILITY_VERSION_2
+-#define _LINUX_CAPABILITY_U32S _LINUX_CAPABILITY_U32S_2
++#define _LINUX_CAPABILITY_VERSION_3 0x20080522
++#define _LINUX_CAPABILITY_U32S_3 2
+
+ typedef struct __user_cap_header_struct {
+ __u32 version;
+@@ -77,10 +77,23 @@ struct vfs_cap_data {
+ } data[VFS_CAP_U32];
+ };
+
+-#ifdef __KERNEL__
++#ifndef __KERNEL__
++
++/*
++ * Backwardly compatible definition for source code - trapped in a
++ * 32-bit world. If you find you need this, please consider using
++ * libcap to untrap yourself...
++ */
++#define _LINUX_CAPABILITY_VERSION _LINUX_CAPABILITY_VERSION_1
++#define _LINUX_CAPABILITY_U32S _LINUX_CAPABILITY_U32S_1
++
++#else
++
++#define _KERNEL_CAPABILITY_VERSION _LINUX_CAPABILITY_VERSION_3
++#define _KERNEL_CAPABILITY_U32S _LINUX_CAPABILITY_U32S_3
+
+ typedef struct kernel_cap_struct {
+- __u32 cap[_LINUX_CAPABILITY_U32S];
++ __u32 cap[_KERNEL_CAPABILITY_U32S];
+ } kernel_cap_t;
+
+ #define _USER_CAP_HEADER_SIZE (sizeof(struct __user_cap_header_struct))
+@@ -350,7 +363,7 @@ typedef struct kernel_cap_struct {
+ */
+
+ #define CAP_FOR_EACH_U32(__capi) \
+- for (__capi = 0; __capi < _LINUX_CAPABILITY_U32S; ++__capi)
++ for (__capi = 0; __capi < _KERNEL_CAPABILITY_U32S; ++__capi)
+
+ # define CAP_FS_MASK_B0 (CAP_TO_MASK(CAP_CHOWN) \
+ | CAP_TO_MASK(CAP_DAC_OVERRIDE) \
+@@ -360,7 +373,7 @@ typedef struct kernel_cap_struct {
+
+ # define CAP_FS_MASK_B1 (CAP_TO_MASK(CAP_MAC_OVERRIDE))
+
+-#if _LINUX_CAPABILITY_U32S != 2
++#if _KERNEL_CAPABILITY_U32S != 2
+ # error Fix up hand-coded capability macro initializers
+ #else /* HAND-CODED capability initializers */
+
+@@ -371,7 +384,7 @@ typedef struct kernel_cap_struct {
+ # define CAP_NFSD_SET {{ CAP_FS_MASK_B0|CAP_TO_MASK(CAP_SYS_RESOURCE), \
+ CAP_FS_MASK_B1 } }
+
+-#endif /* _LINUX_CAPABILITY_U32S != 2 */
++#endif /* _KERNEL_CAPABILITY_U32S != 2 */
+
+ #define CAP_INIT_INH_SET CAP_EMPTY_SET
+
+diff --git a/include/linux/hid.h b/include/linux/hid.h
+index 74ff575..02e70b7 100644
+--- a/include/linux/hid.h
++++ b/include/linux/hid.h
+@@ -284,6 +284,7 @@ struct hid_item {
+ #define HID_QUIRK_2WHEEL_MOUSE_HACK_B8 0x02000000
+ #define HID_QUIRK_HWHEEL_WHEEL_INVERT 0x04000000
+ #define HID_QUIRK_MICROSOFT_KEYS 0x08000000
++#define HID_QUIRK_APPLE_NUMLOCK_EMULATION 0x10000000
+
+ /*
+ * Separate quirks for runtime report descriptor fixup
+diff --git a/include/linux/types.h b/include/linux/types.h
+index 9dc2346..d4a9ce6 100644
+--- a/include/linux/types.h
++++ b/include/linux/types.h
+@@ -197,8 +197,6 @@ typedef u64 resource_size_t;
+ typedef u32 resource_size_t;
+ #endif
+
+-#endif /* __KERNEL__ */
+-
+ struct ustat {
+ __kernel_daddr_t f_tfree;
+ __kernel_ino_t f_tinode;
+@@ -206,4 +204,6 @@ struct ustat {
+ char f_fpack[6];
+ };
+
++#endif /* __KERNEL__ */
++
+ #endif /* _LINUX_TYPES_H */
+diff --git a/kernel/capability.c b/kernel/capability.c
+index 39e8193..cfbe442 100644
+--- a/kernel/capability.c
++++ b/kernel/capability.c
+@@ -53,6 +53,69 @@ static void warn_legacy_capability_use(void)
+ }
+
+ /*
++ * Version 2 capabilities worked fine, but the linux/capability.h file
++ * that accompanied their introduction encouraged their use without
++ * the necessary user-space source code changes. As such, we have
++ * created a version 3 with equivalent functionality to version 2, but
++ * with a header change to protect legacy source code from using
++ * version 2 when it wanted to use version 1. If your system has code
++ * that trips the following warning, it is using version 2 specific
++ * capabilities and may be doing so insecurely.
++ *
++ * The remedy is to either upgrade your version of libcap (to 2.10+,
++ * if the application is linked against it), or recompile your
++ * application with modern kernel headers and this warning will go
++ * away.
++ */
++
++static void warn_deprecated_v2(void)
++{
++ static int warned;
++
++ if (!warned) {
++ char name[sizeof(current->comm)];
++
++ printk(KERN_INFO "warning: `%s' uses deprecated v2"
++ " capabilities in a way that may be insecure.\n",
++ get_task_comm(name, current));
++ warned = 1;
++ }
++}
++
++/*
++ * Version check. Return the number of u32s in each capability flag
++ * array, or a negative value on error.
++ */
++static int cap_validate_magic(cap_user_header_t header, unsigned *tocopy)
++{
++ __u32 version;
++
++ if (get_user(version, &header->version))
++ return -EFAULT;
++
++ switch (version) {
++ case _LINUX_CAPABILITY_VERSION_1:
++ warn_legacy_capability_use();
++ *tocopy = _LINUX_CAPABILITY_U32S_1;
++ break;
++ case _LINUX_CAPABILITY_VERSION_2:
++ warn_deprecated_v2();
++ /*
++ * fall through - v3 is otherwise equivalent to v2.
++ */
++ case _LINUX_CAPABILITY_VERSION_3:
++ *tocopy = _LINUX_CAPABILITY_U32S_3;
++ break;
++ default:
++ if (put_user((u32)_KERNEL_CAPABILITY_VERSION, &header->version))
++ return -EFAULT;
++ return -EINVAL;
++ }
++
++ return 0;
++}
++
++/*
+ * For sys_getproccap() and sys_setproccap(), any of the three
+ * capability set pointers may be NULL -- indicating that that set is
+ * uninteresting and/or not to be changed.
+@@ -71,27 +134,13 @@ asmlinkage long sys_capget(cap_user_header_t header, cap_user_data_t dataptr)
+ {
+ int ret = 0;
+ pid_t pid;
+- __u32 version;
+ struct task_struct *target;
+ unsigned tocopy;
+ kernel_cap_t pE, pI, pP;
+
+- if (get_user(version, &header->version))
+- return -EFAULT;
+-
+- switch (version) {
+- case _LINUX_CAPABILITY_VERSION_1:
+- warn_legacy_capability_use();
+- tocopy = _LINUX_CAPABILITY_U32S_1;
+- break;
+- case _LINUX_CAPABILITY_VERSION_2:
+- tocopy = _LINUX_CAPABILITY_U32S_2;
+- break;
+- default:
+- if (put_user(_LINUX_CAPABILITY_VERSION, &header->version))
+- return -EFAULT;
+- return -EINVAL;
+- }
++ ret = cap_validate_magic(header, &tocopy);
++ if (ret != 0)
++ return ret;
+
+ if (get_user(pid, &header->pid))
+ return -EFAULT;
+@@ -118,7 +167,7 @@ out:
+ spin_unlock(&task_capability_lock);
+
+ if (!ret) {
+- struct __user_cap_data_struct kdata[_LINUX_CAPABILITY_U32S];
++ struct __user_cap_data_struct kdata[_KERNEL_CAPABILITY_U32S];
+ unsigned i;
+
+ for (i = 0; i < tocopy; i++) {
+@@ -128,7 +177,7 @@ out:
+ }
+
+ /*
+- * Note, in the case, tocopy < _LINUX_CAPABILITY_U32S,
++ * Note, in the case, tocopy < _KERNEL_CAPABILITY_U32S,
+ * we silently drop the upper capabilities here. This
+ * has the effect of making older libcap
+ * implementations implicitly drop upper capability
+@@ -240,30 +289,16 @@ static inline int cap_set_all(kernel_cap_t *effective,
+ */
+ asmlinkage long sys_capset(cap_user_header_t header, const cap_user_data_t data)
+ {
+- struct __user_cap_data_struct kdata[_LINUX_CAPABILITY_U32S];
++ struct __user_cap_data_struct kdata[_KERNEL_CAPABILITY_U32S];
+ unsigned i, tocopy;
+ kernel_cap_t inheritable, permitted, effective;
+- __u32 version;
+ struct task_struct *target;
+ int ret;
+ pid_t pid;
+
+- if (get_user(version, &header->version))
+- return -EFAULT;
+-
+- switch (version) {
+- case _LINUX_CAPABILITY_VERSION_1:
+- warn_legacy_capability_use();
+- tocopy = _LINUX_CAPABILITY_U32S_1;
+- break;
+- case _LINUX_CAPABILITY_VERSION_2:
+- tocopy = _LINUX_CAPABILITY_U32S_2;
+- break;
+- default:
+- if (put_user(_LINUX_CAPABILITY_VERSION, &header->version))
+- return -EFAULT;
+- return -EINVAL;
+- }
++ ret = cap_validate_magic(header, &tocopy);
++ if (ret != 0)
++ return ret;
+
+ if (get_user(pid, &header->pid))
+ return -EFAULT;
+@@ -281,7 +316,7 @@ asmlinkage long sys_capset(cap_user_header_t header, const cap_user_data_t data)
+ permitted.cap[i] = kdata[i].permitted;
+ inheritable.cap[i] = kdata[i].inheritable;
+ }
+- while (i < _LINUX_CAPABILITY_U32S) {
++ while (i < _KERNEL_CAPABILITY_U32S) {
+ effective.cap[i] = 0;
+ permitted.cap[i] = 0;
+ inheritable.cap[i] = 0;
+diff --git a/kernel/cgroup.c b/kernel/cgroup.c
+index 6d8de05..4484139 100644
+--- a/kernel/cgroup.c
++++ b/kernel/cgroup.c
+@@ -2808,7 +2808,7 @@ int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys)
+ cg = tsk->cgroups;
+ parent = task_cgroup(tsk, subsys->subsys_id);
+
+- snprintf(nodename, MAX_CGROUP_TYPE_NAMELEN, "node_%d", tsk->pid);
++ snprintf(nodename, MAX_CGROUP_TYPE_NAMELEN, "%d", tsk->pid);
+
+ /* Pin the hierarchy */
+ atomic_inc(&parent->root->sb->s_active);
+diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
+index 7469c50..4d1e8c7 100644
+--- a/mm/memory_hotplug.c
++++ b/mm/memory_hotplug.c
+@@ -58,23 +58,59 @@ static void release_memory_resource(struct resource *res)
+ return;
+ }
+
+-
+ #ifdef CONFIG_MEMORY_HOTPLUG_SPARSE
++static void grow_zone_span(struct zone *zone, unsigned long start_pfn,
++ unsigned long end_pfn)
++{
++ unsigned long old_zone_end_pfn;
++
++ zone_span_writelock(zone);
++
++ old_zone_end_pfn = zone->zone_start_pfn + zone->spanned_pages;
++ if (start_pfn < zone->zone_start_pfn)
++ zone->zone_start_pfn = start_pfn;
++
++ zone->spanned_pages = max(old_zone_end_pfn, end_pfn) -
++ zone->zone_start_pfn;
++
++ zone_span_writeunlock(zone);
++}
++
++static void grow_pgdat_span(struct pglist_data *pgdat, unsigned long start_pfn,
++ unsigned long end_pfn)
++{
++ unsigned long old_pgdat_end_pfn =
++ pgdat->node_start_pfn + pgdat->node_spanned_pages;
++
++ if (start_pfn < pgdat->node_start_pfn)
++ pgdat->node_start_pfn = start_pfn;
++
++ pgdat->node_spanned_pages = max(old_pgdat_end_pfn, end_pfn) -
++ pgdat->node_start_pfn;
++}
++
+ static int __add_zone(struct zone *zone, unsigned long phys_start_pfn)
+ {
+ struct pglist_data *pgdat = zone->zone_pgdat;
+ int nr_pages = PAGES_PER_SECTION;
+ int nid = pgdat->node_id;
+ int zone_type;
++ unsigned long flags;
+
+ zone_type = zone - pgdat->node_zones;
+ if (!zone->wait_table) {
+- int ret = 0;
++ int ret;
++
+ ret = init_currently_empty_zone(zone, phys_start_pfn,
+ nr_pages, MEMMAP_HOTPLUG);
+- if (ret < 0)
++ if (ret)
+ return ret;
+ }
++ pgdat_resize_lock(zone->zone_pgdat, &flags);
++ grow_zone_span(zone, phys_start_pfn, phys_start_pfn + nr_pages);
++ grow_pgdat_span(zone->zone_pgdat, phys_start_pfn,
++ phys_start_pfn + nr_pages);
++ pgdat_resize_unlock(zone->zone_pgdat, &flags);
+ memmap_init_zone(nr_pages, nid, zone_type,
+ phys_start_pfn, MEMMAP_HOTPLUG);
+ return 0;
+@@ -134,36 +170,6 @@ int __add_pages(struct zone *zone, unsigned long phys_start_pfn,
+ }
+ EXPORT_SYMBOL_GPL(__add_pages);
+
+-static void grow_zone_span(struct zone *zone,
+- unsigned long start_pfn, unsigned long end_pfn)
+-{
+- unsigned long old_zone_end_pfn;
+-
+- zone_span_writelock(zone);
+-
+- old_zone_end_pfn = zone->zone_start_pfn + zone->spanned_pages;
+- if (start_pfn < zone->zone_start_pfn)
+- zone->zone_start_pfn = start_pfn;
+-
+- zone->spanned_pages = max(old_zone_end_pfn, end_pfn) -
+- zone->zone_start_pfn;
+-
+- zone_span_writeunlock(zone);
+-}
+-
+-static void grow_pgdat_span(struct pglist_data *pgdat,
+- unsigned long start_pfn, unsigned long end_pfn)
+-{
+- unsigned long old_pgdat_end_pfn =
+- pgdat->node_start_pfn + pgdat->node_spanned_pages;
+-
+- if (start_pfn < pgdat->node_start_pfn)
+- pgdat->node_start_pfn = start_pfn;
+-
+- pgdat->node_spanned_pages = max(old_pgdat_end_pfn, end_pfn) -
+- pgdat->node_start_pfn;
+-}
+-
+ static int online_pages_range(unsigned long start_pfn, unsigned long nr_pages,
+ void *arg)
+ {
+@@ -183,7 +189,6 @@ static int online_pages_range(unsigned long start_pfn, unsigned long nr_pages,
+
+ int online_pages(unsigned long pfn, unsigned long nr_pages)
+ {
+- unsigned long flags;
+ unsigned long onlined_pages = 0;
+ struct zone *zone;
+ int need_zonelists_rebuild = 0;
+@@ -211,11 +216,6 @@ int online_pages(unsigned long pfn, unsigned long nr_pages)
+ * memory_block->state_sem.
+ */
+ zone = page_zone(pfn_to_page(pfn));
+- pgdat_resize_lock(zone->zone_pgdat, &flags);
+- grow_zone_span(zone, pfn, pfn + nr_pages);
+- grow_pgdat_span(zone->zone_pgdat, pfn, pfn + nr_pages);
+- pgdat_resize_unlock(zone->zone_pgdat, &flags);
+-
+ /*
+ * If this zone is not populated, then it is not in zonelist.
+ * This means the page allocator ignores this zone.
+diff --git a/mm/mmap.c b/mm/mmap.c
+index a32d28c..96bdd73 100644
+--- a/mm/mmap.c
++++ b/mm/mmap.c
+@@ -242,10 +242,16 @@ asmlinkage unsigned long sys_brk(unsigned long brk)
+ unsigned long rlim, retval;
+ unsigned long newbrk, oldbrk;
+ struct mm_struct *mm = current->mm;
++ unsigned long min_brk;
+
+ down_write(&mm->mmap_sem);
+
+- if (brk < mm->start_brk)
++#ifdef CONFIG_COMPAT_BRK
++ min_brk = mm->end_code;
++#else
++ min_brk = mm->start_brk;
++#endif
++ if (brk < min_brk)
+ goto out;
+
+ /*
+diff --git a/mm/page_alloc.c b/mm/page_alloc.c
+index 55443c2..f7082af 100644
+--- a/mm/page_alloc.c
++++ b/mm/page_alloc.c
+@@ -2837,8 +2837,6 @@ __meminit int init_currently_empty_zone(struct zone *zone,
+
+ zone->zone_start_pfn = zone_start_pfn;
+
+- memmap_init(size, pgdat->node_id, zone_idx(zone), zone_start_pfn);
+-
+ zone_init_free_lists(zone);
+
+ return 0;
+@@ -3408,6 +3406,7 @@ static void __paginginit free_area_init_core(struct pglist_data *pgdat,
+ ret = init_currently_empty_zone(zone, zone_start_pfn,
+ size, MEMMAP_EARLY);
+ BUG_ON(ret);
++ memmap_init(size, nid, j, zone_start_pfn);
+ zone_start_pfn += size;
+ }
+ }
+diff --git a/net/ipv6/netfilter/nf_conntrack_reasm.c b/net/ipv6/netfilter/nf_conntrack_reasm.c
+index 24c0d03..b8a917b 100644
+--- a/net/ipv6/netfilter/nf_conntrack_reasm.c
++++ b/net/ipv6/netfilter/nf_conntrack_reasm.c
+@@ -209,7 +209,9 @@ fq_find(__be32 id, struct in6_addr *src, struct in6_addr *dst)
+ arg.dst = dst;
+ hash = ip6qhashfn(id, src, dst);
+
++ local_bh_disable();
+ q = inet_frag_find(&nf_init_frags, &nf_frags, &arg, hash);
++ local_bh_enable();
+ if (q == NULL)
+ goto oom;
+
+@@ -638,10 +640,10 @@ struct sk_buff *nf_ct_frag6_gather(struct sk_buff *skb)
+ goto ret_orig;
+ }
+
+- spin_lock(&fq->q.lock);
++ spin_lock_bh(&fq->q.lock);
+
+ if (nf_ct_frag6_queue(fq, clone, fhdr, nhoff) < 0) {
+- spin_unlock(&fq->q.lock);
++ spin_unlock_bh(&fq->q.lock);
+ pr_debug("Can't insert skb to queue\n");
+ fq_put(fq);
+ goto ret_orig;
+@@ -652,7 +654,7 @@ struct sk_buff *nf_ct_frag6_gather(struct sk_buff *skb)
+ if (ret_skb == NULL)
+ pr_debug("Can't reassemble fragmented packets\n");
+ }
+- spin_unlock(&fq->q.lock);
++ spin_unlock_bh(&fq->q.lock);
+
+ fq_put(fq);
+ return ret_skb;
+diff --git a/net/netfilter/nf_conntrack_expect.c b/net/netfilter/nf_conntrack_expect.c
+index 684ec9c..d15d70f 100644
+--- a/net/netfilter/nf_conntrack_expect.c
++++ b/net/netfilter/nf_conntrack_expect.c
+@@ -550,10 +550,10 @@ int __init nf_conntrack_expect_init(void)
+ return 0;
+
+ err3:
++ kmem_cache_destroy(nf_ct_expect_cachep);
++err2:
+ nf_ct_free_hashtable(nf_ct_expect_hash, nf_ct_expect_vmalloc,
+ nf_ct_expect_hsize);
+-err2:
+- kmem_cache_destroy(nf_ct_expect_cachep);
+ err1:
+ return err;
+ }
+diff --git a/net/netfilter/xt_connlimit.c b/net/netfilter/xt_connlimit.c
+index 3b01119..1692338 100644
+--- a/net/netfilter/xt_connlimit.c
++++ b/net/netfilter/xt_connlimit.c
+@@ -75,7 +75,8 @@ static inline bool already_closed(const struct nf_conn *conn)
+ u_int16_t proto = conn->tuplehash[0].tuple.dst.protonum;
+
+ if (proto == IPPROTO_TCP)
+- return conn->proto.tcp.state == TCP_CONNTRACK_TIME_WAIT;
++ return conn->proto.tcp.state == TCP_CONNTRACK_TIME_WAIT ||
++ conn->proto.tcp.state == TCP_CONNTRACK_CLOSE;
+ else
+ return 0;
+ }
+diff --git a/net/netfilter/xt_iprange.c b/net/netfilter/xt_iprange.c
+index 500528d..c63e933 100644
+--- a/net/netfilter/xt_iprange.c
++++ b/net/netfilter/xt_iprange.c
+@@ -179,3 +179,5 @@ module_exit(iprange_mt_exit);
+ MODULE_LICENSE("GPL");
+ MODULE_AUTHOR("Jozsef Kadlecsik <kadlec at blackhole.kfki.hu>, Jan Engelhardt <jengelh at computergmbh.de>");
+ MODULE_DESCRIPTION("Xtables: arbitrary IPv4 range matching");
++MODULE_ALIAS("ipt_iprange");
++MODULE_ALIAS("ip6t_iprange");
+diff --git a/security/smack/smack_lsm.c b/security/smack/smack_lsm.c
+index 732ba27..62d77ff 100644
+--- a/security/smack/smack_lsm.c
++++ b/security/smack/smack_lsm.c
+@@ -1865,6 +1865,18 @@ static void smack_d_instantiate(struct dentry *opt_dentry, struct inode *inode)
+ final = sbsp->smk_default;
+
+ /*
++ * If this is the root inode the superblock
++ * may be in the process of initialization.
++ * If that is the case use the root value out
++ * of the superblock.
++ */
++ if (opt_dentry->d_parent == opt_dentry) {
++ isp->smk_inode = sbsp->smk_root;
++ isp->smk_flags |= SMK_INODE_INSTANT;
++ goto unlockandout;
++ }
++
++ /*
+ * This is pretty hackish.
+ * Casey says that we shouldn't have to do
+ * file system specific code, but it does help
Modified: dists/sid/linux-2.6/debian/patches/series/5
==============================================================================
--- dists/sid/linux-2.6/debian/patches/series/5 (original)
+++ dists/sid/linux-2.6/debian/patches/series/5 Mon Jun 9 23:16:05 2008
@@ -1 +1,3 @@
+ bugfix/all/stable/2.6.25.5.patch
+- bugfix/all/0001-types.h-don-t-expose-struct-ustat-to-userspace.patch
++ bugfix/all/stable/2.6.25.6.patch
More information about the Kernel-svn-changes
mailing list