lkml.org 
[lkml]   [2007]   [Aug]   [25]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    SubjectRe: Linux 2.6.20.17
    diff --git a/Makefile b/Makefile
    index b3806cb..bce2fbf 100644
    --- a/Makefile
    +++ b/Makefile
    @@ -1,7 +1,7 @@
    VERSION = 2
    PATCHLEVEL = 6
    SUBLEVEL = 20
    -EXTRAVERSION = .16
    +EXTRAVERSION = .17
    NAME = Homicidal Dwarf Hamster

    # *DOCUMENTATION*
    diff --git a/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c b/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
    index 10baa35..18c8b67 100644
    --- a/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
    +++ b/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
    @@ -167,11 +167,13 @@ static void do_drv_read(struct drv_cmd *cmd)

    static void do_drv_write(struct drv_cmd *cmd)
    {
    - u32 h = 0;
    + u32 lo, hi;

    switch (cmd->type) {
    case SYSTEM_INTEL_MSR_CAPABLE:
    - wrmsr(cmd->addr.msr.reg, cmd->val, h);
    + rdmsr(cmd->addr.msr.reg, lo, hi);
    + lo = (lo & ~INTEL_MSR_RANGE) | (cmd->val & INTEL_MSR_RANGE);
    + wrmsr(cmd->addr.msr.reg, lo, hi);
    break;
    case SYSTEM_IO_CAPABLE:
    acpi_os_write_port((acpi_io_address)cmd->addr.io.port,
    @@ -372,7 +374,6 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
    struct cpufreq_freqs freqs;
    cpumask_t online_policy_cpus;
    struct drv_cmd cmd;
    - unsigned int msr;
    unsigned int next_state = 0; /* Index into freq_table */
    unsigned int next_perf_state = 0; /* Index into perf table */
    unsigned int i;
    @@ -417,11 +418,7 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
    case SYSTEM_INTEL_MSR_CAPABLE:
    cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
    cmd.addr.msr.reg = MSR_IA32_PERF_CTL;
    - msr =
    - (u32) perf->states[next_perf_state].
    - control & INTEL_MSR_RANGE;
    - cmd.val = get_cur_val(online_policy_cpus);
    - cmd.val = (cmd.val & ~INTEL_MSR_RANGE) | msr;
    + cmd.val = (u32) perf->states[next_perf_state].control;
    break;
    case SYSTEM_IO_CAPABLE:
    cmd.type = SYSTEM_IO_CAPABLE;
    diff --git a/arch/sparc/kernel/entry.S b/arch/sparc/kernel/entry.S
    index 831f540..eac3838 100644
    --- a/arch/sparc/kernel/entry.S
    +++ b/arch/sparc/kernel/entry.S
    @@ -1749,8 +1749,8 @@ fpload:
    __ndelay:
    save %sp, -STACKFRAME_SZ, %sp
    mov %i0, %o0
    - call .umul
    - mov 0x1ad, %o1 ! 2**32 / (1 000 000 000 / HZ)
    + call .umul ! round multiplier up so large ns ok
    + mov 0x1ae, %o1 ! 2**32 / (1 000 000 000 / HZ)
    call .umul
    mov %i1, %o1 ! udelay_val
    ba delay_continue
    @@ -1760,11 +1760,17 @@ __ndelay:
    __udelay:
    save %sp, -STACKFRAME_SZ, %sp
    mov %i0, %o0
    - sethi %hi(0x10c6), %o1
    + sethi %hi(0x10c7), %o1 ! round multiplier up so large us ok
    call .umul
    - or %o1, %lo(0x10c6), %o1 ! 2**32 / 1 000 000
    + or %o1, %lo(0x10c7), %o1 ! 2**32 / 1 000 000
    call .umul
    mov %i1, %o1 ! udelay_val
    + sethi %hi(0x028f4b62), %l0 ! Add in rounding constant * 2**32,
    + or %g0, %lo(0x028f4b62), %l0
    + addcc %o0, %l0, %o0 ! 2**32 * 0.009 999
    + bcs,a 3f
    + add %o1, 0x01, %o1
    +3:
    call .umul
    mov HZ, %o0 ! >>32 earlier for wider range

    diff --git a/arch/sparc/lib/memset.S b/arch/sparc/lib/memset.S
    index a65eba4..1c37ea8 100644
    --- a/arch/sparc/lib/memset.S
    +++ b/arch/sparc/lib/memset.S
    @@ -162,7 +162,7 @@ __bzero:
    8:
    add %o0, 1, %o0
    subcc %o1, 1, %o1
    - bne,a 8b
    + bne 8b
    EX(stb %g3, [%o0 - 1], add %o1, 1)
    0:
    retl
    diff --git a/arch/sparc64/kernel/head.S b/arch/sparc64/kernel/head.S
    index 06459ae..0e19369 100644
    --- a/arch/sparc64/kernel/head.S
    +++ b/arch/sparc64/kernel/head.S
    @@ -458,7 +458,6 @@ tlb_fixup_done:
    or %g6, %lo(init_thread_union), %g6
    ldx [%g6 + TI_TASK], %g4
    mov %sp, %l6
    - mov %o4, %l7

    wr %g0, ASI_P, %asi
    mov 1, %g1
    diff --git a/arch/um/os-Linux/user_syms.c b/arch/um/os-Linux/user_syms.c
    index 3f33165..419b2d5 100644
    --- a/arch/um/os-Linux/user_syms.c
    +++ b/arch/um/os-Linux/user_syms.c
    @@ -5,7 +5,8 @@
    * so I *must* declare good prototypes for them and then EXPORT them.
    * The kernel code uses the macro defined by include/linux/string.h,
    * so I undef macros; the userspace code does not include that and I
    - * add an EXPORT for the glibc one.*/
    + * add an EXPORT for the glibc one.
    + */

    #undef strlen
    #undef strstr
    @@ -61,12 +62,18 @@ EXPORT_SYMBOL_PROTO(dup2);
    EXPORT_SYMBOL_PROTO(__xstat);
    EXPORT_SYMBOL_PROTO(__lxstat);
    EXPORT_SYMBOL_PROTO(__lxstat64);
    +EXPORT_SYMBOL_PROTO(__fxstat64);
    EXPORT_SYMBOL_PROTO(lseek);
    EXPORT_SYMBOL_PROTO(lseek64);
    EXPORT_SYMBOL_PROTO(chown);
    +EXPORT_SYMBOL_PROTO(fchown);
    EXPORT_SYMBOL_PROTO(truncate);
    +EXPORT_SYMBOL_PROTO(ftruncate64);
    EXPORT_SYMBOL_PROTO(utime);
    +EXPORT_SYMBOL_PROTO(utimes);
    +EXPORT_SYMBOL_PROTO(futimes);
    EXPORT_SYMBOL_PROTO(chmod);
    +EXPORT_SYMBOL_PROTO(fchmod);
    EXPORT_SYMBOL_PROTO(rename);
    EXPORT_SYMBOL_PROTO(__xmknod);

    @@ -102,14 +109,3 @@ EXPORT_SYMBOL(__stack_smash_handler);

    extern long __guard __attribute__((weak));
    EXPORT_SYMBOL(__guard);
    -
    -/*
    - * Overrides for Emacs so that we follow Linus's tabbing style.
    - * Emacs will notice this stuff at the end of the file and automatically
    - * adjust the settings for this buffer only. This must remain at the end
    - * of the file.
    - * ---------------------------------------------------------------------------
    - * Local variables:
    - * c-file-style: "linux"
    - * End:
    - */
    diff --git a/drivers/ata/ata_piix.c b/drivers/ata/ata_piix.c
    index 57c0db3..0c646dc 100644
    --- a/drivers/ata/ata_piix.c
    +++ b/drivers/ata/ata_piix.c
    @@ -431,7 +431,7 @@ static const struct piix_map_db ich8_map_db = {
    /* PM PS SM SS MAP */
    { P0, P2, P1, P3 }, /* 00b (hardwired when in AHCI) */
    { RV, RV, RV, RV },
    - { IDE, IDE, NA, NA }, /* 10b (IDE mode) */
    + { P0, P2, IDE, IDE }, /* 10b (IDE mode) */
    { RV, RV, RV, RV },
    },
    };
    diff --git a/drivers/ata/pata_atiixp.c b/drivers/ata/pata_atiixp.c
    index b50ebb6..17d75ec 100644
    --- a/drivers/ata/pata_atiixp.c
    +++ b/drivers/ata/pata_atiixp.c
    @@ -283,6 +283,7 @@ static const struct pci_device_id atiixp[] = {
    { PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP300_IDE), },
    { PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP400_IDE), },
    { PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP600_IDE), },
    + { PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP700_IDE), },

    { },
    };
    diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
    index 7fd095e..be31b43 100644
    --- a/drivers/base/cpu.c
    +++ b/drivers/base/cpu.c
    @@ -53,7 +53,7 @@ static ssize_t store_online(struct sys_device *dev, const char *buf,
    ret = count;
    return ret;
    }
    -static SYSDEV_ATTR(online, 0600, show_online, store_online);
    +static SYSDEV_ATTR(online, 0644, show_online, store_online);

    static void __devinit register_cpu_control(struct cpu *cpu)
    {
    diff --git a/drivers/char/drm/i915_dma.c b/drivers/char/drm/i915_dma.c
    index 9354ce3..ab1a1d0 100644
    --- a/drivers/char/drm/i915_dma.c
    +++ b/drivers/char/drm/i915_dma.c
    @@ -172,6 +172,8 @@ static int i915_initialize(drm_device_t * dev,
    * private backbuffer/depthbuffer usage.
    */
    dev_priv->use_mi_batchbuffer_start = 0;
    + if (IS_I965G(dev)) /* 965 doesn't support older method */
    + dev_priv->use_mi_batchbuffer_start = 1;

    /* Allow hardware batchbuffers unless told otherwise.
    */
    @@ -504,8 +506,13 @@ static int i915_dispatch_batchbuffer(drm_device_t * dev,

    if (dev_priv->use_mi_batchbuffer_start) {
    BEGIN_LP_RING(2);
    - OUT_RING(MI_BATCH_BUFFER_START | (2 << 6));
    - OUT_RING(batch->start | MI_BATCH_NON_SECURE);
    + if (IS_I965G(dev)) {
    + OUT_RING(MI_BATCH_BUFFER_START | (2 << 6) | MI_BATCH_NON_SECURE_I965);
    + OUT_RING(batch->start);
    + } else {
    + OUT_RING(MI_BATCH_BUFFER_START | (2 << 6));
    + OUT_RING(batch->start | MI_BATCH_NON_SECURE);
    + }
    ADVANCE_LP_RING();
    } else {
    BEGIN_LP_RING(4);
    @@ -722,7 +729,8 @@ static int i915_setparam(DRM_IOCTL_ARGS)

    switch (param.param) {
    case I915_SETPARAM_USE_MI_BATCHBUFFER_START:
    - dev_priv->use_mi_batchbuffer_start = param.value;
    + if (!IS_I965G(dev))
    + dev_priv->use_mi_batchbuffer_start = param.value;
    break;
    case I915_SETPARAM_TEX_LRU_LOG_GRANULARITY:
    dev_priv->tex_lru_log_granularity = param.value;
    diff --git a/drivers/char/drm/i915_drv.h b/drivers/char/drm/i915_drv.h
    index 93cdcfe..30022c8 100644
    --- a/drivers/char/drm/i915_drv.h
    +++ b/drivers/char/drm/i915_drv.h
    @@ -280,6 +280,7 @@ extern int i915_wait_ring(drm_device_t * dev, int n, const char *caller);
    #define MI_BATCH_BUFFER_START (0x31<<23)
    #define MI_BATCH_BUFFER_END (0xA<<23)
    #define MI_BATCH_NON_SECURE (1)
    +#define MI_BATCH_NON_SECURE_I965 (1<<8)

    #define MI_WAIT_FOR_EVENT ((0x3<<23))
    #define MI_WAIT_FOR_PLANE_A_FLIP (1<<2)
    diff --git a/drivers/char/random.c b/drivers/char/random.c
    index 263e5e5..96561c8 100644
    --- a/drivers/char/random.c
    +++ b/drivers/char/random.c
    @@ -693,9 +693,14 @@ static void xfer_secondary_pool(struct entropy_store *r, size_t nbytes)

    if (r->pull && r->entropy_count < nbytes * 8 &&
    r->entropy_count < r->poolinfo->POOLBITS) {
    - int bytes = max_t(int, random_read_wakeup_thresh / 8,
    - min_t(int, nbytes, sizeof(tmp)));
    + /* If we're limited, always leave two wakeup worth's BITS */
    int rsvd = r->limit ? 0 : random_read_wakeup_thresh/4;
    + int bytes = nbytes;
    +
    + /* pull at least as many as BYTES as wakeup BITS */
    + bytes = max_t(int, bytes, random_read_wakeup_thresh / 8);
    + /* but never more than the buffer size */
    + bytes = min_t(int, bytes, sizeof(tmp));

    DEBUG_ENT("going to reseed %s with %d bits "
    "(%d of %d requested)\n",
    diff --git a/drivers/char/sx.c b/drivers/char/sx.c
    index 1da92a6..85a2328 100644
    --- a/drivers/char/sx.c
    +++ b/drivers/char/sx.c
    @@ -2721,9 +2721,9 @@ static void __devexit sx_pci_remove(struct pci_dev *pdev)
    its because the standard requires it. So check for SUBVENDOR_ID. */
    static struct pci_device_id sx_pci_tbl[] = {
    { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
    - .subvendor = 0x0200,.subdevice = PCI_ANY_ID },
    + .subvendor = PCI_ANY_ID, .subdevice = 0x0200 },
    { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
    - .subvendor = 0x0300,.subdevice = PCI_ANY_ID },
    + .subvendor = PCI_ANY_ID, .subdevice = 0x0300 },
    { 0 }
    };

    diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c
    index f697449..1d11d13 100644
    --- a/drivers/cpufreq/cpufreq_ondemand.c
    +++ b/drivers/cpufreq/cpufreq_ondemand.c
    @@ -95,15 +95,25 @@ static struct dbs_tuners {

    static inline cputime64_t get_cpu_idle_time(unsigned int cpu)
    {
    - cputime64_t retval;
    + cputime64_t idle_time;
    + cputime64_t cur_jiffies;
    + cputime64_t busy_time;

    - retval = cputime64_add(kstat_cpu(cpu).cpustat.idle,
    - kstat_cpu(cpu).cpustat.iowait);
    + cur_jiffies = jiffies64_to_cputime64(get_jiffies_64());
    + busy_time = cputime64_add(kstat_cpu(cpu).cpustat.user,
    + kstat_cpu(cpu).cpustat.system);

    - if (dbs_tuners_ins.ignore_nice)
    - retval = cputime64_add(retval, kstat_cpu(cpu).cpustat.nice);
    + busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.irq);
    + busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.softirq);
    + busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.steal);

    - return retval;
    + if (!dbs_tuners_ins.ignore_nice) {
    + busy_time = cputime64_add(busy_time,
    + kstat_cpu(cpu).cpustat.nice);
    + }
    +
    + idle_time = cputime64_sub(cur_jiffies, busy_time);
    + return idle_time;
    }

    /*
    @@ -324,7 +334,7 @@ static struct attribute_group dbs_attr_group = {
    static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info)
    {
    unsigned int idle_ticks, total_ticks;
    - unsigned int load;
    + unsigned int load = 0;
    cputime64_t cur_jiffies;

    struct cpufreq_policy *policy;
    @@ -338,7 +348,8 @@ static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info)
    cur_jiffies = jiffies64_to_cputime64(get_jiffies_64());
    total_ticks = (unsigned int) cputime64_sub(cur_jiffies,
    this_dbs_info->prev_cpu_wall);
    - this_dbs_info->prev_cpu_wall = cur_jiffies;
    + this_dbs_info->prev_cpu_wall = get_jiffies_64();
    +
    if (!total_ticks)
    return;
    /*
    @@ -369,7 +380,8 @@ static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info)
    if (tmp_idle_ticks < idle_ticks)
    idle_ticks = tmp_idle_ticks;
    }
    - load = (100 * (total_ticks - idle_ticks)) / total_ticks;
    + if (likely(total_ticks > idle_ticks))
    + load = (100 * (total_ticks - idle_ticks)) / total_ticks;

    /* Check for frequency increase */
    if (load > dbs_tuners_ins.up_threshold) {
    diff --git a/drivers/kvm/svm.c b/drivers/kvm/svm.c
    index c79df79..1e90401 100644
    --- a/drivers/kvm/svm.c
    +++ b/drivers/kvm/svm.c
    @@ -1655,6 +1655,12 @@ static void svm_inject_page_fault(struct kvm_vcpu *vcpu,

    static int is_disabled(void)
    {
    + u64 vm_cr;
    +
    + rdmsrl(MSR_VM_CR, vm_cr);
    + if (vm_cr & (1 << SVM_VM_CR_SVM_DISABLE))
    + return 1;
    +
    return 0;
    }

    diff --git a/drivers/kvm/svm.h b/drivers/kvm/svm.h
    index df731c3..e8f0349 100644
    --- a/drivers/kvm/svm.h
    +++ b/drivers/kvm/svm.h
    @@ -172,8 +172,11 @@ struct __attribute__ ((__packed__)) vmcb {
    #define SVM_CPUID_FUNC 0x8000000a

    #define MSR_EFER_SVME_MASK (1ULL << 12)
    +#define MSR_VM_CR 0xc0010114
    #define MSR_VM_HSAVE_PA 0xc0010117ULL

    +#define SVM_VM_CR_SVM_DISABLE 4
    +
    #define SVM_SELECTOR_S_SHIFT 4
    #define SVM_SELECTOR_DPL_SHIFT 5
    #define SVM_SELECTOR_P_SHIFT 7
    diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
    index b9ff4e3..7989dac 100644
    --- a/drivers/md/dm-crypt.c
    +++ b/drivers/md/dm-crypt.c
    @@ -917,6 +917,8 @@ static void crypt_dtr(struct dm_target *ti)
    {
    struct crypt_config *cc = (struct crypt_config *) ti->private;

    + flush_workqueue(_kcryptd_workqueue);
    +
    bioset_free(cc->bs);
    mempool_destroy(cc->page_pool);
    mempool_destroy(cc->io_pool);
    @@ -938,9 +940,6 @@ static int crypt_map(struct dm_target *ti, struct bio *bio,
    struct crypt_config *cc = ti->private;
    struct crypt_io *io;

    - if (bio_barrier(bio))
    - return -EOPNOTSUPP;
    -
    io = mempool_alloc(cc->io_pool, GFP_NOIO);
    io->target = ti;
    io->base_bio = bio;
    diff --git a/drivers/md/dm-exception-store.c b/drivers/md/dm-exception-store.c
    index 99cdffa..fc496fc 100644
    --- a/drivers/md/dm-exception-store.c
    +++ b/drivers/md/dm-exception-store.c
    @@ -453,11 +453,6 @@ static int persistent_read_metadata(struct exception_store *store)
    /*
    * Sanity checks.
    */
    - if (!ps->valid) {
    - DMWARN("snapshot is marked invalid");
    - return -EINVAL;
    - }
    -
    if (ps->version != SNAPSHOT_DISK_VERSION) {
    DMWARN("unable to handle snapshot disk version %d",
    ps->version);
    @@ -465,6 +460,12 @@ static int persistent_read_metadata(struct exception_store *store)
    }

    /*
    + * Metadata are valid, but snapshot is invalidated
    + */
    + if (!ps->valid)
    + return 1;
    +
    + /*
    * Read the metadata.
    */
    r = read_exceptions(ps);
    diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
    index 3aa0135..af27464 100644
    --- a/drivers/md/dm-mpath.c
    +++ b/drivers/md/dm-mpath.c
    @@ -795,9 +795,6 @@ static int multipath_map(struct dm_target *ti, struct bio *bio,
    struct mpath_io *mpio;
    struct multipath *m = (struct multipath *) ti->private;

    - if (bio_barrier(bio))
    - return -EOPNOTSUPP;
    -
    mpio = mempool_alloc(m->mpio_pool, GFP_NOIO);
    dm_bio_record(&mpio->details, bio);

    diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
    index 0821a2b..3955621 100644
    --- a/drivers/md/dm-snap.c
    +++ b/drivers/md/dm-snap.c
    @@ -522,9 +522,12 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)

    /* Metadata must only be loaded into one table at once */
    r = s->store.read_metadata(&s->store);
    - if (r) {
    + if (r < 0) {
    ti->error = "Failed to read snapshot metadata";
    goto bad6;
    + } else if (r > 0) {
    + s->valid = 0;
    + DMWARN("Snapshot is marked invalid.");
    }

    bio_list_init(&s->queued_bios);
    @@ -884,9 +887,6 @@ static int snapshot_map(struct dm_target *ti, struct bio *bio,
    if (!s->valid)
    return -EIO;

    - if (unlikely(bio_barrier(bio)))
    - return -EOPNOTSUPP;
    -
    /* FIXME: should only take write lock if we need
    * to copy an exception */
    down_write(&s->lock);
    @@ -1157,9 +1157,6 @@ static int origin_map(struct dm_target *ti, struct bio *bio,
    struct dm_dev *dev = (struct dm_dev *) ti->private;
    bio->bi_bdev = dev->bdev;

    - if (unlikely(bio_barrier(bio)))
    - return -EOPNOTSUPP;
    -
    /* Only tell snapshots if this is a write */
    return (bio_rw(bio) == WRITE) ? do_origin(dev, bio) : DM_MAPIO_REMAPPED;
    }
    diff --git a/drivers/md/dm.c b/drivers/md/dm.c
    index 3668b17..d531f0c 100644
    --- a/drivers/md/dm.c
    +++ b/drivers/md/dm.c
    @@ -802,6 +802,15 @@ static int dm_request(request_queue_t *q, struct bio *bio)
    int rw = bio_data_dir(bio);
    struct mapped_device *md = q->queuedata;

    + /*
    + * There is no use in forwarding any barrier request since we can't
    + * guarantee it is (or can be) handled by the targets correctly.
    + */
    + if (unlikely(bio_barrier(bio))) {
    + bio_endio(bio, bio->bi_size, -EOPNOTSUPP);
    + return 0;
    + }
    +
    down_read(&md->io_lock);

    disk_stat_inc(dm_disk(md), ios[rw]);
    diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
    index 9eb66c1..e0029ea 100644
    --- a/drivers/md/raid10.c
    +++ b/drivers/md/raid10.c
    @@ -917,6 +917,13 @@ static int make_request(request_queue_t *q, struct bio * bio)
    bio_list_add(&bl, mbio);
    }

    + if (unlikely(!atomic_read(&r10_bio->remaining))) {
    + /* the array is dead */
    + md_write_end(mddev);
    + raid_end_bio_io(r10_bio);
    + return 0;
    + }
    +
    bitmap_startwrite(mddev->bitmap, bio->bi_sector, r10_bio->sectors, 0);
    spin_lock_irqsave(&conf->device_lock, flags);
    bio_list_merge(&conf->pending_bio_list, &bl);
    @@ -1558,7 +1565,6 @@ static void raid10d(mddev_t *mddev)
    bio = r10_bio->devs[r10_bio->read_slot].bio;
    r10_bio->devs[r10_bio->read_slot].bio =
    mddev->ro ? IO_BLOCKED : NULL;
    - bio_put(bio);
    mirror = read_balance(conf, r10_bio);
    if (mirror == -1) {
    printk(KERN_ALERT "raid10: %s: unrecoverable I/O"
    @@ -1566,8 +1572,10 @@ static void raid10d(mddev_t *mddev)
    bdevname(bio->bi_bdev,b),
    (unsigned long long)r10_bio->sector);
    raid_end_bio_io(r10_bio);
    + bio_put(bio);
    } else {
    const int do_sync = bio_sync(r10_bio->master_bio);
    + bio_put(bio);
    rdev = conf->mirrors[mirror].rdev;
    if (printk_ratelimit())
    printk(KERN_ERR "raid10: %s: redirecting sector %llu to"
    diff --git a/drivers/media/video/v4l2-common.c b/drivers/media/video/v4l2-common.c
    index b87d571..31807ba 100644
    --- a/drivers/media/video/v4l2-common.c
    +++ b/drivers/media/video/v4l2-common.c
    @@ -1499,16 +1499,25 @@ int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qc
    When no more controls are available 0 is returned. */
    u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
    {
    - u32 ctrl_class;
    + u32 ctrl_class = V4L2_CTRL_ID2CLASS(id);
    const u32 *pctrl;

    - /* if no query is desired, then just return the control ID */
    - if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0)
    - return id;
    if (ctrl_classes == NULL)
    return 0;
    +
    + /* if no query is desired, then check if the ID is part of ctrl_classes */
    + if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) {
    + /* find class */
    + while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) != ctrl_class)
    + ctrl_classes++;
    + if (*ctrl_classes == NULL)
    + return 0;
    + pctrl = *ctrl_classes;
    + /* find control ID */
    + while (*pctrl && *pctrl != id) pctrl++;
    + return *pctrl ? id : 0;
    + }
    id &= V4L2_CTRL_ID_MASK;
    - ctrl_class = V4L2_CTRL_ID2CLASS(id);
    id++; /* select next control */
    /* find first class that matches (or is greater than) the class of
    the ID */
    diff --git a/drivers/media/video/wm8739.c b/drivers/media/video/wm8739.c
    index a9b59c3..009941b 100644
    --- a/drivers/media/video/wm8739.c
    +++ b/drivers/media/video/wm8739.c
    @@ -317,12 +317,14 @@ static int wm8739_probe(struct i2c_adapter *adapter)

    static int wm8739_detach(struct i2c_client *client)
    {
    + struct wm8739_state *state = i2c_get_clientdata(client);
    int err;

    err = i2c_detach_client(client);
    if (err)
    return err;

    + kfree(state);
    kfree(client);
    return 0;
    }
    diff --git a/drivers/media/video/wm8775.c b/drivers/media/video/wm8775.c
    index d81a88b..e555b3a 100644
    --- a/drivers/media/video/wm8775.c
    +++ b/drivers/media/video/wm8775.c
    @@ -218,12 +218,14 @@ static int wm8775_probe(struct i2c_adapter *adapter)

    static int wm8775_detach(struct i2c_client *client)
    {
    + struct wm8775_state *state = i2c_get_clientdata(client);
    int err;

    err = i2c_detach_client(client);
    if (err) {
    return err;
    }
    + kfree(state);
    kfree(client);

    return 0;
    diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c
    index 952a6bd..c383dc3 100644
    --- a/drivers/net/forcedeth.c
    +++ b/drivers/net/forcedeth.c
    @@ -553,6 +553,7 @@ union ring_type {
    /* PHY defines */
    #define PHY_OUI_MARVELL 0x5043
    #define PHY_OUI_CICADA 0x03f1
    +#define PHY_OUI_VITESSE 0x01c1
    #define PHYID1_OUI_MASK 0x03ff
    #define PHYID1_OUI_SHFT 6
    #define PHYID2_OUI_MASK 0xfc00
    @@ -560,12 +561,29 @@ union ring_type {
    #define PHYID2_MODEL_MASK 0x03f0
    #define PHY_MODEL_MARVELL_E3016 0x220
    #define PHY_MARVELL_E3016_INITMASK 0x0300
    -#define PHY_INIT1 0x0f000
    -#define PHY_INIT2 0x0e00
    -#define PHY_INIT3 0x01000
    -#define PHY_INIT4 0x0200
    -#define PHY_INIT5 0x0004
    -#define PHY_INIT6 0x02000
    +#define PHY_CICADA_INIT1 0x0f000
    +#define PHY_CICADA_INIT2 0x0e00
    +#define PHY_CICADA_INIT3 0x01000
    +#define PHY_CICADA_INIT4 0x0200
    +#define PHY_CICADA_INIT5 0x0004
    +#define PHY_CICADA_INIT6 0x02000
    +#define PHY_VITESSE_INIT_REG1 0x1f
    +#define PHY_VITESSE_INIT_REG2 0x10
    +#define PHY_VITESSE_INIT_REG3 0x11
    +#define PHY_VITESSE_INIT_REG4 0x12
    +#define PHY_VITESSE_INIT_MSK1 0xc
    +#define PHY_VITESSE_INIT_MSK2 0x0180
    +#define PHY_VITESSE_INIT1 0x52b5
    +#define PHY_VITESSE_INIT2 0xaf8a
    +#define PHY_VITESSE_INIT3 0x8
    +#define PHY_VITESSE_INIT4 0x8f8a
    +#define PHY_VITESSE_INIT5 0xaf86
    +#define PHY_VITESSE_INIT6 0x8f86
    +#define PHY_VITESSE_INIT7 0xaf82
    +#define PHY_VITESSE_INIT8 0x0100
    +#define PHY_VITESSE_INIT9 0x8f82
    +#define PHY_VITESSE_INIT10 0x0
    +
    #define PHY_GIGABIT 0x0100

    #define PHY_TIMEOUT 0x1
    @@ -1133,14 +1151,14 @@ static int phy_init(struct net_device *dev)
    /* phy vendor specific configuration */
    if ((np->phy_oui == PHY_OUI_CICADA) && (phyinterface & PHY_RGMII) ) {
    phy_reserved = mii_rw(dev, np->phyaddr, MII_RESV1, MII_READ);
    - phy_reserved &= ~(PHY_INIT1 | PHY_INIT2);
    - phy_reserved |= (PHY_INIT3 | PHY_INIT4);
    + phy_reserved &= ~(PHY_CICADA_INIT1 | PHY_CICADA_INIT2);
    + phy_reserved |= (PHY_CICADA_INIT3 | PHY_CICADA_INIT4);
    if (mii_rw(dev, np->phyaddr, MII_RESV1, phy_reserved)) {
    printk(KERN_INFO "%s: phy init failed.\n", pci_name(np->pci_dev));
    return PHY_ERROR;
    }
    phy_reserved = mii_rw(dev, np->phyaddr, MII_NCONFIG, MII_READ);
    - phy_reserved |= PHY_INIT5;
    + phy_reserved |= PHY_CICADA_INIT5;
    if (mii_rw(dev, np->phyaddr, MII_NCONFIG, phy_reserved)) {
    printk(KERN_INFO "%s: phy init failed.\n", pci_name(np->pci_dev));
    return PHY_ERROR;
    @@ -1148,12 +1166,82 @@ static int phy_init(struct net_device *dev)
    }
    if (np->phy_oui == PHY_OUI_CICADA) {
    phy_reserved = mii_rw(dev, np->phyaddr, MII_SREVISION, MII_READ);
    - phy_reserved |= PHY_INIT6;
    + phy_reserved |= PHY_CICADA_INIT6;
    if (mii_rw(dev, np->phyaddr, MII_SREVISION, phy_reserved)) {
    printk(KERN_INFO "%s: phy init failed.\n", pci_name(np->pci_dev));
    return PHY_ERROR;
    }
    }
    + if (np->phy_oui == PHY_OUI_VITESSE) {
    + if (mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG1, PHY_VITESSE_INIT1)) {
    + printk(KERN_INFO "%s: phy init failed.\n", pci_name(np->pci_dev));
    + return PHY_ERROR;
    + }
    + if (mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG2, PHY_VITESSE_INIT2)) {
    + printk(KERN_INFO "%s: phy init failed.\n", pci_name(np->pci_dev));
    + return PHY_ERROR;
    + }
    + phy_reserved = mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG4, MII_READ);
    + if (mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG4, phy_reserved)) {
    + printk(KERN_INFO "%s: phy init failed.\n", pci_name(np->pci_dev));
    + return PHY_ERROR;
    + }
    + phy_reserved = mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG3, MII_READ);
    + phy_reserved &= ~PHY_VITESSE_INIT_MSK1;
    + phy_reserved |= PHY_VITESSE_INIT3;
    + if (mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG3, phy_reserved)) {
    + printk(KERN_INFO "%s: phy init failed.\n", pci_name(np->pci_dev));
    + return PHY_ERROR;
    + }
    + if (mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG2, PHY_VITESSE_INIT4)) {
    + printk(KERN_INFO "%s: phy init failed.\n", pci_name(np->pci_dev));
    + return PHY_ERROR;
    + }
    + if (mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG2, PHY_VITESSE_INIT5)) {
    + printk(KERN_INFO "%s: phy init failed.\n", pci_name(np->pci_dev));
    + return PHY_ERROR;
    + }
    + phy_reserved = mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG4, MII_READ);
    + phy_reserved &= ~PHY_VITESSE_INIT_MSK1;
    + phy_reserved |= PHY_VITESSE_INIT3;
    + if (mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG4, phy_reserved)) {
    + printk(KERN_INFO "%s: phy init failed.\n", pci_name(np->pci_dev));
    + return PHY_ERROR;
    + }
    + phy_reserved = mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG3, MII_READ);
    + if (mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG3, phy_reserved)) {
    + printk(KERN_INFO "%s: phy init failed.\n", pci_name(np->pci_dev));
    + return PHY_ERROR;
    + }
    + if (mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG2, PHY_VITESSE_INIT6)) {
    + printk(KERN_INFO "%s: phy init failed.\n", pci_name(np->pci_dev));
    + return PHY_ERROR;
    + }
    + if (mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG2, PHY_VITESSE_INIT7)) {
    + printk(KERN_INFO "%s: phy init failed.\n", pci_name(np->pci_dev));
    + return PHY_ERROR;
    + }
    + phy_reserved = mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG4, MII_READ);
    + if (mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG4, phy_reserved)) {
    + printk(KERN_INFO "%s: phy init failed.\n", pci_name(np->pci_dev));
    + return PHY_ERROR;
    + }
    + phy_reserved = mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG3, MII_READ);
    + phy_reserved &= ~PHY_VITESSE_INIT_MSK2;
    + phy_reserved |= PHY_VITESSE_INIT8;
    + if (mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG3, phy_reserved)) {
    + printk(KERN_INFO "%s: phy init failed.\n", pci_name(np->pci_dev));
    + return PHY_ERROR;
    + }
    + if (mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG2, PHY_VITESSE_INIT9)) {
    + printk(KERN_INFO "%s: phy init failed.\n", pci_name(np->pci_dev));
    + return PHY_ERROR;
    + }
    + if (mii_rw(dev, np->phyaddr, PHY_VITESSE_INIT_REG1, PHY_VITESSE_INIT10)) {
    + printk(KERN_INFO "%s: phy init failed.\n", pci_name(np->pci_dev));
    + return PHY_ERROR;
    + }
    + }
    /* some phys clear out pause advertisment on reset, set it back */
    mii_rw(dev, np->phyaddr, MII_ADVERTISE, reg);

    diff --git a/drivers/pcmcia/cs.c b/drivers/pcmcia/cs.c
    index 606a467..2785d83 100644
    --- a/drivers/pcmcia/cs.c
    +++ b/drivers/pcmcia/cs.c
    @@ -410,6 +410,9 @@ static void socket_shutdown(struct pcmcia_socket *s)
    #endif
    s->functions = 0;

    + /* give socket some time to power down */
    + msleep(100);
    +
    s->ops->get_status(s, &status);
    if (status & SS_POWERON) {
    printk(KERN_ERR "PCMCIA: socket %p: *** DANGER *** unable to remove socket power\n", s);
    diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
    index d2cf875..3d5cff7 100644
    --- a/drivers/scsi/aacraid/linit.c
    +++ b/drivers/scsi/aacraid/linit.c
    @@ -539,6 +539,8 @@ static int aac_cfg_open(struct inode *inode, struct file *file)
    static int aac_cfg_ioctl(struct inode *inode, struct file *file,
    unsigned int cmd, unsigned long arg)
    {
    + if (!capable(CAP_SYS_ADMIN))
    + return -EPERM;
    return aac_do_ioctl(file->private_data, cmd, (void __user *)arg);
    }

    @@ -592,6 +594,8 @@ static int aac_compat_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)

    static long aac_compat_cfg_ioctl(struct file *file, unsigned cmd, unsigned long arg)
    {
    + if (!capable(CAP_SYS_ADMIN))
    + return -EPERM;
    return aac_compat_do_ioctl((struct aac_dev *)file->private_data, cmd, arg);
    }
    #endif
    diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
    index 8ddeed3..d5890d5 100644
    --- a/drivers/usb/core/hub.c
    +++ b/drivers/usb/core/hub.c
    @@ -1356,6 +1356,10 @@ static int __usb_new_device(void *void_data)
    }
    #endif

    + /* Increment the parent's count of unsuspended children */
    + if (udev->parent)
    + usb_autoresume_device(udev->parent);
    +
    /* Register the device. The device driver is responsible
    * for adding the device files to usbfs and sysfs and for
    * configuring the device.
    @@ -1363,13 +1367,11 @@ static int __usb_new_device(void *void_data)
    err = device_add (&udev->dev);
    if (err) {
    dev_err(&udev->dev, "can't device_add, error %d\n", err);
    + if (udev->parent)
    + usb_autosuspend_device(udev->parent);
    goto fail;
    }

    - /* Increment the parent's count of unsuspended children */
    - if (udev->parent)
    - usb_autoresume_device(udev->parent);
    -
    exit:
    module_put(THIS_MODULE);
    return err;
    diff --git a/drivers/video/macmodes.c b/drivers/video/macmodes.c
    index ab21495..083f603 100644
    --- a/drivers/video/macmodes.c
    +++ b/drivers/video/macmodes.c
    @@ -369,9 +369,8 @@ EXPORT_SYMBOL(mac_map_monitor_sense);
    *
    */

    -int __devinit mac_find_mode(struct fb_var_screeninfo *var,
    - struct fb_info *info, const char *mode_option,
    - unsigned int default_bpp)
    +int mac_find_mode(struct fb_var_screeninfo *var, struct fb_info *info,
    + const char *mode_option, unsigned int default_bpp)
    {
    const struct fb_videomode *db = NULL;
    unsigned int dbsize = 0;
    diff --git a/drivers/video/macmodes.h b/drivers/video/macmodes.h
    index babeb81..b86ba08 100644
    --- a/drivers/video/macmodes.h
    +++ b/drivers/video/macmodes.h
    @@ -55,10 +55,10 @@ extern int mac_vmode_to_var(int vmode, int cmode,
    extern int mac_var_to_vmode(const struct fb_var_screeninfo *var, int *vmode,
    int *cmode);
    extern int mac_map_monitor_sense(int sense);
    -extern int __devinit mac_find_mode(struct fb_var_screeninfo *var,
    - struct fb_info *info,
    - const char *mode_option,
    - unsigned int default_bpp);
    +extern int mac_find_mode(struct fb_var_screeninfo *var,
    + struct fb_info *info,
    + const char *mode_option,
    + unsigned int default_bpp);


    /*
    diff --git a/drivers/video/stifb.c b/drivers/video/stifb.c
    index 69f3b26..6074ae9 100644
    --- a/drivers/video/stifb.c
    +++ b/drivers/video/stifb.c
    @@ -1101,13 +1101,18 @@ stifb_init_fb(struct sti_struct *sti, int bpp_pref)
    /* only supported cards are allowed */
    switch (fb->id) {
    case CRT_ID_VISUALIZE_EG:
    - /* look for a double buffering device like e.g. the
    - "INTERNAL_EG_DX1024" in the RDI precisionbook laptop
    - which won't work. The same device in non-double
    - buffering mode returns "INTERNAL_EG_X1024". */
    - if (strstr(sti->outptr.dev_name, "EG_DX")) {
    - printk(KERN_WARNING
    - "stifb: ignoring '%s'. Disable double buffering in IPL menu.\n",
    + /* Visualize cards can run either in "double buffer" or
    + "standard" mode. Depending on the mode, the card reports
    + a different device name, e.g. "INTERNAL_EG_DX1024" in double
    + buffer mode and "INTERNAL_EG_X1024" in standard mode.
    + Since this driver only supports standard mode, we check
    + if the device name contains the string "DX" and tell the
    + user how to reconfigure the card. */
    + if (strstr(sti->outptr.dev_name, "DX")) {
    + printk(KERN_WARNING "WARNING: stifb framebuffer driver does not "
    + "support '%s' in double-buffer mode.\n"
    + KERN_WARNING "WARNING: Please disable the double-buffer mode "
    + "in IPL menu (the PARISC-BIOS).\n",
    sti->outptr.dev_name);
    goto out_err0;
    }
    diff --git a/fs/9p/conv.c b/fs/9p/conv.c
    index a3ed571..923d75c 100644
    --- a/fs/9p/conv.c
    +++ b/fs/9p/conv.c
    @@ -742,6 +742,7 @@ struct v9fs_fcall *v9fs_create_twrite(u32 fid, u64 offset, u32 count,
    if (err) {
    kfree(fc);
    fc = ERR_PTR(err);
    + goto error;
    }

    if (buf_check_overflow(bufp)) {
    diff --git a/fs/direct-io.c b/fs/direct-io.c
    index d9d0833..0286993 100644
    --- a/fs/direct-io.c
    +++ b/fs/direct-io.c
    @@ -978,6 +978,7 @@ direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
    dio->get_block = get_block;
    dio->end_io = end_io;
    dio->map_bh.b_private = NULL;
    + dio->map_bh.b_state = 0;
    dio->final_block_in_bio = -1;
    dio->next_block_for_io = -1;

    diff --git a/fs/exec.c b/fs/exec.c
    index 0f8573a..bd1ab3f 100644
    --- a/fs/exec.c
    +++ b/fs/exec.c
    @@ -881,9 +881,12 @@ int flush_old_exec(struct linux_binprm * bprm)
    */
    current->mm->task_size = TASK_SIZE;

    - if (bprm->e_uid != current->euid || bprm->e_gid != current->egid ||
    - file_permission(bprm->file, MAY_READ) ||
    - (bprm->interp_flags & BINPRM_FLAGS_ENFORCE_NONDUMP)) {
    + if (bprm->e_uid != current->euid || bprm->e_gid != current->egid) {
    + suid_keys(current);
    + current->mm->dumpable = suid_dumpable;
    + current->pdeath_signal = 0;
    + } else if (file_permission(bprm->file, MAY_READ) ||
    + (bprm->interp_flags & BINPRM_FLAGS_ENFORCE_NONDUMP)) {
    suid_keys(current);
    current->mm->dumpable = suid_dumpable;
    }
    @@ -974,8 +977,10 @@ void compute_creds(struct linux_binprm *bprm)
    {
    int unsafe;

    - if (bprm->e_uid != current->uid)
    + if (bprm->e_uid != current->uid) {
    suid_keys(current);
    + current->pdeath_signal = 0;
    + }
    exec_keys(current);

    task_lock(current);
    diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
    index dc2724f..14b0b49 100644
    --- a/fs/ext4/extents.c
    +++ b/fs/ext4/extents.c
    @@ -1397,7 +1397,7 @@ int ext4_ext_walk_space(struct inode *inode, unsigned long block,

    static void
    ext4_ext_put_in_cache(struct inode *inode, __u32 block,
    - __u32 len, __u32 start, int type)
    + __u32 len, ext4_fsblk_t start, int type)
    {
    struct ext4_ext_cache *cex;
    BUG_ON(len == 0);
    diff --git a/fs/jbd/commit.c b/fs/jbd/commit.c
    index be4648b..84436cb 100644
    --- a/fs/jbd/commit.c
    +++ b/fs/jbd/commit.c
    @@ -888,7 +888,8 @@ restart_loop:
    journal->j_committing_transaction = NULL;
    spin_unlock(&journal->j_state_lock);

    - if (commit_transaction->t_checkpoint_list == NULL) {
    + if (commit_transaction->t_checkpoint_list == NULL &&
    + commit_transaction->t_checkpoint_io_list == NULL) {
    __journal_drop_transaction(journal, commit_transaction);
    } else {
    if (journal->j_checkpoint_transactions == NULL) {
    diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
    index 6bd8005..7d29549 100644
    --- a/fs/jbd2/commit.c
    +++ b/fs/jbd2/commit.c
    @@ -897,7 +897,8 @@ restart_loop:
    journal->j_committing_transaction = NULL;
    spin_unlock(&journal->j_state_lock);

    - if (commit_transaction->t_checkpoint_list == NULL) {
    + if (commit_transaction->t_checkpoint_list == NULL &&
    + commit_transaction->t_checkpoint_io_list == NULL) {
    __jbd2_journal_drop_transaction(journal, commit_transaction);
    } else {
    if (journal->j_checkpoint_transactions == NULL) {
    diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
    index 8283236..d8b773a 100644
    --- a/fs/nfsd/vfs.c
    +++ b/fs/nfsd/vfs.c
    @@ -1887,7 +1887,7 @@ nfsd_racache_init(int cache_size)
    raparm_hash[i].pb_head = NULL;
    spin_lock_init(&raparm_hash[i].pb_lock);
    }
    - nperbucket = cache_size >> RAPARM_HASH_BITS;
    + nperbucket = DIV_ROUND_UP(cache_size, RAPARM_HASH_SIZE);
    for (i = 0; i < cache_size - 1; i++) {
    if (i % nperbucket == 0)
    raparm_hash[j++].pb_head = raparml + i;
    diff --git a/fs/splice.c b/fs/splice.c
    index 2fca6eb..b657217 100644
    --- a/fs/splice.c
    +++ b/fs/splice.c
    @@ -614,7 +614,7 @@ find_page:
    ret = add_to_page_cache_lru(page, mapping, index,
    GFP_KERNEL);
    if (unlikely(ret))
    - goto out;
    + goto out_release;
    }

    /*
    @@ -695,8 +695,9 @@ find_page:
    goto find_page;
    }
    out:
    - page_cache_release(page);
    unlock_page(page);
    +out_release:
    + page_cache_release(page);
    out_ret:
    return ret;
    }
    diff --git a/include/linux/Kbuild b/include/linux/Kbuild
    index 157db77..199fd71 100644
    --- a/include/linux/Kbuild
    +++ b/include/linux/Kbuild
    @@ -134,6 +134,7 @@ header-y += radeonfb.h
    header-y += raw.h
    header-y += resource.h
    header-y += rose.h
    +header-y += serial_reg.h
    header-y += smbno.h
    header-y += snmp.h
    header-y += sockios.h
    diff --git a/include/linux/netfilter_ipv4/ipt_iprange.h b/include/linux/netfilter_ipv4/ipt_iprange.h
    index 34ab0fb..a92fefc 100644
    --- a/include/linux/netfilter_ipv4/ipt_iprange.h
    +++ b/include/linux/netfilter_ipv4/ipt_iprange.h
    @@ -1,6 +1,8 @@
    #ifndef _IPT_IPRANGE_H
    #define _IPT_IPRANGE_H

    +#include <linux/types.h>
    +
    #define IPRANGE_SRC 0x01 /* Match source IP address */
    #define IPRANGE_DST 0x02 /* Match destination IP address */
    #define IPRANGE_SRC_INV 0x10 /* Negate the condition */
    diff --git a/include/net/bluetooth/rfcomm.h b/include/net/bluetooth/rfcomm.h
    index 3c563f0..25aa575 100644
    --- a/include/net/bluetooth/rfcomm.h
    +++ b/include/net/bluetooth/rfcomm.h
    @@ -323,6 +323,7 @@ int rfcomm_connect_ind(struct rfcomm_session *s, u8 channel, struct rfcomm_dlc
    #define RFCOMM_RELEASE_ONHUP 1
    #define RFCOMM_HANGUP_NOW 2
    #define RFCOMM_TTY_ATTACHED 3
    +#define RFCOMM_TTY_RELEASED 4

    struct rfcomm_dev_req {
    s16 dev_id;
    diff --git a/include/net/xfrm.h b/include/net/xfrm.h
    index e476541..4fc943b 100644
    --- a/include/net/xfrm.h
    +++ b/include/net/xfrm.h
    @@ -561,7 +561,6 @@ static inline int xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ct
    struct xfrm_dst
    {
    union {
    - struct xfrm_dst *next;
    struct dst_entry dst;
    struct rtable rt;
    struct rt6_info rt6;
    diff --git a/ipc/shm.c b/ipc/shm.c
    index f8e10a2..10b7a2c 100644
    --- a/ipc/shm.c
    +++ b/ipc/shm.c
    @@ -652,7 +652,7 @@ asmlinkage long sys_shmctl (int shmid, int cmd, struct shmid_ds __user *buf)
    struct user_struct * user = current->user;
    if (!is_file_hugepages(shp->shm_file)) {
    err = shmem_lock(shp->shm_file, 1, user);
    - if (!err) {
    + if (!err && !(shp->shm_perm.mode & SHM_LOCKED)){
    shp->shm_perm.mode |= SHM_LOCKED;
    shp->mlock_user = user;
    }
    diff --git a/kernel/lockdep_proc.c b/kernel/lockdep_proc.c
    index b554b40..d787db5 100644
    --- a/kernel/lockdep_proc.c
    +++ b/kernel/lockdep_proc.c
    @@ -323,7 +323,7 @@ static const struct file_operations proc_lockdep_stats_operations = {
    .open = lockdep_stats_open,
    .read = seq_read,
    .llseek = seq_lseek,
    - .release = seq_release,
    + .release = single_release,
    };

    static int __init lockdep_proc_init(void)
    diff --git a/mm/hugetlb.c b/mm/hugetlb.c
    index 36db012..7c07eb2 100644
    --- a/mm/hugetlb.c
    +++ b/mm/hugetlb.c
    @@ -101,13 +101,20 @@ static void free_huge_page(struct page *page)

    static int alloc_fresh_huge_page(void)
    {
    - static int nid = 0;
    + static int prev_nid;
    struct page *page;
    - page = alloc_pages_node(nid, GFP_HIGHUSER|__GFP_COMP|__GFP_NOWARN,
    - HUGETLB_PAGE_ORDER);
    - nid = next_node(nid, node_online_map);
    + static DEFINE_SPINLOCK(nid_lock);
    + int nid;
    +
    + spin_lock(&nid_lock);
    + nid = next_node(prev_nid, node_online_map);
    if (nid == MAX_NUMNODES)
    nid = first_node(node_online_map);
    + prev_nid = nid;
    + spin_unlock(&nid_lock);
    +
    + page = alloc_pages_node(nid, GFP_HIGHUSER|__GFP_COMP|__GFP_NOWARN,
    + HUGETLB_PAGE_ORDER);
    if (page) {
    set_compound_page_dtor(page, free_huge_page);
    spin_lock(&hugetlb_lock);
    diff --git a/mm/mlock.c b/mm/mlock.c
    index 3446b7e..ef8fc94 100644
    --- a/mm/mlock.c
    +++ b/mm/mlock.c
    @@ -233,9 +233,12 @@ int user_shm_lock(size_t size, struct user_struct *user)

    locked = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
    lock_limit = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur;
    + if (lock_limit == RLIM_INFINITY)
    + allowed = 1;
    lock_limit >>= PAGE_SHIFT;
    spin_lock(&shmlock_user_lock);
    - if (locked + user->locked_shm > lock_limit && !capable(CAP_IPC_LOCK))
    + if (!allowed &&
    + locked + user->locked_shm > lock_limit && !capable(CAP_IPC_LOCK))
    goto out;
    get_uid(user);
    user->locked_shm += locked;
    diff --git a/mm/readahead.c b/mm/readahead.c
    index 0f539e8..f26cdea 100644
    --- a/mm/readahead.c
    +++ b/mm/readahead.c
    @@ -21,8 +21,16 @@ void default_unplug_io_fn(struct backing_dev_info *bdi, struct page *page)
    }
    EXPORT_SYMBOL(default_unplug_io_fn);

    +/*
    + * Convienent macros for min/max read-ahead pages.
    + * Note that MAX_RA_PAGES is rounded down, while MIN_RA_PAGES is rounded up.
    + * The latter is necessary for systems with large page size(i.e. 64k).
    + */
    +#define MAX_RA_PAGES (VM_MAX_READAHEAD*1024 / PAGE_CACHE_SIZE)
    +#define MIN_RA_PAGES DIV_ROUND_UP(VM_MIN_READAHEAD*1024, PAGE_CACHE_SIZE)
    +
    struct backing_dev_info default_backing_dev_info = {
    - .ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE,
    + .ra_pages = MAX_RA_PAGES,
    .state = 0,
    .capabilities = BDI_CAP_MAP_COPY,
    .unplug_io_fn = default_unplug_io_fn,
    @@ -51,7 +59,7 @@ static inline unsigned long get_max_readahead(struct file_ra_state *ra)

    static inline unsigned long get_min_readahead(struct file_ra_state *ra)
    {
    - return (VM_MIN_READAHEAD * 1024) / PAGE_CACHE_SIZE;
    + return MIN_RA_PAGES;
    }

    static inline void reset_ahead_window(struct file_ra_state *ra)
    diff --git a/net/bluetooth/rfcomm/tty.c b/net/bluetooth/rfcomm/tty.c
    index eb2b524..26e8c02 100644
    --- a/net/bluetooth/rfcomm/tty.c
    +++ b/net/bluetooth/rfcomm/tty.c
    @@ -93,6 +93,10 @@ static void rfcomm_dev_destruct(struct rfcomm_dev *dev)

    BT_DBG("dev %p dlc %p", dev, dlc);

    + write_lock_bh(&rfcomm_dev_lock);
    + list_del_init(&dev->list);
    + write_unlock_bh(&rfcomm_dev_lock);
    +
    rfcomm_dlc_lock(dlc);
    /* Detach DLC if it's owned by this dev */
    if (dlc->owner == dev)
    @@ -154,8 +158,13 @@ static inline struct rfcomm_dev *rfcomm_dev_get(int id)
    read_lock(&rfcomm_dev_lock);

    dev = __rfcomm_dev_get(id);
    - if (dev)
    - rfcomm_dev_hold(dev);
    +
    + if (dev) {
    + if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
    + dev = NULL;
    + else
    + rfcomm_dev_hold(dev);
    + }

    read_unlock(&rfcomm_dev_lock);

    @@ -263,6 +272,12 @@ out:

    tty_register_device(rfcomm_tty_driver, dev->id, rfcomm_get_device(dev));

    + if (IS_ERR(dev->tty_dev)) {
    + list_del(&dev->list);
    + kfree(dev);
    + return PTR_ERR(dev->tty_dev);
    + }
    +
    return dev->id;
    }

    @@ -270,10 +285,7 @@ static void rfcomm_dev_del(struct rfcomm_dev *dev)
    {
    BT_DBG("dev %p", dev);

    - write_lock_bh(&rfcomm_dev_lock);
    - list_del_init(&dev->list);
    - write_unlock_bh(&rfcomm_dev_lock);
    -
    + set_bit(RFCOMM_TTY_RELEASED, &dev->flags);
    rfcomm_dev_put(dev);
    }

    @@ -327,7 +339,7 @@ static int rfcomm_create_dev(struct sock *sk, void __user *arg)
    if (copy_from_user(&req, arg, sizeof(req)))
    return -EFAULT;

    - BT_DBG("sk %p dev_id %id flags 0x%x", sk, req.dev_id, req.flags);
    + BT_DBG("sk %p dev_id %d flags 0x%x", sk, req.dev_id, req.flags);

    if (req.flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN))
    return -EPERM;
    @@ -368,7 +380,7 @@ static int rfcomm_release_dev(void __user *arg)
    if (copy_from_user(&req, arg, sizeof(req)))
    return -EFAULT;

    - BT_DBG("dev_id %id flags 0x%x", req.dev_id, req.flags);
    + BT_DBG("dev_id %d flags 0x%x", req.dev_id, req.flags);

    if (!(dev = rfcomm_dev_get(req.dev_id)))
    return -ENODEV;
    @@ -381,6 +393,10 @@ static int rfcomm_release_dev(void __user *arg)
    if (req.flags & (1 << RFCOMM_HANGUP_NOW))
    rfcomm_dlc_close(dev->dlc, 0);

    + /* Shut down TTY synchronously before freeing rfcomm_dev */
    + if (dev->tty)
    + tty_vhangup(dev->tty);
    +
    rfcomm_dev_del(dev);
    rfcomm_dev_put(dev);
    return 0;
    @@ -413,6 +429,8 @@ static int rfcomm_get_dev_list(void __user *arg)

    list_for_each(p, &rfcomm_dev_list) {
    struct rfcomm_dev *dev = list_entry(p, struct rfcomm_dev, list);
    + if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
    + continue;
    (di + n)->id = dev->id;
    (di + n)->flags = dev->flags;
    (di + n)->state = dev->dlc->state;
    diff --git a/net/core/gen_estimator.c b/net/core/gen_estimator.c
    index 3cad026..acc1ee0 100644
    --- a/net/core/gen_estimator.c
    +++ b/net/core/gen_estimator.c
    @@ -79,27 +79,27 @@

    struct gen_estimator
    {
    - struct gen_estimator *next;
    + struct list_head list;
    struct gnet_stats_basic *bstats;
    struct gnet_stats_rate_est *rate_est;
    spinlock_t *stats_lock;
    - unsigned interval;
    int ewma_log;
    u64 last_bytes;
    u32 last_packets;
    u32 avpps;
    u32 avbps;
    + struct rcu_head e_rcu;
    };

    struct gen_estimator_head
    {
    struct timer_list timer;
    - struct gen_estimator *list;
    + struct list_head list;
    };

    static struct gen_estimator_head elist[EST_MAX_INTERVAL+1];

    -/* Estimator array lock */
    +/* Protects against NULL dereference */
    static DEFINE_RWLOCK(est_lock);

    static void est_timer(unsigned long arg)
    @@ -107,13 +107,17 @@ static void est_timer(unsigned long arg)
    int idx = (int)arg;
    struct gen_estimator *e;

    - read_lock(&est_lock);
    - for (e = elist[idx].list; e; e = e->next) {
    + rcu_read_lock();
    + list_for_each_entry_rcu(e, &elist[idx].list, list) {
    u64 nbytes;
    u32 npackets;
    u32 rate;

    spin_lock(e->stats_lock);
    + read_lock(&est_lock);
    + if (e->bstats == NULL)
    + goto skip;
    +
    nbytes = e->bstats->bytes;
    npackets = e->bstats->packets;
    rate = (nbytes - e->last_bytes)<<(7 - idx);
    @@ -125,11 +129,14 @@ static void est_timer(unsigned long arg)
    e->last_packets = npackets;
    e->avpps += ((long)rate - (long)e->avpps) >> e->ewma_log;
    e->rate_est->pps = (e->avpps+0x1FF)>>10;
    +skip:
    + read_unlock(&est_lock);
    spin_unlock(e->stats_lock);
    }

    - mod_timer(&elist[idx].timer, jiffies + ((HZ<<idx)/4));
    - read_unlock(&est_lock);
    + if (!list_empty(&elist[idx].list))
    + mod_timer(&elist[idx].timer, jiffies + ((HZ<<idx)/4));
    + rcu_read_unlock();
    }

    /**
    @@ -146,12 +153,17 @@ static void est_timer(unsigned long arg)
    * &rate_est with the statistics lock grabed during this period.
    *
    * Returns 0 on success or a negative error code.
    + *
    + * NOTE: Called under rtnl_mutex
    */
    int gen_new_estimator(struct gnet_stats_basic *bstats,
    - struct gnet_stats_rate_est *rate_est, spinlock_t *stats_lock, struct rtattr *opt)
    + struct gnet_stats_rate_est *rate_est,
    + spinlock_t *stats_lock,
    + struct rtattr *opt)
    {
    struct gen_estimator *est;
    struct gnet_estimator *parm = RTA_DATA(opt);
    + int idx;

    if (RTA_PAYLOAD(opt) < sizeof(*parm))
    return -EINVAL;
    @@ -163,7 +175,7 @@ int gen_new_estimator(struct gnet_stats_basic *bstats,
    if (est == NULL)
    return -ENOBUFS;

    - est->interval = parm->interval + 2;
    + idx = parm->interval + 2;
    est->bstats = bstats;
    est->rate_est = rate_est;
    est->stats_lock = stats_lock;
    @@ -173,20 +185,25 @@ int gen_new_estimator(struct gnet_stats_basic *bstats,
    est->last_packets = bstats->packets;
    est->avpps = rate_est->pps<<10;

    - est->next = elist[est->interval].list;
    - if (est->next == NULL) {
    - init_timer(&elist[est->interval].timer);
    - elist[est->interval].timer.data = est->interval;
    - elist[est->interval].timer.expires = jiffies + ((HZ<<est->interval)/4);
    - elist[est->interval].timer.function = est_timer;
    - add_timer(&elist[est->interval].timer);
    + if (!elist[idx].timer.function) {
    + INIT_LIST_HEAD(&elist[idx].list);
    + setup_timer(&elist[idx].timer, est_timer, idx);
    }
    - write_lock_bh(&est_lock);
    - elist[est->interval].list = est;
    - write_unlock_bh(&est_lock);
    +
    + if (list_empty(&elist[idx].list))
    + mod_timer(&elist[idx].timer, jiffies + ((HZ<<idx)/4));
    +
    + list_add_rcu(&est->list, &elist[idx].list);
    return 0;
    }

    +static void __gen_kill_estimator(struct rcu_head *head)
    +{
    + struct gen_estimator *e = container_of(head,
    + struct gen_estimator, e_rcu);
    + kfree(e);
    +}
    +
    /**
    * gen_kill_estimator - remove a rate estimator
    * @bstats: basic statistics
    @@ -194,31 +211,32 @@ int gen_new_estimator(struct gnet_stats_basic *bstats,
    *
    * Removes the rate estimator specified by &bstats and &rate_est
    * and deletes the timer.
    + *
    + * NOTE: Called under rtnl_mutex
    */
    void gen_kill_estimator(struct gnet_stats_basic *bstats,
    struct gnet_stats_rate_est *rate_est)
    {
    int idx;
    - struct gen_estimator *est, **pest;
    + struct gen_estimator *e, *n;

    for (idx=0; idx <= EST_MAX_INTERVAL; idx++) {
    - int killed = 0;
    - pest = &elist[idx].list;
    - while ((est=*pest) != NULL) {
    - if (est->rate_est != rate_est || est->bstats != bstats) {
    - pest = &est->next;
    +
    + /* Skip non initialized indexes */
    + if (!elist[idx].timer.function)
    + continue;
    +
    + list_for_each_entry_safe(e, n, &elist[idx].list, list) {
    + if (e->rate_est != rate_est || e->bstats != bstats)
    continue;
    - }

    write_lock_bh(&est_lock);
    - *pest = est->next;
    + e->bstats = NULL;
    write_unlock_bh(&est_lock);

    - kfree(est);
    - killed++;
    + list_del_rcu(&e->list);
    + call_rcu(&e->e_rcu, __gen_kill_estimator);
    }
    - if (killed && elist[idx].list == NULL)
    - del_timer(&elist[idx].timer);
    }
    }

    diff --git a/net/core/netpoll.c b/net/core/netpoll.c
    index 522e441..3431d48 100644
    --- a/net/core/netpoll.c
    +++ b/net/core/netpoll.c
    @@ -776,7 +776,6 @@ void netpoll_cleanup(struct netpoll *np)
    spin_unlock_irqrestore(&npinfo->rx_lock, flags);
    }

    - np->dev->npinfo = NULL;
    if (atomic_dec_and_test(&npinfo->refcnt)) {
    skb_queue_purge(&npinfo->arp_tx);
    skb_queue_purge(&npinfo->txq);
    @@ -784,6 +783,7 @@ void netpoll_cleanup(struct netpoll *np)
    flush_scheduled_work();

    kfree(npinfo);
    + np->dev->npinfo = NULL;
    }
    }

    diff --git a/net/ieee80211/softmac/ieee80211softmac_assoc.c b/net/ieee80211/softmac/ieee80211softmac_assoc.c
    index a824852..dadb65c 100644
    --- a/net/ieee80211/softmac/ieee80211softmac_assoc.c
    +++ b/net/ieee80211/softmac/ieee80211softmac_assoc.c
    @@ -271,8 +271,11 @@ ieee80211softmac_assoc_work(struct work_struct *work)
    */
    dprintk(KERN_INFO PFX "Associate: Scanning for networks first.\n");
    ieee80211softmac_notify(mac->dev, IEEE80211SOFTMAC_EVENT_SCAN_FINISHED, ieee80211softmac_assoc_notify_scan, NULL);
    - if (ieee80211softmac_start_scan(mac))
    + if (ieee80211softmac_start_scan(mac)) {
    dprintk(KERN_INFO PFX "Associate: failed to initiate scan. Is device up?\n");
    + mac->associnfo.associating = 0;
    + mac->associnfo.associated = 0;
    + }
    goto out;
    } else {
    mac->associnfo.associating = 0;
    diff --git a/net/ieee80211/softmac/ieee80211softmac_wx.c b/net/ieee80211/softmac/ieee80211softmac_wx.c
    index fb58e03..c3c39ed 100644
    --- a/net/ieee80211/softmac/ieee80211softmac_wx.c
    +++ b/net/ieee80211/softmac/ieee80211softmac_wx.c
    @@ -74,8 +74,8 @@ ieee80211softmac_wx_set_essid(struct net_device *net_dev,
    struct ieee80211softmac_auth_queue_item *authptr;
    int length = 0;

    +check_assoc_again:
    mutex_lock(&sm->associnfo.mutex);
    -
    /* Check if we're already associating to this or another network
    * If it's another network, cancel and start over with our new network
    * If it's our network, ignore the change, we're already doing it!
    @@ -98,13 +98,18 @@ ieee80211softmac_wx_set_essid(struct net_device *net_dev,
    cancel_delayed_work(&authptr->work);
    sm->associnfo.bssvalid = 0;
    sm->associnfo.bssfixed = 0;
    - flush_scheduled_work();
    sm->associnfo.associating = 0;
    sm->associnfo.associated = 0;
    + /* We must unlock to avoid deadlocks with the assoc workqueue
    + * on the associnfo.mutex */
    + mutex_unlock(&sm->associnfo.mutex);
    + flush_scheduled_work();
    + /* Avoid race! Check assoc status again. Maybe someone started an
    + * association while we flushed. */
    + goto check_assoc_again;
    }
    }

    -
    sm->associnfo.static_essid = 0;
    sm->associnfo.assoc_wait = 0;

    diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c
    index e383ac8..0d21d96 100644
    --- a/net/ipv6/addrconf.c
    +++ b/net/ipv6/addrconf.c
    @@ -2451,6 +2451,7 @@ static int addrconf_ifdown(struct net_device *dev, int how)
    write_unlock_bh(&idev->lock);

    __ipv6_ifa_notify(RTM_DELADDR, ifa);
    + atomic_notifier_call_chain(&inet6addr_chain, NETDEV_DOWN, ifa);
    in6_ifa_put(ifa);

    write_lock_bh(&idev->lock);
    diff --git a/net/ipv6/anycast.c b/net/ipv6/anycast.c
    index fe0c895..7cf5248 100644
    --- a/net/ipv6/anycast.c
    +++ b/net/ipv6/anycast.c
    @@ -67,6 +67,7 @@ ip6_onlink(struct in6_addr *addr, struct net_device *dev)
    break;
    }
    read_unlock_bh(&idev->lock);
    + in6_dev_put(idev);
    }
    rcu_read_unlock();
    return onlink;
    diff --git a/net/ipv6/icmp.c b/net/ipv6/icmp.c
    index 3dcc4b7..4437a70 100644
    --- a/net/ipv6/icmp.c
    +++ b/net/ipv6/icmp.c
    @@ -600,7 +600,7 @@ static void icmpv6_notify(struct sk_buff *skb, int type, int code, __be32 info)

    read_lock(&raw_v6_lock);
    if ((sk = sk_head(&raw_v6_htable[hash])) != NULL) {
    - while((sk = __raw_v6_lookup(sk, nexthdr, daddr, saddr,
    + while ((sk = __raw_v6_lookup(sk, nexthdr, saddr, daddr,
    IP6CB(skb)->iif))) {
    rawv6_err(sk, skb, NULL, type, code, inner_offset, info);
    sk = sk_next(sk);
    diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
    index a2d41ba..03f53f5 100644
    --- a/net/ipv6/tcp_ipv6.c
    +++ b/net/ipv6/tcp_ipv6.c
    @@ -637,6 +637,7 @@ static int tcp_v6_md5_do_del(struct sock *sk, struct in6_addr *peer)
    if (tp->md5sig_info->entries6 == 0) {
    kfree(tp->md5sig_info->keys6);
    tp->md5sig_info->keys6 = NULL;
    + tp->md5sig_info->alloced6 = 0;

    tcp_free_md5sig_pool();

    diff --git a/net/sctp/ipv6.c b/net/sctp/ipv6.c
    index ef36be0..c00c73c 100644
    --- a/net/sctp/ipv6.c
    +++ b/net/sctp/ipv6.c
    @@ -874,6 +874,10 @@ static int sctp_inet6_send_verify(struct sctp_sock *opt, union sctp_addr *addr)
    dev = dev_get_by_index(addr->v6.sin6_scope_id);
    if (!dev)
    return 0;
    + if (!ipv6_chk_addr(&addr->v6.sin6_addr, dev, 0)) {
    + dev_put(dev);
    + return 0;
    + }
    dev_put(dev);
    }
    af = opt->pf->af;
    diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c
    index 066c64a..6179767 100644
    --- a/net/sunrpc/auth_gss/svcauth_gss.c
    +++ b/net/sunrpc/auth_gss/svcauth_gss.c
    @@ -760,11 +760,12 @@ svcauth_gss_register_pseudoflavor(u32 pseudoflavor, char * name)
    new->h.flavour = &svcauthops_gss;
    new->pseudoflavor = pseudoflavor;

    + stat = 0;
    test = auth_domain_lookup(name, &new->h);
    - if (test != &new->h) { /* XXX Duplicate registration? */
    - auth_domain_put(&new->h);
    - /* dangling ref-count... */
    - goto out;
    + if (test != &new->h) { /* Duplicate registration */
    + auth_domain_put(test);
    + kfree(new->h.name);
    + goto out_free_dom;
    }
    return 0;

    diff --git a/net/xfrm/xfrm_policy.c b/net/xfrm/xfrm_policy.c
    index 9704e05..c208a8a 100644
    --- a/net/xfrm/xfrm_policy.c
    +++ b/net/xfrm/xfrm_policy.c
    @@ -1971,7 +1971,7 @@ int xfrm_bundle_ok(struct xfrm_policy *pol, struct xfrm_dst *first,
    if (last == first)
    break;

    - last = last->u.next;
    + last = (struct xfrm_dst *)last->u.dst.next;
    last->child_mtu_cached = mtu;
    }

    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/
    \
     
     \ /
      Last update: 2007-08-25 17:43    [W:0.131 / U:125.344 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site