64 files changed, 703 insertions, 486 deletions

diff --git a/Documentation/filesystems/9p.txt b/Documentation/filesystems/9p.txt
index 43b89c214d20..4d075a4558f9 100644
--- a/Documentation/filesystems/9p.txt
+++ b/Documentation/filesystems/9p.txt
@@ -73,8 +73,22 @@ OPTIONS
 RESOURCES
 =========
 
-The Linux version of the 9p server is now maintained under the npfs project
-on sourceforge (http://sourceforge.net/projects/npfs).
+Our current recommendation is to use Inferno (http://www.vitanuova.com/inferno)
+as the 9p server.  You can start a 9p server under Inferno by issuing the
+following command:
+   ; styxlisten -A tcp!*!564 export '#U*'
+
+The -A specifies an unauthenticated export.  The 564 is the port # (you may
+have to choose a higher port number if running as a normal user).  The '#U*'
+specifies exporting the root of the Linux name space.  You may specify a
+subset of the namespace by extending the path: '#U*'/tmp would just export
+/tmp.  For more information, see the Inferno manual pages covering styxlisten
+and export.
+
+A Linux version of the 9p server is now maintained under the npfs project
+on sourceforge (http://sourceforge.net/projects/npfs).  There is also a
+more stable single-threaded version of the server (named spfs) available from
+the same CVS repository.
 
 There are user and developer mailing lists available through the v9fs project
 on sourceforge (http://sourceforge.net/projects/v9fs).
@@ -96,5 +110,5 @@ STATUS
 
 The 2.6 kernel support is working on PPC and x86.
 
-PLEASE USE THE SOURCEFORGE BUG-TRACKER TO REPORT PROBLEMS.
+PLEASE USE THE KERNEL BUGZILLA TO REPORT PROBLEMS. (http://bugzilla.kernel.org)
 
diff --git a/MAINTAINERS b/MAINTAINERS
index d6f04a81f761..f0596e452c5c 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1137,9 +1137,9 @@ T:	git kernel.org:/pub/scm/linux/kernel/git/airlied/drm-2.6.git
 S:      Maintained
 
 DSCC4 DRIVER
-P:      François Romieu
-M:      romieu@cogenit.fr
-M:      romieu@ensta.fr
+P:      Francois Romieu
+M:      romieu@fr.zoreil.com
+L:      netdev@vger.kernel.org
 S:      Maintained
 
 DVB SUBSYSTEM AND DRIVERS
@@ -1928,11 +1928,10 @@ S:	Maintained
 
 KERNEL NFSD
 P:      Neil Brown
-M:      neilb@cse.unsw.edu.au
+M:      neilb@suse.de
 L:      nfs@lists.sourceforge.net
 W:      http://nfs.sourceforge.net/
-W:      http://www.cse.unsw.edu.au/~neilb/patches/linux-devel/
-S:      Maintained
+S:      Supported
 
 KERNEL VIRTUAL MACHINE (KVM)
 P:      Avi Kivity
@@ -2993,9 +2992,9 @@ SOFTWARE RAID (Multiple Disks) SUPPORT
 P:      Ingo Molnar
 M:      mingo@redhat.com
 P:      Neil Brown
-M:      neilb@cse.unsw.edu.au
+M:      neilb@suse.de
 L:      linux-raid@vger.kernel.org
-S:      Maintained
+S:      Supported
 
 SOFTWARE SUSPEND:
 P:      Pavel Machek
@@ -3575,6 +3574,12 @@ M:	khali@linux-fr.org
 L:      i2c@lm-sensors.org
 S:      Maintained
 
+VIA VELOCITY NETWORK DRIVER
+P:      Francois Romieu
+M:      romieu@fr.zoreil.com
+L:      netdev@vger.kernel.org
+S:      Maintained
+
 UCLINUX (AND M68KNOMMU)
 P:      Greg Ungerer
 M:      gerg@uclinux.org
diff --git a/Makefile b/Makefile
index 477f52e3c7f6..9e1adac8aa28 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
 VERSION = 2
 PATCHLEVEL = 6
 SUBLEVEL = 20
-EXTRAVERSION =-rc5
+EXTRAVERSION =-rc6
 NAME = Homicidal Dwarf Hamster
 
 # *DOCUMENTATION*
diff --git a/arch/i386/kernel/entry.S b/arch/i386/kernel/entry.S
index 06461b8b715d..5e47683fc63a 100644
--- a/arch/i386/kernel/entry.S
+++ b/arch/i386/kernel/entry.S
@@ -302,12 +302,16 @@ sysenter_past_esp:
         pushl $(__USER_CS)
         CFI_ADJUST_CFA_OFFSET 4
         /*CFI_REL_OFFSET cs, 0*/
+#ifndef CONFIG_COMPAT_VDSO
         /*
          * Push current_thread_info()->sysenter_return to the stack.
          * A tiny bit of offset fixup is necessary - 4*4 means the 4 words
          * pushed above; +8 corresponds to copy_thread's esp0 setting.
          */
         pushl (TI_sysenter_return-THREAD_SIZE+8+4*4)(%esp)
+#else
+        pushl $SYSENTER_RETURN
+#endif
         CFI_ADJUST_CFA_OFFSET 4
         CFI_REL_OFFSET eip, 0
 
diff --git a/arch/i386/kernel/sysenter.c b/arch/i386/kernel/sysenter.c
index 7de9117b5a3a..5da744204d10 100644
--- a/arch/i386/kernel/sysenter.c
+++ b/arch/i386/kernel/sysenter.c
@@ -79,11 +79,6 @@ int __init sysenter_setup(void)
 #ifdef CONFIG_COMPAT_VDSO
         __set_fixmap(FIX_VDSO, __pa(syscall_page), PAGE_READONLY);
         printk("Compat vDSO mapped to %08lx.\n", __fix_to_virt(FIX_VDSO));
-#else
-        /*
-         * In the non-compat case the ELF coredumping code needs the fixmap:
-         */
-        __set_fixmap(FIX_VDSO, __pa(syscall_page), PAGE_KERNEL_RO);
 #endif
 
         if (!boot_cpu_has(X86_FEATURE_SEP)) {
@@ -100,6 +95,7 @@ int __init sysenter_setup(void)
         return 0;
 }
 
+#ifndef CONFIG_COMPAT_VDSO
 static struct page *syscall_nopage(struct vm_area_struct *vma,
                                 unsigned long adr, int *type)
 {
@@ -146,6 +142,13 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int exstack)
         vma->vm_end = addr + PAGE_SIZE;
         /* MAYWRITE to allow gdb to COW and set breakpoints */
         vma->vm_flags = VM_READ|VM_EXEC|VM_MAYREAD|VM_MAYEXEC|VM_MAYWRITE;
+        /*
+         * Make sure the vDSO gets into every core dump.
+         * Dumping its contents makes post-mortem fully interpretable later
+         * without matching up the same kernel and hardware config to see
+         * what PC values meant.
+         */
+        vma->vm_flags |= VM_ALWAYSDUMP;
         vma->vm_flags |= mm->def_flags;
         vma->vm_page_prot = protection_map[vma->vm_flags & 7];
         vma->vm_ops = &syscall_vm_ops;
@@ -187,3 +190,4 @@ int in_gate_area_no_task(unsigned long addr)
 {
         return 0;
 }
+#endif
diff --git a/arch/powerpc/kernel/vdso.c b/arch/powerpc/kernel/vdso.c
index a4b28c73bba0..ae0ede19879d 100644
--- a/arch/powerpc/kernel/vdso.c
+++ b/arch/powerpc/kernel/vdso.c
@@ -284,6 +284,13 @@ int arch_setup_additional_pages(struct linux_binprm *bprm,
          * pages though
          */
         vma->vm_flags = VM_READ|VM_EXEC|VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC;
+        /*
+         * Make sure the vDSO gets into every core dump.
+         * Dumping its contents makes post-mortem fully interpretable later
+         * without matching up the same kernel and hardware config to see
+         * what PC values meant.
+         */
+        vma->vm_flags |= VM_ALWAYSDUMP;
         vma->vm_flags |= mm->def_flags;
         vma->vm_page_prot = protection_map[vma->vm_flags & 0x7];
         vma->vm_ops = &vdso_vmops;
diff --git a/arch/um/Kconfig.i386 b/arch/um/Kconfig.i386
index f191a550a079..77558a88a2fe 100644
--- a/arch/um/Kconfig.i386
+++ b/arch/um/Kconfig.i386
@@ -19,22 +19,22 @@ config SEMAPHORE_SLEEPERS
 choice
         prompt "Host memory split"
         default HOST_VMSPLIT_3G
-        ---help---
-           This is needed when the host kernel on which you run has a non-default
-           (like 2G/2G) memory split, instead of the customary 3G/1G. If you did
-           not recompile your own kernel but use the default distro's one, you can
-           safely accept the "Default split" option.
+        help
+        This is needed when the host kernel on which you run has a non-default
+        (like 2G/2G) memory split, instead of the customary 3G/1G. If you did
+        not recompile your own kernel but use the default distro's one, you can
+        safely accept the "Default split" option.
 
-           It can be enabled on recent (>=2.6.16-rc2) vanilla kernels via
-           CONFIG_VM_SPLIT_*, or on previous kernels with special patches (-ck
-           patchset by Con Kolivas, or other ones) - option names match closely the
-           host CONFIG_VM_SPLIT_* ones.
+        It can be enabled on recent (>=2.6.16-rc2) vanilla kernels via
+        CONFIG_VM_SPLIT_*, or on previous kernels with special patches (-ck
+        patchset by Con Kolivas, or other ones) - option names match closely the
+        host CONFIG_VM_SPLIT_* ones.
 
-           A lower setting (where 1G/3G is lowest and 3G/1G is higher) will
-           tolerate even more "normal" host kernels, but an higher setting will be
-           stricter.
+        A lower setting (where 1G/3G is lowest and 3G/1G is higher) will
+        tolerate even more "normal" host kernels, but an higher setting will be
+        stricter.
 
-           So, if you do not know what to do here, say 'Default split'.
+        So, if you do not know what to do here, say 'Default split'.
 
         config HOST_VMSPLIT_3G
                 bool "Default split (3G/1G user/kernel host split)"
@@ -67,13 +67,13 @@ config 3_LEVEL_PGTABLES
 
 config STUB_CODE
         hex
-        default 0xbfffe000 if !HOST_2G_2G
-        default 0x7fffe000 if HOST_2G_2G
+        default 0xbfffe000 if !HOST_VMSPLIT_2G
+        default 0x7fffe000 if HOST_VMSPLIT_2G
 
 config STUB_DATA
         hex
-        default 0xbffff000 if !HOST_2G_2G
-        default 0x7ffff000 if HOST_2G_2G
+        default 0xbffff000 if !HOST_VMSPLIT_2G
+        default 0x7ffff000 if HOST_VMSPLIT_2G
 
 config STUB_START
         hex
diff --git a/arch/x86_64/ia32/ia32_binfmt.c b/arch/x86_64/ia32/ia32_binfmt.c
index 543ef4f405e9..5ce0bd486bbf 100644
--- a/arch/x86_64/ia32/ia32_binfmt.c
+++ b/arch/x86_64/ia32/ia32_binfmt.c
@@ -64,55 +64,6 @@ typedef unsigned int elf_greg_t;
 #define ELF_NGREG (sizeof (struct user_regs_struct32) / sizeof(elf_greg_t))
 typedef elf_greg_t elf_gregset_t[ELF_NGREG];
 
-/*
- * These macros parameterize elf_core_dump in fs/binfmt_elf.c to write out
- * extra segments containing the vsyscall DSO contents.  Dumping its
- * contents makes post-mortem fully interpretable later without matching up
- * the same kernel and hardware config to see what PC values meant.
- * Dumping its extra ELF program headers includes all the other information
- * a debugger needs to easily find how the vsyscall DSO was being used.
- */
-#define ELF_CORE_EXTRA_PHDRS    (find_vma(current->mm, VSYSCALL32_BASE) ?     \
-    (VSYSCALL32_EHDR->e_phnum) : 0)
-#define ELF_CORE_WRITE_EXTRA_PHDRS                                            \
-do {                                                                          \
-        if (find_vma(current->mm, VSYSCALL32_BASE)) {                         \
-                const struct elf32_phdr *const vsyscall_phdrs =               \
-                        (const struct elf32_phdr *) (VSYSCALL32_BASE          \
-                                                   + VSYSCALL32_EHDR->e_phoff);\
-                int i;                                                        \
-                Elf32_Off ofs = 0;                                            \
-                for (i = 0; i < VSYSCALL32_EHDR->e_phnum; ++i) {              \
-                        struct elf32_phdr phdr = vsyscall_phdrs[i];           \
-                        if (phdr.p_type == PT_LOAD) {                         \
-                                BUG_ON(ofs != 0);                             \
-                                ofs = phdr.p_offset = offset;                 \
-                                phdr.p_memsz = PAGE_ALIGN(phdr.p_memsz);      \
-                                phdr.p_filesz = phdr.p_memsz;                 \
-                                offset += phdr.p_filesz;                      \
-                        }                                                     \
-                        else                                                  \
-                                phdr.p_offset += ofs;                         \
-                        phdr.p_paddr = 0; /* match other core phdrs */        \
-                        DUMP_WRITE(&phdr, sizeof(phdr));                      \
-                }                                                             \
-        }                                                                     \
-} while (0)
-#define ELF_CORE_WRITE_EXTRA_DATA                                             \
-do {                                                                          \
-        if (find_vma(current->mm, VSYSCALL32_BASE)) {                         \
-                const struct elf32_phdr *const vsyscall_phdrs =               \
-                        (const struct elf32_phdr *) (VSYSCALL32_BASE          \
-                                                   + VSYSCALL32_EHDR->e_phoff);      \
-                int i;                                                        \
-                for (i = 0; i < VSYSCALL32_EHDR->e_phnum; ++i) {              \
-                        if (vsyscall_phdrs[i].p_type == PT_LOAD)              \
-                                DUMP_WRITE((void *) (u64) vsyscall_phdrs[i].p_vaddr,\
-                                    PAGE_ALIGN(vsyscall_phdrs[i].p_memsz));   \
-                }                                                             \
-        }                                                                     \
-} while (0)
-
 struct elf_siginfo
 {
         int     si_signo;                       /* signal number */
diff --git a/arch/x86_64/ia32/syscall32.c b/arch/x86_64/ia32/syscall32.c
index 3e5ed20cba45..59f1fa155915 100644
--- a/arch/x86_64/ia32/syscall32.c
+++ b/arch/x86_64/ia32/syscall32.c
@@ -59,6 +59,13 @@ int syscall32_setup_pages(struct linux_binprm *bprm, int exstack)
         vma->vm_end = VSYSCALL32_END;
         /* MAYWRITE to allow gdb to COW and set breakpoints */
         vma->vm_flags = VM_READ|VM_EXEC|VM_MAYREAD|VM_MAYEXEC|VM_MAYWRITE;
+        /*
+         * Make sure the vDSO gets into every core dump.
+         * Dumping its contents makes post-mortem fully interpretable later
+         * without matching up the same kernel and hardware config to see
+         * what PC values meant.
+         */
+        vma->vm_flags |= VM_ALWAYSDUMP;
         vma->vm_flags |= mm->def_flags;
         vma->vm_page_prot = protection_map[vma->vm_flags & 7];
         vma->vm_ops = &syscall32_vm_ops;
@@ -75,6 +82,14 @@ int syscall32_setup_pages(struct linux_binprm *bprm, int exstack)
         return 0;
 }
 
+const char *arch_vma_name(struct vm_area_struct *vma)
+{
+        if (vma->vm_start == VSYSCALL32_BASE &&
+            vma->vm_mm && vma->vm_mm->task_size == IA32_PAGE_OFFSET)
+                return "[vdso]";
+        return NULL;
+}
+
 static int __init init_syscall32(void)
 { 
         syscall32_page = (void *)get_zeroed_page(GFP_KERNEL); 
diff --git a/drivers/acpi/processor_perflib.c b/drivers/acpi/processor_perflib.c
index 5207f9e4b443..cbb6f0814ce2 100644
--- a/drivers/acpi/processor_perflib.c
+++ b/drivers/acpi/processor_perflib.c
@@ -322,10 +322,6 @@ static int acpi_processor_get_performance_info(struct acpi_processor *pr)
         if (result)
                 return result;
 
-        result = acpi_processor_get_platform_limit(pr);
-        if (result)
-                return result;
-
         return 0;
 }
 
diff --git a/drivers/firmware/efivars.c b/drivers/firmware/efivars.c
index 5ab5e393b882..c6281ccd4fe7 100644
--- a/drivers/firmware/efivars.c
+++ b/drivers/firmware/efivars.c
@@ -122,8 +122,6 @@ struct efivar_entry {
         struct kobject kobj;
 };
 
-#define get_efivar_entry(n) list_entry(n, struct efivar_entry, list)
-
 struct efivar_attribute {
         struct attribute attr;
         ssize_t (*show) (struct efivar_entry *entry, char *buf);
@@ -386,9 +384,6 @@ static struct sysfs_ops efivar_attr_ops = {
 static void efivar_release(struct kobject *kobj)
 {
         struct efivar_entry *var = container_of(kobj, struct efivar_entry, kobj);
-        spin_lock(&efivars_lock);
-        list_del(&var->list);
-        spin_unlock(&efivars_lock);
         kfree(var);
 }
 
@@ -430,9 +425,8 @@ static ssize_t
 efivar_create(struct subsystem *sub, const char *buf, size_t count)
 {
         struct efi_variable *new_var = (struct efi_variable *)buf;
-        struct efivar_entry *search_efivar = NULL;
+        struct efivar_entry *search_efivar, *n;
         unsigned long strsize1, strsize2;
-        struct list_head *pos, *n;
         efi_status_t status = EFI_NOT_FOUND;
         int found = 0;
 
@@ -444,8 +438,7 @@ efivar_create(struct subsystem *sub, const char *buf, size_t count)
         /*
          * Does this variable already exist?
          */
-        list_for_each_safe(pos, n, &efivar_list) {
-                search_efivar = get_efivar_entry(pos);
+        list_for_each_entry_safe(search_efivar, n, &efivar_list, list) {
                 strsize1 = utf8_strsize(search_efivar->var.VariableName, 1024);
                 strsize2 = utf8_strsize(new_var->VariableName, 1024);
                 if (strsize1 == strsize2 &&
@@ -490,9 +483,8 @@ static ssize_t
 efivar_delete(struct subsystem *sub, const char *buf, size_t count)
 {
         struct efi_variable *del_var = (struct efi_variable *)buf;
-        struct efivar_entry *search_efivar = NULL;
+        struct efivar_entry *search_efivar, *n;
         unsigned long strsize1, strsize2;
-        struct list_head *pos, *n;
         efi_status_t status = EFI_NOT_FOUND;
         int found = 0;
 
@@ -504,8 +496,7 @@ efivar_delete(struct subsystem *sub, const char *buf, size_t count)
         /*
          * Does this variable already exist?
          */
-        list_for_each_safe(pos, n, &efivar_list) {
-                search_efivar = get_efivar_entry(pos);
+        list_for_each_entry_safe(search_efivar, n, &efivar_list, list) {
                 strsize1 = utf8_strsize(search_efivar->var.VariableName, 1024);
                 strsize2 = utf8_strsize(del_var->VariableName, 1024);
                 if (strsize1 == strsize2 &&
@@ -537,9 +528,9 @@ efivar_delete(struct subsystem *sub, const char *buf, size_t count)
                 spin_unlock(&efivars_lock);
                 return -EIO;
         }
+        list_del(&search_efivar->list);
         /* We need to release this lock before unregistering. */
         spin_unlock(&efivars_lock);
-
         efivar_unregister(search_efivar);
 
         /* It's dead Jim.... */
@@ -768,10 +759,14 @@ out_free:
 static void __exit
 efivars_exit(void)
 {
-        struct list_head *pos, *n;
+        struct efivar_entry *entry, *n;
 
-        list_for_each_safe(pos, n, &efivar_list)
-                efivar_unregister(get_efivar_entry(pos));
+        list_for_each_entry_safe(entry, n, &efivar_list, list) {
+                spin_lock(&efivars_lock);
+                list_del(&entry->list);
+                spin_unlock(&efivars_lock);
+                efivar_unregister(entry);
+        }
 
         subsystem_unregister(&vars_subsys);
         firmware_unregister(&efi_subsys);
diff --git a/drivers/isdn/gigaset/common.c b/drivers/isdn/gigaset/common.c
index 95eff3b2917a..4f75cce6fdff 100644
--- a/drivers/isdn/gigaset/common.c
+++ b/drivers/isdn/gigaset/common.c
@@ -356,16 +356,17 @@ static struct cardstate *alloc_cs(struct gigaset_driver *drv)
 {
         unsigned long flags;
         unsigned i;
-        static struct cardstate *ret = NULL;
+        struct cardstate *ret = NULL;
 
         spin_lock_irqsave(&drv->lock, flags);
         for (i = 0; i < drv->minors; ++i) {
                 if (!(drv->flags[i] & VALID_MINOR)) {
-                        drv->flags[i] = VALID_MINOR;
-                        ret = drv->cs + i;
-                }
-                if (ret)
+                        if (try_module_get(drv->owner)) {
+                                drv->flags[i] = VALID_MINOR;
+                                ret = drv->cs + i;
+                        }
                         break;
+                }
         }
         spin_unlock_irqrestore(&drv->lock, flags);
         return ret;
@@ -376,6 +377,8 @@ static void free_cs(struct cardstate *cs)
         unsigned long flags;
         struct gigaset_driver *drv = cs->driver;
         spin_lock_irqsave(&drv->lock, flags);
+        if (drv->flags[cs->minor_index] & VALID_MINOR)
+                module_put(drv->owner);
         drv->flags[cs->minor_index] = 0;
         spin_unlock_irqrestore(&drv->lock, flags);
 }
@@ -579,7 +582,7 @@ static struct bc_state *gigaset_initbcs(struct bc_state *bcs,
         } else if ((bcs->skb = dev_alloc_skb(SBUFSIZE + HW_HDR_LEN)) != NULL)
                 skb_reserve(bcs->skb, HW_HDR_LEN);
         else {
-                warn("could not allocate skb\n");
+                warn("could not allocate skb");
                 bcs->inputstate |= INS_skip_frame;
         }
 
@@ -632,17 +635,25 @@ struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels,
         int i;
 
         gig_dbg(DEBUG_INIT, "allocating cs");
-        cs = alloc_cs(drv);
-        if (!cs)
-                goto error;
+        if (!(cs = alloc_cs(drv))) {
+                err("maximum number of devices exceeded");
+                return NULL;
+        }
+        mutex_init(&cs->mutex);
+        mutex_lock(&cs->mutex);
+
         gig_dbg(DEBUG_INIT, "allocating bcs[0..%d]", channels - 1);
         cs->bcs = kmalloc(channels * sizeof(struct bc_state), GFP_KERNEL);
-        if (!cs->bcs)
+        if (!cs->bcs) {
+                err("out of memory");
                 goto error;
+        }
         gig_dbg(DEBUG_INIT, "allocating inbuf");
         cs->inbuf = kmalloc(sizeof(struct inbuf_t), GFP_KERNEL);
-        if (!cs->inbuf)
+        if (!cs->inbuf) {
+                err("out of memory");
                 goto error;
+        }
 
         cs->cs_init = 0;
         cs->channels = channels;
@@ -654,8 +665,6 @@ struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels,
         spin_lock_init(&cs->ev_lock);
         cs->ev_tail = 0;
         cs->ev_head = 0;
-        mutex_init(&cs->mutex);
-        mutex_lock(&cs->mutex);
 
         tasklet_init(&cs->event_tasklet, &gigaset_handle_event,
                      (unsigned long) cs);
@@ -684,8 +693,10 @@ struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels,
 
         for (i = 0; i < channels; ++i) {
                 gig_dbg(DEBUG_INIT, "setting up bcs[%d].read", i);
-                if (!gigaset_initbcs(cs->bcs + i, cs, i))
+                if (!gigaset_initbcs(cs->bcs + i, cs, i)) {
+                        err("could not allocate channel %d data", i);
                         goto error;
+                }
         }
 
         ++cs->cs_init;
@@ -720,8 +731,10 @@ struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels,
         make_valid(cs, VALID_ID);
         ++cs->cs_init;
         gig_dbg(DEBUG_INIT, "setting up hw");
-        if (!cs->ops->initcshw(cs))
+        if (!cs->ops->initcshw(cs)) {
+                err("could not allocate device specific data");
                 goto error;
+        }
 
         ++cs->cs_init;
 
@@ -743,8 +756,8 @@ struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels,
         mutex_unlock(&cs->mutex);
         return cs;
 
-error:  if (cs)
-                mutex_unlock(&cs->mutex);
+error:
+        mutex_unlock(&cs->mutex);
         gig_dbg(DEBUG_INIT, "failed");
         gigaset_freecs(cs);
         return NULL;
@@ -1040,7 +1053,6 @@ void gigaset_freedriver(struct gigaset_driver *drv)
         spin_unlock_irqrestore(&driver_lock, flags);
 
         gigaset_if_freedriver(drv);
-        module_put(drv->owner);
 
         kfree(drv->cs);
         kfree(drv->flags);
@@ -1072,10 +1084,6 @@ struct gigaset_driver *gigaset_initdriver(unsigned minor, unsigned minors,
         if (!drv)
                 return NULL;
 
-        if (!try_module_get(owner))
-                goto out1;
-
-        drv->cs = NULL;
         drv->have_tty = 0;
         drv->minor = minor;
         drv->minors = minors;
@@ -1087,11 +1095,11 @@ struct gigaset_driver *gigaset_initdriver(unsigned minor, unsigned minors,
 
         drv->cs = kmalloc(minors * sizeof *drv->cs, GFP_KERNEL);
         if (!drv->cs)
-                goto out2;
+                goto error;
 
         drv->flags = kmalloc(minors * sizeof *drv->flags, GFP_KERNEL);
         if (!drv->flags)
-                goto out3;
+                goto error;
 
         for (i = 0; i < minors; ++i) {
                 drv->flags[i] = 0;
@@ -1108,11 +1116,8 @@ struct gigaset_driver *gigaset_initdriver(unsigned minor, unsigned minors,
 
         return drv;
 
-out3:
+error:
         kfree(drv->cs);
-out2:
-        module_put(owner);
-out1:
         kfree(drv);
         return NULL;
 }
diff --git a/drivers/kvm/kvm.h b/drivers/kvm/kvm.h
index 91e0c75aca8f..2db1ca4c6800 100644
--- a/drivers/kvm/kvm.h
+++ b/drivers/kvm/kvm.h
@@ -242,6 +242,7 @@ struct kvm_vcpu {
         u64 pdptrs[4]; /* pae */
         u64 shadow_efer;
         u64 apic_base;
+        u64 ia32_misc_enable_msr;
         int nmsrs;
         struct vmx_msr_entry *guest_msrs;
         struct vmx_msr_entry *host_msrs;
diff --git a/drivers/kvm/kvm_main.c b/drivers/kvm/kvm_main.c
index be4651abe72c..b10972ed0c9f 100644
--- a/drivers/kvm/kvm_main.c
+++ b/drivers/kvm/kvm_main.c
@@ -1226,6 +1226,9 @@ int kvm_get_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata)
         case MSR_IA32_APICBASE:
                 data = vcpu->apic_base;
                 break;
+        case MSR_IA32_MISC_ENABLE:
+                data = vcpu->ia32_misc_enable_msr;
+                break;
 #ifdef CONFIG_X86_64
         case MSR_EFER:
                 data = vcpu->shadow_efer;
@@ -1297,6 +1300,9 @@ int kvm_set_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 data)
         case MSR_IA32_APICBASE:
                 vcpu->apic_base = data;
                 break;
+        case MSR_IA32_MISC_ENABLE:
+                vcpu->ia32_misc_enable_msr = data;
+                break;
         default:
                 printk(KERN_ERR "kvm: unhandled wrmsr: 0x%x\n", msr);
                 return 1;
@@ -1600,6 +1606,10 @@ static u32 msrs_to_save[] = {
 
 static unsigned num_msrs_to_save;
 
+static u32 emulated_msrs[] = {
+        MSR_IA32_MISC_ENABLE,
+};
+
 static __init void kvm_init_msr_list(void)
 {
         u32 dummy[2];
@@ -1925,7 +1935,7 @@ static long kvm_dev_ioctl(struct file *filp,
                 if (copy_from_user(&msr_list, user_msr_list, sizeof msr_list))
                         goto out;
                 n = msr_list.nmsrs;
-                msr_list.nmsrs = num_msrs_to_save;
+                msr_list.nmsrs = num_msrs_to_save + ARRAY_SIZE(emulated_msrs);
                 if (copy_to_user(user_msr_list, &msr_list, sizeof msr_list))
                         goto out;
                 r = -E2BIG;
@@ -1935,6 +1945,11 @@ static long kvm_dev_ioctl(struct file *filp,
                 if (copy_to_user(user_msr_list->indices, &msrs_to_save,
                                  num_msrs_to_save * sizeof(u32)))
                         goto out;
+                if (copy_to_user(user_msr_list->indices
+                                 + num_msrs_to_save * sizeof(u32),
+                                 &emulated_msrs,
+                                 ARRAY_SIZE(emulated_msrs) * sizeof(u32)))
+                        goto out;
                 r = 0;
                 break;
         }
diff --git a/drivers/kvm/mmu.c b/drivers/kvm/mmu.c
index c6f972914f08..22c426cd8cb2 100644
--- a/drivers/kvm/mmu.c
+++ b/drivers/kvm/mmu.c
@@ -143,6 +143,7 @@ static int dbg = 1;
 #define PFERR_PRESENT_MASK (1U << 0)
 #define PFERR_WRITE_MASK (1U << 1)
 #define PFERR_USER_MASK (1U << 2)
+#define PFERR_FETCH_MASK (1U << 4)
 
 #define PT64_ROOT_LEVEL 4
 #define PT32_ROOT_LEVEL 2
@@ -168,6 +169,11 @@ static int is_cpuid_PSE36(void)
         return 1;
 }
 
+static int is_nx(struct kvm_vcpu *vcpu)
+{
+        return vcpu->shadow_efer & EFER_NX;
+}
+
 static int is_present_pte(unsigned long pte)
 {
         return pte & PT_PRESENT_MASK;
@@ -992,16 +998,6 @@ static inline int fix_read_pf(u64 *shadow_ent)
         return 0;
 }
 
-static int may_access(u64 pte, int write, int user)
-{
-
-        if (user && !(pte & PT_USER_MASK))
-                return 0;
-        if (write && !(pte & PT_WRITABLE_MASK))
-                return 0;
-        return 1;
-}
-
 static void paging_free(struct kvm_vcpu *vcpu)
 {
         nonpaging_free(vcpu);
diff --git a/drivers/kvm/paging_tmpl.h b/drivers/kvm/paging_tmpl.h
index 6bc41950fbb3..149fa45fd9a5 100644
--- a/drivers/kvm/paging_tmpl.h
+++ b/drivers/kvm/paging_tmpl.h
@@ -63,13 +63,15 @@ struct guest_walker {
         pt_element_t *ptep;
         pt_element_t inherited_ar;
         gfn_t gfn;
+        u32 error_code;
 };
 
 /*
  * Fetch a guest pte for a guest virtual address
  */
-static void FNAME(walk_addr)(struct guest_walker *walker,
-                             struct kvm_vcpu *vcpu, gva_t addr)
+static int FNAME(walk_addr)(struct guest_walker *walker,
+                            struct kvm_vcpu *vcpu, gva_t addr,
+                            int write_fault, int user_fault, int fetch_fault)
 {
         hpa_t hpa;
         struct kvm_memory_slot *slot;
@@ -86,7 +88,7 @@ static void FNAME(walk_addr)(struct guest_walker *walker,
                 walker->ptep = &vcpu->pdptrs[(addr >> 30) & 3];
                 root = *walker->ptep;
                 if (!(root & PT_PRESENT_MASK))
-                        return;
+                        goto not_present;
                 --walker->level;
         }
 #endif
@@ -111,11 +113,23 @@ static void FNAME(walk_addr)(struct guest_walker *walker,
                 ASSERT(((unsigned long)walker->table & PAGE_MASK) ==
                        ((unsigned long)ptep & PAGE_MASK));
 
-                if (is_present_pte(*ptep) && !(*ptep &  PT_ACCESSED_MASK))
-                        *ptep |= PT_ACCESSED_MASK;
-
                 if (!is_present_pte(*ptep))
-                        break;
+                        goto not_present;
+
+                if (write_fault && !is_writeble_pte(*ptep))
+                        if (user_fault || is_write_protection(vcpu))
+                                goto access_error;
+
+                if (user_fault && !(*ptep & PT_USER_MASK))
+                        goto access_error;
+
+#if PTTYPE == 64
+                if (fetch_fault && is_nx(vcpu) && (*ptep & PT64_NX_MASK))
+                        goto access_error;
+#endif
+
+                if (!(*ptep & PT_ACCESSED_MASK))
+                        *ptep |= PT_ACCESSED_MASK;      /* avoid rmw */
 
                 if (walker->level == PT_PAGE_TABLE_LEVEL) {
                         walker->gfn = (*ptep & PT_BASE_ADDR_MASK)
@@ -146,6 +160,23 @@ static void FNAME(walk_addr)(struct guest_walker *walker,
         }
         walker->ptep = ptep;
         pgprintk("%s: pte %llx\n", __FUNCTION__, (u64)*ptep);
+        return 1;
+
+not_present:
+        walker->error_code = 0;
+        goto err;
+
+access_error:
+        walker->error_code = PFERR_PRESENT_MASK;
+
+err:
+        if (write_fault)
+                walker->error_code |= PFERR_WRITE_MASK;
+        if (user_fault)
+                walker->error_code |= PFERR_USER_MASK;
+        if (fetch_fault)
+                walker->error_code |= PFERR_FETCH_MASK;
+        return 0;
 }
 
 static void FNAME(release_walker)(struct guest_walker *walker)
@@ -347,8 +378,8 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gva_t addr,
                                u32 error_code)
 {
         int write_fault = error_code & PFERR_WRITE_MASK;
-        int pte_present = error_code & PFERR_PRESENT_MASK;
         int user_fault = error_code & PFERR_USER_MASK;
+        int fetch_fault = error_code & PFERR_FETCH_MASK;
         struct guest_walker walker;
         u64 *shadow_pte;
         int fixed;
@@ -365,19 +396,20 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gva_t addr,
         /*
          * Look up the shadow pte for the faulting address.
          */
-        FNAME(walk_addr)(&walker, vcpu, addr);
-        shadow_pte = FNAME(fetch)(vcpu, addr, &walker);
+        r = FNAME(walk_addr)(&walker, vcpu, addr, write_fault, user_fault,
+                             fetch_fault);
 
         /*
          * The page is not mapped by the guest.  Let the guest handle it.
          */
-        if (!shadow_pte) {
-                pgprintk("%s: not mapped\n", __FUNCTION__);
-                inject_page_fault(vcpu, addr, error_code);
+        if (!r) {
+                pgprintk("%s: guest page fault\n", __FUNCTION__);
+                inject_page_fault(vcpu, addr, walker.error_code);
                 FNAME(release_walker)(&walker);
                 return 0;
         }
 
+        shadow_pte = FNAME(fetch)(vcpu, addr, &walker);
         pgprintk("%s: shadow pte %p %llx\n", __FUNCTION__,
                  shadow_pte, *shadow_pte);
 
@@ -399,22 +431,7 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gva_t addr,
          * mmio: emulate if accessible, otherwise its a guest fault.
          */
         if (is_io_pte(*shadow_pte)) {
-                if (may_access(*shadow_pte, write_fault, user_fault))
-                        return 1;
-                pgprintk("%s: io work, no access\n", __FUNCTION__);
-                inject_page_fault(vcpu, addr,
-                                  error_code | PFERR_PRESENT_MASK);
-                kvm_mmu_audit(vcpu, "post page fault (io)");
-                return 0;
-        }
-
-        /*
-         * pte not present, guest page fault.
-         */
-        if (pte_present && !fixed && !write_pt) {
-                inject_page_fault(vcpu, addr, error_code);
-                kvm_mmu_audit(vcpu, "post page fault (guest)");
-                return 0;
+                return 1;
         }
 
         ++kvm_stat.pf_fixed;
@@ -429,7 +446,7 @@ static gpa_t FNAME(gva_to_gpa)(struct kvm_vcpu *vcpu, gva_t vaddr)
         pt_element_t guest_pte;
         gpa_t gpa;
 
-        FNAME(walk_addr)(&walker, vcpu, vaddr);
+        FNAME(walk_addr)(&walker, vcpu, vaddr, 0, 0, 0);
         guest_pte = *walker.ptep;
         FNAME(release_walker)(&walker);
 
diff --git a/drivers/kvm/svm.c b/drivers/kvm/svm.c
index 7397bfbbcb1c..9c70ff65e6b7 100644
--- a/drivers/kvm/svm.c
+++ b/drivers/kvm/svm.c
@@ -502,6 +502,7 @@ static void init_vmcb(struct vmcb *vmcb)
                                 (1ULL << INTERCEPT_IOIO_PROT) |
                                 (1ULL << INTERCEPT_MSR_PROT) |
                                 (1ULL << INTERCEPT_TASK_SWITCH) |
+                                (1ULL << INTERCEPT_SHUTDOWN) |
                                 (1ULL << INTERCEPT_VMRUN) |
                                 (1ULL << INTERCEPT_VMMCALL) |
                                 (1ULL << INTERCEPT_VMLOAD) |
@@ -680,14 +681,14 @@ static void svm_get_cs_db_l_bits(struct kvm_vcpu *vcpu, int *db, int *l)
 
 static void svm_get_idt(struct kvm_vcpu *vcpu, struct descriptor_table *dt)
 {
-        dt->limit = vcpu->svm->vmcb->save.ldtr.limit;
-        dt->base = vcpu->svm->vmcb->save.ldtr.base;
+        dt->limit = vcpu->svm->vmcb->save.idtr.limit;
+        dt->base = vcpu->svm->vmcb->save.idtr.base;
 }
 
 static void svm_set_idt(struct kvm_vcpu *vcpu, struct descriptor_table *dt)
 {
-        vcpu->svm->vmcb->save.ldtr.limit = dt->limit;
-        vcpu->svm->vmcb->save.ldtr.base = dt->base ;
+        vcpu->svm->vmcb->save.idtr.limit = dt->limit;
+        vcpu->svm->vmcb->save.idtr.base = dt->base ;
 }
 
 static void svm_get_gdt(struct kvm_vcpu *vcpu, struct descriptor_table *dt)
@@ -892,6 +893,19 @@ static int pf_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
         return 0;
 }
 
+static int shutdown_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+{
+        /*
+         * VMCB is undefined after a SHUTDOWN intercept
+         * so reinitialize it.
+         */
+        memset(vcpu->svm->vmcb, 0, PAGE_SIZE);
+        init_vmcb(vcpu->svm->vmcb);
+
+        kvm_run->exit_reason = KVM_EXIT_SHUTDOWN;
+        return 0;
+}
+
 static int io_get_override(struct kvm_vcpu *vcpu,
                           struct vmcb_seg **seg,
                           int *addr_override)
@@ -1249,6 +1263,7 @@ static int (*svm_exit_handlers[])(struct kvm_vcpu *vcpu,
         [SVM_EXIT_IOIO]                         = io_interception,
         [SVM_EXIT_MSR]                          = msr_interception,
         [SVM_EXIT_TASK_SWITCH]                  = task_switch_interception,
+        [SVM_EXIT_SHUTDOWN]                     = shutdown_interception,
         [SVM_EXIT_VMRUN]                        = invalid_op_interception,
         [SVM_EXIT_VMMCALL]                      = invalid_op_interception,
         [SVM_EXIT_VMLOAD]                       = invalid_op_interception,
diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index 5432d07c074d..11108165e264 100644
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -479,9 +479,12 @@ static int bitmap_read_sb(struct bitmap *bitmap)
         int err = -EINVAL;
 
         /* page 0 is the superblock, read it... */
-        if (bitmap->file)
-                bitmap->sb_page = read_page(bitmap->file, 0, bitmap, PAGE_SIZE);
-        else {
+        if (bitmap->file) {
+                loff_t isize = i_size_read(bitmap->file->f_mapping->host);
+                int bytes = isize > PAGE_SIZE ? PAGE_SIZE : isize;
+
+                bitmap->sb_page = read_page(bitmap->file, 0, bitmap, bytes);
+        } else {
                 bitmap->sb_page = read_sb_page(bitmap->mddev, bitmap->offset, 0);
         }
         if (IS_ERR(bitmap->sb_page)) {
@@ -877,7 +880,8 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
                         int count;
                         /* unmap the old page, we're done with it */
                         if (index == num_pages-1)
-                                count = bytes - index * PAGE_SIZE;
+                                count = bytes + sizeof(bitmap_super_t)
+                                        - index * PAGE_SIZE;
                         else
                                 count = PAGE_SIZE;
                         if (index == 0) {
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index fe7c56e10435..3668b170ea68 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -1116,7 +1116,8 @@ static int __bind(struct mapped_device *md, struct dm_table *t)
         if (size != get_capacity(md->disk))
                 memset(&md->geometry, 0, sizeof(md->geometry));
 
-        __set_size(md, size);
+        if (md->suspended_bdev)
+                __set_size(md, size);
         if (size == 0)
                 return 0;
 
@@ -1264,6 +1265,11 @@ int dm_swap_table(struct mapped_device *md, struct dm_table *table)
         if (!dm_suspended(md))
                 goto out;
 
+        /* without bdev, the device size cannot be changed */
+        if (!md->suspended_bdev)
+                if (get_capacity(md->disk) != dm_table_get_size(table))
+                        goto out;
+
         __unbind(md);
         r = __bind(md, table);
 
@@ -1341,11 +1347,14 @@ int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
         /* This does not get reverted if there's an error later. */
         dm_table_presuspend_targets(map);
 
-        md->suspended_bdev = bdget_disk(md->disk, 0);
-        if (!md->suspended_bdev) {
-                DMWARN("bdget failed in dm_suspend");
-                r = -ENOMEM;
-                goto flush_and_out;
+        /* bdget() can stall if the pending I/Os are not flushed */
+        if (!noflush) {
+                md->suspended_bdev = bdget_disk(md->disk, 0);
+                if (!md->suspended_bdev) {
+                        DMWARN("bdget failed in dm_suspend");
+                        r = -ENOMEM;
+                        goto flush_and_out;
+                }
         }
 
         /*
@@ -1473,8 +1482,10 @@ int dm_resume(struct mapped_device *md)
 
         unlock_fs(md);
 
-        bdput(md->suspended_bdev);
-        md->suspended_bdev = NULL;
+        if (md->suspended_bdev) {
+                bdput(md->suspended_bdev);
+                md->suspended_bdev = NULL;
+        }
 
         clear_bit(DMF_SUSPENDED, &md->flags);
 
diff --git a/drivers/md/md.c b/drivers/md/md.c
index d1cb45f6d6a9..e8807ea5377d 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -1633,7 +1633,8 @@ repeat:
          * and 'events' is odd, we can roll back to the previous clean state */
         if (nospares
             && (mddev->in_sync && mddev->recovery_cp == MaxSector)
-            && (mddev->events & 1))
+            && (mddev->events & 1)
+            && mddev->events != 1)
                 mddev->events--;
         else {
                 /* otherwise we have to go forward and ... */
@@ -3563,6 +3564,8 @@ static int get_bitmap_file(mddev_t * mddev, void __user * arg)
         char *ptr, *buf = NULL;
         int err = -ENOMEM;
 
+        md_allow_write(mddev);
+
         file = kmalloc(sizeof(*file), GFP_KERNEL);
         if (!file)
                 goto out;
@@ -5031,6 +5034,33 @@ void md_write_end(mddev_t *mddev)
         }
 }
 
+/* md_allow_write(mddev)
+ * Calling this ensures that the array is marked 'active' so that writes
+ * may proceed without blocking.  It is important to call this before
+ * attempting a GFP_KERNEL allocation while holding the mddev lock.
+ * Must be called with mddev_lock held.
+ */
+void md_allow_write(mddev_t *mddev)
+{
+        if (!mddev->pers)
+                return;
+        if (mddev->ro)
+                return;
+
+        spin_lock_irq(&mddev->write_lock);
+        if (mddev->in_sync) {
+                mddev->in_sync = 0;
+                set_bit(MD_CHANGE_CLEAN, &mddev->flags);
+                if (mddev->safemode_delay &&
+                    mddev->safemode == 0)
+                        mddev->safemode = 1;
+                spin_unlock_irq(&mddev->write_lock);
+                md_update_sb(mddev, 0);
+        } else
+                spin_unlock_irq(&mddev->write_lock);
+}
+EXPORT_SYMBOL_GPL(md_allow_write);
+
 static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
 
 #define SYNC_MARKS      10
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 164b25dca101..97ee870b265d 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1266,6 +1266,11 @@ static void sync_request_write(mddev_t *mddev, r1bio_t *r1_bio)
                                         sbio->bi_sector = r1_bio->sector +
                                                 conf->mirrors[i].rdev->data_offset;
                                         sbio->bi_bdev = conf->mirrors[i].rdev->bdev;
+                                        for (j = 0; j < vcnt ; j++)
+                                                memcpy(page_address(sbio->bi_io_vec[j].bv_page),
+                                                       page_address(pbio->bi_io_vec[j].bv_page),
+                                                       PAGE_SIZE);
+
                                 }
                         }
         }
@@ -2099,6 +2104,8 @@ static int raid1_reshape(mddev_t *mddev)
                 return -EINVAL;
         }
 
+        md_allow_write(mddev);
+
         raid_disks = mddev->raid_disks + mddev->delta_disks;
 
         if (raid_disks < conf->raid_disks) {
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index be008f034ada..467c16982d02 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -405,6 +405,8 @@ static int resize_stripes(raid5_conf_t *conf, int newsize)
         if (newsize <= conf->pool_size)
                 return 0; /* never bother to shrink */
 
+        md_allow_write(conf->mddev);
+
         /* Step 1 */
         sc = kmem_cache_create(conf->cache_name[1-conf->active_name],
                                sizeof(struct stripe_head)+(newsize-1)*sizeof(struct r5dev),
@@ -2678,7 +2680,7 @@ static int chunk_aligned_read(request_queue_t *q, struct bio * raid_bio)
         mdk_rdev_t *rdev;
 
         if (!in_chunk_boundary(mddev, raid_bio)) {
-                printk("chunk_aligned_read : non aligned\n");
+                PRINTK("chunk_aligned_read : non aligned\n");
                 return 0;
         }
         /*
@@ -3250,6 +3252,7 @@ raid5_store_stripe_cache_size(mddev_t *mddev, const char *page, size_t len)
                 else
                         break;
         }
+        md_allow_write(mddev);
         while (new > conf->max_nr_stripes) {
                 if (grow_one_stripe(conf))
                         conf->max_nr_stripes++;
diff --git a/drivers/rtc/rtc-sysfs.c b/drivers/rtc/rtc-sysfs.c
index 9418a59fb368..2ddd0cf07140 100644
--- a/drivers/rtc/rtc-sysfs.c
+++ b/drivers/rtc/rtc-sysfs.c
@@ -78,7 +78,7 @@ static struct attribute_group rtc_attr_group = {
         .attrs = rtc_attrs,
 };
 
-static int __devinit rtc_sysfs_add_device(struct class_device *class_dev,
+static int rtc_sysfs_add_device(struct class_device *class_dev,
                                         struct class_interface *class_intf)
 {
         int err;
diff --git a/drivers/spi/pxa2xx_spi.c b/drivers/spi/pxa2xx_spi.c
index 6ed3f1da9296..8b41f9cc2560 100644
--- a/drivers/spi/pxa2xx_spi.c
+++ b/drivers/spi/pxa2xx_spi.c
@@ -1169,8 +1169,9 @@ static int setup(struct spi_device *spi)
                                 spi->bits_per_word - 16 : spi->bits_per_word)
                         | SSCR0_SSE
                         | (spi->bits_per_word > 16 ? SSCR0_EDSS : 0);
-        chip->cr1 |= (((spi->mode & SPI_CPHA) != 0) << 4)
-                        | (((spi->mode & SPI_CPOL) != 0) << 3);
+        chip->cr1 &= ~(SSCR1_SPO | SSCR1_SPH);
+        chip->cr1 |= (((spi->mode & SPI_CPHA) != 0) ? SSCR1_SPH : 0)
+                        | (((spi->mode & SPI_CPOL) != 0) ? SSCR1_SPO : 0);
 
         /* NOTE:  PXA25x_SSP _could_ use external clocking ... */
         if (drv_data->ssp_type != PXA25x_SSP)
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index 270e6211c2e3..6307428d2c94 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -366,7 +366,6 @@ spi_alloc_master(struct device *dev, unsigned size)
 
         class_device_initialize(&master->cdev);
         master->cdev.class = &spi_master_class;
-        kobj_set_kset_s(&master->cdev, spi_master_class.subsys);
         master->cdev.dev = get_device(dev);
         spi_master_set_devdata(master, &master[1]);
 
@@ -466,14 +465,20 @@ EXPORT_SYMBOL_GPL(spi_unregister_master);
  */
 struct spi_master *spi_busnum_to_master(u16 bus_num)
 {
-        char                    name[9];
-        struct kobject          *bus;
-
-        snprintf(name, sizeof name, "spi%u", bus_num);
-        bus = kset_find_obj(&spi_master_class.subsys.kset, name);
-        if (bus)
-                return container_of(bus, struct spi_master, cdev.kobj);
-        return NULL;
+        struct class_device     *cdev;
+        struct spi_master       *master = NULL;
+        struct spi_master       *m;
+
+        down(&spi_master_class.sem);
+        list_for_each_entry(cdev, &spi_master_class.children, node) {
+                m = container_of(cdev, struct spi_master, cdev);
+                if (m->bus_num == bus_num) {
+                        master = spi_master_get(m);
+                        break;
+                }
+        }
+        up(&spi_master_class.sem);
+        return master;
 }
 EXPORT_SYMBOL_GPL(spi_busnum_to_master);
 
diff --git a/drivers/spi/spi_s3c24xx.c b/drivers/spi/spi_s3c24xx.c
index 8ca08713528e..651379c51ae6 100644
--- a/drivers/spi/spi_s3c24xx.c
+++ b/drivers/spi/spi_s3c24xx.c
@@ -10,9 +10,6 @@
  *
 */
 
-
-//#define DEBUG
-
 #include <linux/init.h>
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
@@ -44,6 +41,9 @@ struct s3c24xx_spi {
         int                      len;
         int                      count;
 
+        int                     (*set_cs)(struct s3c2410_spi_info *spi,
+                                          int cs, int pol);
+
         /* data buffers */
         const unsigned char     *tx;
         unsigned char           *rx;
@@ -64,6 +64,11 @@ static inline struct s3c24xx_spi *to_hw(struct spi_device *sdev)
         return spi_master_get_devdata(sdev->master);
 }
 
+static void s3c24xx_spi_gpiocs(struct s3c2410_spi_info *spi, int cs, int pol)
+{
+        s3c2410_gpio_setpin(spi->pin_cs, pol);
+}
+
 static void s3c24xx_spi_chipsel(struct spi_device *spi, int value)
 {
         struct s3c24xx_spi *hw = to_hw(spi);
@@ -72,10 +77,7 @@ static void s3c24xx_spi_chipsel(struct spi_device *spi, int value)
 
         switch (value) {
         case BITBANG_CS_INACTIVE:
-                if (hw->pdata->set_cs)
-                        hw->pdata->set_cs(hw->pdata, value, cspol);
-                else
-                        s3c2410_gpio_setpin(hw->pdata->pin_cs, cspol ^ 1);
+                hw->pdata->set_cs(hw->pdata, spi->chip_select, cspol^1);
                 break;
 
         case BITBANG_CS_ACTIVE:
@@ -96,14 +98,9 @@ static void s3c24xx_spi_chipsel(struct spi_device *spi, int value)
                 /* write new configration */
 
                 writeb(spcon, hw->regs + S3C2410_SPCON);
-
-                if (hw->pdata->set_cs)
-                        hw->pdata->set_cs(hw->pdata, value, cspol);
-                else
-                        s3c2410_gpio_setpin(hw->pdata->pin_cs, cspol);
+                hw->pdata->set_cs(hw->pdata, spi->chip_select, cspol);
 
                 break;
-
         }
 }
 
@@ -330,9 +327,12 @@ static int s3c24xx_spi_probe(struct platform_device *pdev)
         /* setup any gpio we can */
 
         if (!hw->pdata->set_cs) {
+                hw->set_cs = s3c24xx_spi_gpiocs;
+
                 s3c2410_gpio_setpin(hw->pdata->pin_cs, 1);
                 s3c2410_gpio_cfgpin(hw->pdata->pin_cs, S3C2410_GPIO_OUTPUT);
-        }
+        } else
+                hw->set_cs = hw->pdata->set_cs;
 
         /* register our spi controller */
 
diff --git a/fs/9p/error.c b/fs/9p/error.c
index ae91555c1558..0d7fa4e08812 100644
--- a/fs/9p/error.c
+++ b/fs/9p/error.c
@@ -83,6 +83,7 @@ int v9fs_errstr2errno(char *errstr, int len)
 
         if (errno == 0) {
                 /* TODO: if error isn't found, add it dynamically */
+                errstr[len] = 0;
                 printk(KERN_ERR "%s: errstr :%s: not found\n", __FUNCTION__,
                        errstr);
                 errno = 1;
diff --git a/fs/9p/fid.c b/fs/9p/fid.c
index 27507201f9e7..a9b6301a04fc 100644
--- a/fs/9p/fid.c
+++ b/fs/9p/fid.c
@@ -25,6 +25,7 @@
 #include <linux/fs.h>
 #include <linux/sched.h>
 #include <linux/idr.h>
+#include <asm/semaphore.h>
 
 #include "debug.h"
 #include "v9fs.h"
@@ -84,6 +85,7 @@ struct v9fs_fid *v9fs_fid_create(struct v9fs_session_info *v9ses, int fid)
         new->iounit = 0;
         new->rdir_pos = 0;
         new->rdir_fcall = NULL;
+        init_MUTEX(&new->lock);
         INIT_LIST_HEAD(&new->list);
 
         return new;
@@ -102,11 +104,11 @@ void v9fs_fid_destroy(struct v9fs_fid *fid)
 }
 
 /**
- * v9fs_fid_lookup - retrieve the right fid from a  particular dentry
+ * v9fs_fid_lookup - return a locked fid from a dentry
  * @dentry: dentry to look for fid in
- * @type: intent of lookup (operation or traversal)
  *
- * find a fid in the dentry
+ * find a fid in the dentry, obtain its semaphore and return a reference to it.
+ * code calling lookup is responsible for releasing lock
  *
  * TODO: only match fids that have the same uid as current user
  *
@@ -124,7 +126,68 @@ struct v9fs_fid *v9fs_fid_lookup(struct dentry *dentry)
 
         if (!return_fid) {
                 dprintk(DEBUG_ERROR, "Couldn't find a fid in dentry\n");
+                return_fid = ERR_PTR(-EBADF);
         }
 
+        if(down_interruptible(&return_fid->lock))
+                return ERR_PTR(-EINTR);
+
         return return_fid;
 }
+
+/**
+ * v9fs_fid_clone - lookup the fid for a dentry, clone a private copy and release it
+ * @dentry: dentry to look for fid in
+ *
+ * find a fid in the dentry and then clone to a new private fid
+ *
+ * TODO: only match fids that have the same uid as current user
+ *
+ */
+
+struct v9fs_fid *v9fs_fid_clone(struct dentry *dentry)
+{
+        struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
+        struct v9fs_fid *base_fid, *new_fid = ERR_PTR(-EBADF);
+        struct v9fs_fcall *fcall = NULL;
+        int fid, err;
+
+        base_fid = v9fs_fid_lookup(dentry);
+
+        if(IS_ERR(base_fid))
+                return base_fid;
+
+        if(base_fid) {  /* clone fid */
+                fid = v9fs_get_idpool(&v9ses->fidpool);
+                if (fid < 0) {
+                        eprintk(KERN_WARNING, "newfid fails!\n");
+                        new_fid = ERR_PTR(-ENOSPC);
+                        goto Release_Fid;
+                }
+
+                err = v9fs_t_walk(v9ses, base_fid->fid, fid, NULL, &fcall);
+                if (err < 0) {
+                        dprintk(DEBUG_ERROR, "clone walk didn't work\n");
+                        v9fs_put_idpool(fid, &v9ses->fidpool);
+                        new_fid = ERR_PTR(err);
+                        goto Free_Fcall;
+                }
+                new_fid = v9fs_fid_create(v9ses, fid);
+                if (new_fid == NULL) {
+                        dprintk(DEBUG_ERROR, "out of memory\n");
+                        new_fid = ERR_PTR(-ENOMEM);
+                }
+Free_Fcall:
+                kfree(fcall);
+        }
+
+Release_Fid:
+        up(&base_fid->lock);
+        return new_fid;
+}
+
+void v9fs_fid_clunk(struct v9fs_session_info *v9ses, struct v9fs_fid *fid)
+{
+        v9fs_t_clunk(v9ses, fid->fid);
+        v9fs_fid_destroy(fid);
+}
diff --git a/fs/9p/fid.h b/fs/9p/fid.h
index aa974d6875c3..48fc170c26c8 100644
--- a/fs/9p/fid.h
+++ b/fs/9p/fid.h
@@ -30,6 +30,8 @@ struct v9fs_fid {
         struct list_head list;   /* list of fids associated with a dentry */
         struct list_head active; /* XXX - debug */
 
+        struct semaphore lock;
+
         u32 fid;
         unsigned char fidopen;    /* set when fid is opened */
         unsigned char fidclunked; /* set when fid has already been clunked */
@@ -55,3 +57,6 @@ struct v9fs_fid *v9fs_fid_get_created(struct dentry *);
 void v9fs_fid_destroy(struct v9fs_fid *fid);
 struct v9fs_fid *v9fs_fid_create(struct v9fs_session_info *, int fid);
 int v9fs_fid_insert(struct v9fs_fid *fid, struct dentry *dentry);
+struct v9fs_fid *v9fs_fid_clone(struct dentry *dentry);
+void v9fs_fid_clunk(struct v9fs_session_info *v9ses, struct v9fs_fid *fid);
+
diff --git a/fs/9p/mux.c b/fs/9p/mux.c
index 944273c3dbff..147ceef8e537 100644
--- a/fs/9p/mux.c
+++ b/fs/9p/mux.c
@@ -132,8 +132,10 @@ int v9fs_mux_global_init(void)
                 v9fs_mux_poll_tasks[i].task = NULL;
 
         v9fs_mux_wq = create_workqueue("v9fs");
-        if (!v9fs_mux_wq)
+        if (!v9fs_mux_wq) {
+                printk(KERN_WARNING "v9fs: mux: creating workqueue failed\n");
                 return -ENOMEM;
+        }
 
         return 0;
 }
diff --git a/fs/9p/v9fs.c b/fs/9p/v9fs.c
index 0b96fae8b479..d9b561ba5e58 100644
--- a/fs/9p/v9fs.c
+++ b/fs/9p/v9fs.c
@@ -457,14 +457,19 @@ static int __init init_v9fs(void)
 
         v9fs_error_init();
 
-        printk(KERN_INFO "Installing v9fs 9P2000 file system support\n");
+        printk(KERN_INFO "Installing v9fs 9p2000 file system support\n");
 
         ret = v9fs_mux_global_init();
-        if (!ret)
+        if (ret) {
+                printk(KERN_WARNING "v9fs: starting mux failed\n");
                 return ret;
+        }
         ret = register_filesystem(&v9fs_fs_type);
-        if (!ret)
+        if (ret) {
+                printk(KERN_WARNING "v9fs: registering file system failed\n");
                 v9fs_mux_global_exit();
+        }
+
         return ret;
 }
 
diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index e86a07151280..9f17b0cacdd0 100644
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -55,53 +55,22 @@ int v9fs_file_open(struct inode *inode, struct file *file)
         struct v9fs_fid *vfid;
         struct v9fs_fcall *fcall = NULL;
         int omode;
-        int fid = V9FS_NOFID;
         int err;
 
         dprintk(DEBUG_VFS, "inode: %p file: %p \n", inode, file);
 
-        vfid = v9fs_fid_lookup(file->f_path.dentry);
-        if (!vfid) {
-                dprintk(DEBUG_ERROR, "Couldn't resolve fid from dentry\n");
-                return -EBADF;
-        }
-
-        fid = v9fs_get_idpool(&v9ses->fidpool);
-        if (fid < 0) {
-                eprintk(KERN_WARNING, "newfid fails!\n");
-                return -ENOSPC;
-        }
+        vfid = v9fs_fid_clone(file->f_path.dentry);
+        if (IS_ERR(vfid))
+                return PTR_ERR(vfid);
 
-        err = v9fs_t_walk(v9ses, vfid->fid, fid, NULL, &fcall);
-        if (err < 0) {
-                dprintk(DEBUG_ERROR, "rewalk didn't work\n");
-                if (fcall && fcall->id == RWALK)
-                        goto clunk_fid;
-                else {
-                        v9fs_put_idpool(fid, &v9ses->fidpool);
-                        goto free_fcall;
-                }
-        }
-        kfree(fcall);
-
-        /* TODO: do special things for O_EXCL, O_NOFOLLOW, O_SYNC */
-        /* translate open mode appropriately */
         omode = v9fs_uflags2omode(file->f_flags);
-        err = v9fs_t_open(v9ses, fid, omode, &fcall);
+        err = v9fs_t_open(v9ses, vfid->fid, omode, &fcall);
         if (err < 0) {
                 PRINT_FCALL_ERROR("open failed", fcall);
-                goto clunk_fid;
-        }
-
-        vfid = kmalloc(sizeof(struct v9fs_fid), GFP_KERNEL);
-        if (vfid == NULL) {
-                dprintk(DEBUG_ERROR, "out of memory\n");
-                err = -ENOMEM;
-                goto clunk_fid;
+                goto Clunk_Fid;
         }
 
         file->private_data = vfid;
-        vfid->fid = fid;
         vfid->fidopen = 1;
         vfid->fidclunked = 0;
         vfid->iounit = fcall->params.ropen.iounit;
@@ -112,10 +81,8 @@ int v9fs_file_open(struct inode *inode, struct file *file)
 
         return 0;
 
-clunk_fid:
-        v9fs_t_clunk(v9ses, fid);
-
-free_fcall:
+Clunk_Fid:
+        v9fs_fid_clunk(v9ses, vfid);
         kfree(fcall);
 
         return err;
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index 18f26cdfd882..9109ba1d6969 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -416,12 +416,8 @@ static int v9fs_remove(struct inode *dir, struct dentry *file, int rmdir)
         sb = file_inode->i_sb;
         v9ses = v9fs_inode2v9ses(file_inode);
         v9fid = v9fs_fid_lookup(file);
-
-        if (!v9fid) {
-                dprintk(DEBUG_ERROR,
-                        "no v9fs_fid\n");
-                return -EBADF;
-        }
+        if(IS_ERR(v9fid))
+                return PTR_ERR(v9fid);
 
         fid = v9fid->fid;
         if (fid < 0) {
@@ -433,11 +429,13 @@ static int v9fs_remove(struct inode *dir, struct dentry *file, int rmdir)
         result = v9fs_t_remove(v9ses, fid, &fcall);
         if (result < 0) {
                 PRINT_FCALL_ERROR("remove fails", fcall);
+                goto Error;
         }
 
         v9fs_put_idpool(fid, &v9ses->fidpool);
         v9fs_fid_destroy(v9fid);
 
+Error:
         kfree(fcall);
         return result;
 }
@@ -473,9 +471,13 @@ v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
         inode = NULL;
         vfid = NULL;
         v9ses = v9fs_inode2v9ses(dir);
-        dfid = v9fs_fid_lookup(dentry->d_parent);
-        perm = unixmode2p9mode(v9ses, mode);
+        dfid = v9fs_fid_clone(dentry->d_parent);
+        if(IS_ERR(dfid)) {
+                err = PTR_ERR(dfid);
+                goto error;
+        }
 
+        perm = unixmode2p9mode(v9ses, mode);
         if (nd && nd->flags & LOOKUP_OPEN)
                 flags = nd->intent.open.flags - 1;
         else
@@ -485,9 +487,10 @@ v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
                 perm, v9fs_uflags2omode(flags), NULL, &fid, &qid, &iounit);
 
         if (err)
-                goto error;
+                goto clunk_dfid;
 
         vfid = v9fs_clone_walk(v9ses, dfid->fid, dentry);
+        v9fs_fid_clunk(v9ses, dfid);
         if (IS_ERR(vfid)) {
                 err = PTR_ERR(vfid);
                 vfid = NULL;
@@ -525,6 +528,9 @@ v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
 
         return 0;
 
+clunk_dfid:
+        v9fs_fid_clunk(v9ses, dfid);
+
 error:
         if (vfid)
                 v9fs_fid_destroy(vfid);
@@ -551,7 +557,12 @@ static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         inode = NULL;
         vfid = NULL;
         v9ses = v9fs_inode2v9ses(dir);
-        dfid = v9fs_fid_lookup(dentry->d_parent);
+        dfid = v9fs_fid_clone(dentry->d_parent);
+        if(IS_ERR(dfid)) {
+                err = PTR_ERR(dfid);
+                goto error;
+        }
+
         perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
 
         err = v9fs_create(v9ses, dfid->fid, (char *) dentry->d_name.name,
@@ -559,37 +570,36 @@ static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 
         if (err) {
                 dprintk(DEBUG_ERROR, "create error %d\n", err);
-                goto error;
-        }
-
-        err = v9fs_t_clunk(v9ses, fid);
-        if (err) {
-                dprintk(DEBUG_ERROR, "clunk error %d\n", err);
-                goto error;
+                goto clean_up_dfid;
         }
 
         vfid = v9fs_clone_walk(v9ses, dfid->fid, dentry);
         if (IS_ERR(vfid)) {
                 err = PTR_ERR(vfid);
                 vfid = NULL;
-                goto error;
+                goto clean_up_dfid;
         }
 
+        v9fs_fid_clunk(v9ses, dfid);
         inode = v9fs_inode_from_fid(v9ses, vfid->fid, dir->i_sb);
         if (IS_ERR(inode)) {
                 err = PTR_ERR(inode);
                 inode = NULL;
-                goto error;
+                goto clean_up_fids;
         }
 
         dentry->d_op = &v9fs_dentry_operations;
         d_instantiate(dentry, inode);
         return 0;
 
-error:
+clean_up_fids:
         if (vfid)
                 v9fs_fid_destroy(vfid);
 
+clean_up_dfid:
+        v9fs_fid_clunk(v9ses, dfid);
+
+error:
         return err;
 }
 
@@ -622,28 +632,23 @@ static struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
         dentry->d_op = &v9fs_dentry_operations;
         dirfid = v9fs_fid_lookup(dentry->d_parent);
 
-        if (!dirfid) {
-                dprintk(DEBUG_ERROR, "no dirfid\n");
-                return ERR_PTR(-EINVAL);
-        }
+        if(IS_ERR(dirfid))
+                return ERR_PTR(PTR_ERR(dirfid));
 
         dirfidnum = dirfid->fid;
 
-        if (dirfidnum < 0) {
-                dprintk(DEBUG_ERROR, "no dirfid for inode %p, #%lu\n",
-                        dir, dir->i_ino);
-                return ERR_PTR(-EBADF);
-        }
-
         newfid = v9fs_get_idpool(&v9ses->fidpool);
         if (newfid < 0) {
                 eprintk(KERN_WARNING, "newfid fails!\n");
-                return ERR_PTR(-ENOSPC);
+                result = -ENOSPC;
+                goto Release_Dirfid;
         }
 
         result = v9fs_t_walk(v9ses, dirfidnum, newfid,
                 (char *)dentry->d_name.name, &fcall);
 
+        up(&dirfid->lock);
+
         if (result < 0) {
                 if (fcall && fcall->id == RWALK)
                         v9fs_t_clunk(v9ses, newfid);
@@ -701,8 +706,12 @@ static struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
 
         return NULL;
 
-      FreeFcall:
+Release_Dirfid:
+        up(&dirfid->lock);
+
+FreeFcall:
         kfree(fcall);
+
         return ERR_PTR(result);
 }
 
@@ -746,10 +755,8 @@ v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct inode *old_inode = old_dentry->d_inode;
         struct v9fs_session_info *v9ses = v9fs_inode2v9ses(old_inode);
         struct v9fs_fid *oldfid = v9fs_fid_lookup(old_dentry);
-        struct v9fs_fid *olddirfid =
-            v9fs_fid_lookup(old_dentry->d_parent);
-        struct v9fs_fid *newdirfid =
-            v9fs_fid_lookup(new_dentry->d_parent);
+        struct v9fs_fid *olddirfid;
+        struct v9fs_fid *newdirfid;
         struct v9fs_wstat wstat;
         struct v9fs_fcall *fcall = NULL;
         int fid = -1;
@@ -759,16 +766,26 @@ v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
         dprintk(DEBUG_VFS, "\n");
 
-        if ((!oldfid) || (!olddirfid) || (!newdirfid)) {
-                dprintk(DEBUG_ERROR, "problem with arguments\n");
-                return -EBADF;
+        if(IS_ERR(oldfid))
+                return PTR_ERR(oldfid);
+
+        olddirfid = v9fs_fid_clone(old_dentry->d_parent);
+        if(IS_ERR(olddirfid)) {
+                retval = PTR_ERR(olddirfid);
+                goto Release_lock;
+        }
+
+        newdirfid = v9fs_fid_clone(new_dentry->d_parent);
+        if(IS_ERR(newdirfid)) {
+                retval = PTR_ERR(newdirfid);
+                goto Clunk_olddir;
         }
 
         /* 9P can only handle file rename in the same directory */
         if (memcmp(&olddirfid->qid, &newdirfid->qid, sizeof(newdirfid->qid))) {
                 dprintk(DEBUG_ERROR, "old dir and new dir are different\n");
-                retval = -EPERM;
-                goto FreeFcallnBail;
+                retval = -EXDEV;
+                goto Clunk_newdir;
         }
 
         fid = oldfid->fid;
@@ -779,7 +796,7 @@ v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                 dprintk(DEBUG_ERROR, "no fid for old file #%lu\n",
                         old_inode->i_ino);
                 retval = -EBADF;
-                goto FreeFcallnBail;
+                goto Clunk_newdir;
         }
 
         v9fs_blank_wstat(&wstat);
@@ -788,11 +805,20 @@ v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
         retval = v9fs_t_wstat(v9ses, fid, &wstat, &fcall);
 
-      FreeFcallnBail:
         if (retval < 0)
                 PRINT_FCALL_ERROR("wstat error", fcall);
 
         kfree(fcall);
+
+Clunk_newdir:
+        v9fs_fid_clunk(v9ses, newdirfid);
+
+Clunk_olddir:
+        v9fs_fid_clunk(v9ses, olddirfid);
+
+Release_lock:
+        up(&oldfid->lock);
+
         return retval;
 }
 
@@ -810,15 +836,12 @@ v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 {
         struct v9fs_fcall *fcall = NULL;
         struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
-        struct v9fs_fid *fid = v9fs_fid_lookup(dentry);
+        struct v9fs_fid *fid = v9fs_fid_clone(dentry);
         int err = -EPERM;
 
         dprintk(DEBUG_VFS, "dentry: %p\n", dentry);
-        if (!fid) {
-                dprintk(DEBUG_ERROR,
-                        "couldn't find fid associated with dentry\n");
-                return -EBADF;
-        }
+        if(IS_ERR(fid))
+                return PTR_ERR(fid);
 
         err = v9fs_t_stat(v9ses, fid->fid, &fcall);
 
@@ -831,6 +854,7 @@ v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
         }
 
         kfree(fcall);
+        v9fs_fid_clunk(v9ses, fid);
         return err;
 }
 
@@ -844,18 +868,14 @@ v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
 {
         struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
-        struct v9fs_fid *fid = v9fs_fid_lookup(dentry);
+        struct v9fs_fid *fid = v9fs_fid_clone(dentry);
         struct v9fs_fcall *fcall = NULL;
         struct v9fs_wstat wstat;
         int res = -EPERM;
 
         dprintk(DEBUG_VFS, "\n");
-
-        if (!fid) {
-                dprintk(DEBUG_ERROR,
-                        "Couldn't find fid associated with dentry\n");
-                return -EBADF;
-        }
+        if(IS_ERR(fid))
+                return PTR_ERR(fid);
 
         v9fs_blank_wstat(&wstat);
         if (iattr->ia_valid & ATTR_MODE)
@@ -887,6 +907,7 @@ static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
         if (res >= 0)
                 res = inode_setattr(dentry->d_inode, iattr);
 
+        v9fs_fid_clunk(v9ses, fid);
         return res;
 }
 
@@ -987,18 +1008,15 @@ static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
 
         struct v9fs_fcall *fcall = NULL;
         struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
-        struct v9fs_fid *fid = v9fs_fid_lookup(dentry);
+        struct v9fs_fid *fid = v9fs_fid_clone(dentry);
 
-        if (!fid) {
-                dprintk(DEBUG_ERROR, "could not resolve fid from dentry\n");
-                retval = -EBADF;
-                goto FreeFcall;
-        }
+        if(IS_ERR(fid))
+                return PTR_ERR(fid);
 
         if (!v9ses->extended) {
                 retval = -EBADF;
                 dprintk(DEBUG_ERROR, "not extended\n");
-                goto FreeFcall;
+                goto ClunkFid;
         }
 
         dprintk(DEBUG_VFS, " %s\n", dentry->d_name.name);
@@ -1009,8 +1027,10 @@ static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
                 goto FreeFcall;
         }
 
-        if (!fcall)
-                return -EIO;
+        if (!fcall) {
+                retval = -EIO;
+                goto ClunkFid;
+        }
 
         if (!(fcall->params.rstat.stat.mode & V9FS_DMSYMLINK)) {
                 retval = -EINVAL;
@@ -1028,9 +1048,12 @@ static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
                 fcall->params.rstat.stat.extension.str, buffer);
         retval = buflen;
 
-      FreeFcall:
+FreeFcall:
         kfree(fcall);
 
+ClunkFid:
+        v9fs_fid_clunk(v9ses, fid);
+
         return retval;
 }
 
@@ -1123,52 +1146,58 @@ static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
         int err;
         u32 fid, perm;
         struct v9fs_session_info *v9ses;
-        struct v9fs_fid *dfid, *vfid;
-        struct inode *inode;
+        struct v9fs_fid *dfid, *vfid = NULL;
+        struct inode *inode = NULL;
 
-        inode = NULL;
-        vfid = NULL;
         v9ses = v9fs_inode2v9ses(dir);
-        dfid = v9fs_fid_lookup(dentry->d_parent);
-        perm = unixmode2p9mode(v9ses, mode);
-
         if (!v9ses->extended) {
                 dprintk(DEBUG_ERROR, "not extended\n");
                 return -EPERM;
         }
 
+        dfid = v9fs_fid_clone(dentry->d_parent);
+        if(IS_ERR(dfid)) {
+                err = PTR_ERR(dfid);
+                goto error;
+        }
+
+        perm = unixmode2p9mode(v9ses, mode);
+
         err = v9fs_create(v9ses, dfid->fid, (char *) dentry->d_name.name,
                 perm, V9FS_OREAD, (char *) extension, &fid, NULL, NULL);
 
         if (err)
-                goto error;
+                goto clunk_dfid;
 
         err = v9fs_t_clunk(v9ses, fid);
         if (err)
-                goto error;
+                goto clunk_dfid;
 
         vfid = v9fs_clone_walk(v9ses, dfid->fid, dentry);
         if (IS_ERR(vfid)) {
                 err = PTR_ERR(vfid);
                 vfid = NULL;
-                goto error;
+                goto clunk_dfid;
         }
 
         inode = v9fs_inode_from_fid(v9ses, vfid->fid, dir->i_sb);
         if (IS_ERR(inode)) {
                 err = PTR_ERR(inode);
                 inode = NULL;
-                goto error;
+                goto free_vfid;
         }
 
         dentry->d_op = &v9fs_dentry_operations;
         d_instantiate(dentry, inode);
         return 0;
 
-error:
-        if (vfid)
-                v9fs_fid_destroy(vfid);
+free_vfid:
+        v9fs_fid_destroy(vfid);
+
+clunk_dfid:
+        v9fs_fid_clunk(v9ses, dfid);
 
+error:
         return err;
 
 }
@@ -1209,26 +1238,29 @@ v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
               struct dentry *dentry)
 {
         int retval;
+        struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
         struct v9fs_fid *oldfid;
         char *name;
 
         dprintk(DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
                 old_dentry->d_name.name);
 
-        oldfid = v9fs_fid_lookup(old_dentry);
-        if (!oldfid) {
-                dprintk(DEBUG_ERROR, "can't find oldfid\n");
-                return -EPERM;
-        }
+        oldfid = v9fs_fid_clone(old_dentry);
+        if(IS_ERR(oldfid))
+                return PTR_ERR(oldfid);
 
         name = __getname();
-        if (unlikely(!name))
-                return -ENOMEM;
+        if (unlikely(!name)) {
+                retval = -ENOMEM;
+                goto clunk_fid;
+        }
 
         sprintf(name, "%d\n", oldfid->fid);
         retval = v9fs_vfs_mkspecial(dir, dentry, V9FS_DMLINK, name);
         __putname(name);
 
+clunk_fid:
+        v9fs_fid_clunk(v9ses, oldfid);
         return retval;
 }
 
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index 7cb28720f90e..669dbe5b0317 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -682,6 +682,15 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
                         retval = PTR_ERR(interpreter);
                         if (IS_ERR(interpreter))
                                 goto out_free_interp;
+
+                        /*
+                         * If the binary is not readable then enforce
+                         * mm->dumpable = 0 regardless of the interpreter's
+                         * permissions.
+                         */
+                        if (file_permission(interpreter, MAY_READ) < 0)
+                                bprm->interp_flags |= BINPRM_FLAGS_ENFORCE_NONDUMP;
+
                         retval = kernel_read(interpreter, 0, bprm->buf,
                                              BINPRM_BUF_SIZE);
                         if (retval != BINPRM_BUF_SIZE) {
@@ -1178,6 +1187,10 @@ static int dump_seek(struct file *file, loff_t off)
  */
 static int maydump(struct vm_area_struct *vma)
 {
+        /* The vma can be set up to tell us the answer directly.  */
+        if (vma->vm_flags & VM_ALWAYSDUMP)
+                return 1;
+
         /* Do not dump I/O mapped devices or special mappings */
         if (vma->vm_flags & (VM_IO | VM_RESERVED))
                 return 0;
@@ -1424,6 +1437,32 @@ static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
         return sz;
 }
 
+static struct vm_area_struct *first_vma(struct task_struct *tsk,
+                                        struct vm_area_struct *gate_vma)
+{
+        struct vm_area_struct *ret = tsk->mm->mmap;
+
+        if (ret)
+                return ret;
+        return gate_vma;
+}
+/*
+ * Helper function for iterating across a vma list.  It ensures that the caller
+ * will visit `gate_vma' prior to terminating the search.
+ */
+static struct vm_area_struct *next_vma(struct vm_area_struct *this_vma,
+                                        struct vm_area_struct *gate_vma)
+{
+        struct vm_area_struct *ret;
+
+        ret = this_vma->vm_next;
+        if (ret)
+                return ret;
+        if (this_vma == gate_vma)
+                return NULL;
+        return gate_vma;
+}
+
 /*
  * Actual dumper
  *
@@ -1439,7 +1478,7 @@ static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file)
         int segs;
         size_t size = 0;
         int i;
-        struct vm_area_struct *vma;
+        struct vm_area_struct *vma, *gate_vma;
         struct elfhdr *elf = NULL;
         loff_t offset = 0, dataoff, foffset;
         unsigned long limit = current->signal->rlim[RLIMIT_CORE].rlim_cur;
@@ -1525,6 +1564,10 @@ static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file)
         segs += ELF_CORE_EXTRA_PHDRS;
 #endif
 
+        gate_vma = get_gate_vma(current);
+        if (gate_vma != NULL)
+                segs++;
+
         /* Set up header */
         fill_elf_header(elf, segs + 1); /* including notes section */
 
@@ -1592,7 +1635,8 @@ static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file)
         dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
 
         /* Write program headers for segments dump */
-        for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
+        for (vma = first_vma(current, gate_vma); vma != NULL;
+                        vma = next_vma(vma, gate_vma)) {
                 struct elf_phdr phdr;
                 size_t sz;
 
@@ -1641,7 +1685,8 @@ static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file)
         /* Align to page */
         DUMP_SEEK(dataoff - foffset);
 
-        for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
+        for (vma = first_vma(current, gate_vma); vma != NULL;
+                        vma = next_vma(vma, gate_vma)) {
                 unsigned long addr;
 
                 if (!maydump(vma))
diff --git a/fs/binfmt_elf_fdpic.c b/fs/binfmt_elf_fdpic.c
index 6e6d4568d548..a4d933a51208 100644
--- a/fs/binfmt_elf_fdpic.c
+++ b/fs/binfmt_elf_fdpic.c
@@ -234,6 +234,14 @@ static int load_elf_fdpic_binary(struct linux_binprm *bprm,
                                 goto error;
                         }
 
+                        /*
+                         * If the binary is not readable then enforce
+                         * mm->dumpable = 0 regardless of the interpreter's
+                         * permissions.
+                         */
+                        if (file_permission(interpreter, MAY_READ) < 0)
+                                bprm->interp_flags |= BINPRM_FLAGS_ENFORCE_NONDUMP;
+
                         retval = kernel_read(interpreter, 0, bprm->buf,
                                              BINPRM_BUF_SIZE);
                         if (retval < 0)
diff --git a/fs/buffer.c b/fs/buffer.c
index 3b116078b4c3..460f1c43238e 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -2834,7 +2834,7 @@ int try_to_free_buffers(struct page *page)
         int ret = 0;
 
         BUG_ON(!PageLocked(page));
-        if (PageDirty(page) || PageWriteback(page))
+        if (PageWriteback(page))
                 return 0;
 
         if (mapping == NULL) {          /* can this still happen? */
@@ -2845,6 +2845,19 @@ int try_to_free_buffers(struct page *page)
         spin_lock(&mapping->private_lock);
         ret = drop_buffers(page, &buffers_to_free);
         spin_unlock(&mapping->private_lock);
+
+        /*
+         * If the filesystem writes its buffers by hand (eg ext3)
+         * then we can have clean buffers against a dirty page.  We
+         * clean the page here; otherwise the VM will never notice
+         * that the filesystem did any IO at all.
+         *
+         * Also, during truncate, discard_buffer will have marked all
+         * the page's buffers clean.  We discover that here and clean
+         * the page also.
+         */
+        if (ret)
+                cancel_dirty_page(page, PAGE_CACHE_SIZE);
 out:
         if (buffers_to_free) {
                 struct buffer_head *bh = buffers_to_free;
diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
index c403b66ec83c..a4b142a6a2c7 100644
--- a/fs/fs-writeback.c
+++ b/fs/fs-writeback.c
@@ -251,8 +251,19 @@ __writeback_single_inode(struct inode *inode, struct writeback_control *wbc)
                 WARN_ON(inode->i_state & I_WILL_FREE);
 
         if ((wbc->sync_mode != WB_SYNC_ALL) && (inode->i_state & I_LOCK)) {
+                struct address_space *mapping = inode->i_mapping;
+                int ret;
+
                 list_move(&inode->i_list, &inode->i_sb->s_dirty);
-                return 0;
+
+                /*
+                 * Even if we don't actually write the inode itself here,
+                 * we can at least start some of the data writeout..
+                 */
+                spin_unlock(&inode_lock);
+                ret = do_writepages(mapping, wbc);
+                spin_lock(&inode_lock);
+                return ret;
         }
 
         /*
diff --git a/fs/nfsd/nfs3xdr.c b/fs/nfsd/nfs3xdr.c
index 277df40f098d..e695660921ec 100644
--- a/fs/nfsd/nfs3xdr.c
+++ b/fs/nfsd/nfs3xdr.c
@@ -990,15 +990,16 @@ encode_entry(struct readdir_cd *ccd, const char *name,
 }
 
 int
-nfs3svc_encode_entry(struct readdir_cd *cd, const char *name,
-                     int namlen, loff_t offset, ino_t ino, unsigned int d_type)
+nfs3svc_encode_entry(void *cd, const char *name,
+                     int namlen, loff_t offset, u64 ino, unsigned int d_type)
 {
         return encode_entry(cd, name, namlen, offset, ino, d_type, 0);
 }
 
 int
-nfs3svc_encode_entry_plus(struct readdir_cd *cd, const char *name,
-                          int namlen, loff_t offset, ino_t ino, unsigned int d_type)
+nfs3svc_encode_entry_plus(void *cd, const char *name,
+                          int namlen, loff_t offset, u64 ino,
+                          unsigned int d_type)
 {
         return encode_entry(cd, name, namlen, offset, ino, d_type, 1);
 }
diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index fea46368afb2..18aa9440df14 100644
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -1880,9 +1880,10 @@ nfsd4_encode_rdattr_error(__be32 *p, int buflen, __be32 nfserr)
 }
 
 static int
-nfsd4_encode_dirent(struct readdir_cd *ccd, const char *name, int namlen,
-                    loff_t offset, ino_t ino, unsigned int d_type)
+nfsd4_encode_dirent(void *ccdv, const char *name, int namlen,
+                    loff_t offset, u64 ino, unsigned int d_type)
 {
+        struct readdir_cd *ccd = ccdv;
         struct nfsd4_readdir *cd = container_of(ccd, struct nfsd4_readdir, common);
         int buflen;
         __be32 *p = cd->buffer;
diff --git a/fs/nfsd/nfssvc.c b/fs/nfsd/nfssvc.c
index 0aaccb03bf76..fbf5d51947ea 100644
--- a/fs/nfsd/nfssvc.c
+++ b/fs/nfsd/nfssvc.c
@@ -72,7 +72,7 @@ static struct svc_program	nfsd_acl_program = {
         .pg_prog                = NFS_ACL_PROGRAM,
         .pg_nvers               = NFSD_ACL_NRVERS,
         .pg_vers                = nfsd_acl_versions,
-        .pg_name                = "nfsd",
+        .pg_name                = "nfsacl",
         .pg_class               = "nfsd",
         .pg_stats               = &nfsd_acl_svcstats,
         .pg_authenticate        = &svc_set_client,
@@ -118,16 +118,16 @@ int nfsd_vers(int vers, enum vers_op change)
         switch(change) {
         case NFSD_SET:
                 nfsd_versions[vers] = nfsd_version[vers];
-                break;
 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
                 if (vers < NFSD_ACL_NRVERS)
-                        nfsd_acl_version[vers] = nfsd_acl_version[vers];
+                        nfsd_acl_versions[vers] = nfsd_acl_version[vers];
 #endif
+                break;
         case NFSD_CLEAR:
                 nfsd_versions[vers] = NULL;
 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
                 if (vers < NFSD_ACL_NRVERS)
-                        nfsd_acl_version[vers] = NULL;
+                        nfsd_acl_versions[vers] = NULL;
 #endif
                 break;
         case NFSD_TEST:
diff --git a/fs/nfsd/nfsxdr.c b/fs/nfsd/nfsxdr.c
index f5243f943996..6555c50d9006 100644
--- a/fs/nfsd/nfsxdr.c
+++ b/fs/nfsd/nfsxdr.c
@@ -462,9 +462,10 @@ nfssvc_encode_statfsres(struct svc_rqst *rqstp, __be32 *p,
 }
 
 int
-nfssvc_encode_entry(struct readdir_cd *ccd, const char *name,
-                    int namlen, loff_t offset, ino_t ino, unsigned int d_type)
+nfssvc_encode_entry(void *ccdv, const char *name,
+                    int namlen, loff_t offset, u64 ino, unsigned int d_type)
 {
+        struct readdir_cd *ccd = ccdv;
         struct nfsd_readdirres *cd = container_of(ccd, struct nfsd_readdirres, common);
         __be32  *p = cd->buffer;
         int     buflen, slen;
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 7a79c23aa6d4..5d32e5fa697e 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -822,7 +822,8 @@ nfsd_read_actor(read_descriptor_t *desc, struct page *page, unsigned long offset
                 rqstp->rq_res.page_len = size;
         } else if (page != pp[-1]) {
                 get_page(page);
-                put_page(*pp);
+                if (*pp)
+                        put_page(*pp);
                 *pp = page;
                 rqstp->rq_resused++;
                 rqstp->rq_res.page_len += size;
@@ -1244,7 +1245,6 @@ nfsd_create_v3(struct svc_rqst *rqstp, struct svc_fh *fhp,
         __be32          err;
         int             host_err;
         __u32           v_mtime=0, v_atime=0;
-        int             v_mode=0;
 
         err = nfserr_perm;
         if (!flen)
@@ -1281,16 +1281,11 @@ nfsd_create_v3(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 goto out;
 
         if (createmode == NFS3_CREATE_EXCLUSIVE) {
-                /* while the verifier would fit in mtime+atime,
-                 * solaris7 gets confused (bugid 4218508) if these have
-                 * the high bit set, so we use the mode as well
+                /* solaris7 gets confused (bugid 4218508) if these have
+                 * the high bit set, so just clear the high bits.
                  */
                 v_mtime = verifier[0]&0x7fffffff;
                 v_atime = verifier[1]&0x7fffffff;
-                v_mode  = S_IFREG
-                        | ((verifier[0]&0x80000000) >> (32-7)) /* u+x */
-                        | ((verifier[1]&0x80000000) >> (32-9)) /* u+r */
-                        ;
         }
         
         if (dchild->d_inode) {
@@ -1318,7 +1313,6 @@ nfsd_create_v3(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 case NFS3_CREATE_EXCLUSIVE:
                         if (   dchild->d_inode->i_mtime.tv_sec == v_mtime
                             && dchild->d_inode->i_atime.tv_sec == v_atime
-                            && dchild->d_inode->i_mode  == v_mode
                             && dchild->d_inode->i_size  == 0 )
                                 break;
                          /* fallthru */
@@ -1340,26 +1334,22 @@ nfsd_create_v3(struct svc_rqst *rqstp, struct svc_fh *fhp,
         }
 
         if (createmode == NFS3_CREATE_EXCLUSIVE) {
-                /* Cram the verifier into atime/mtime/mode */
+                /* Cram the verifier into atime/mtime */
                 iap->ia_valid = ATTR_MTIME|ATTR_ATIME
-                        | ATTR_MTIME_SET|ATTR_ATIME_SET
-                        | ATTR_MODE;
+                        | ATTR_MTIME_SET|ATTR_ATIME_SET;
                 /* XXX someone who knows this better please fix it for nsec */ 
                 iap->ia_mtime.tv_sec = v_mtime;
                 iap->ia_atime.tv_sec = v_atime;
                 iap->ia_mtime.tv_nsec = 0;
                 iap->ia_atime.tv_nsec = 0;
-                iap->ia_mode  = v_mode;
         }
 
         /* Set file attributes.
-         * Mode has already been set but we might need to reset it
-         * for CREATE_EXCLUSIVE
          * Irix appears to send along the gid when it tries to
          * implement setgid directories via NFS. Clear out all that cruft.
          */
  set_attr:
-        if ((iap->ia_valid &= ~(ATTR_UID|ATTR_GID)) != 0) {
+        if ((iap->ia_valid &= ~(ATTR_UID|ATTR_GID|ATTR_MODE)) != 0) {
                 __be32 err2 = nfsd_setattr(rqstp, resfhp, iap, 0, (time_t)0);
                 if (err2)
                         err = err2;
@@ -1726,7 +1716,7 @@ out:
  */
 __be32
 nfsd_readdir(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t *offsetp, 
-             struct readdir_cd *cdp, encode_dent_fn func)
+             struct readdir_cd *cdp, filldir_t func)
 {
         __be32          err;
         int             host_err;
@@ -1751,7 +1741,7 @@ nfsd_readdir(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t *offsetp,
 
         do {
                 cdp->err = nfserr_eof; /* will be cleared on successful read */
-                host_err = vfs_readdir(file, (filldir_t) func, cdp);
+                host_err = vfs_readdir(file, func, cdp);
         } while (host_err >=0 && cdp->err == nfs_ok);
         if (host_err)
                 err = nfserrno(host_err);
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 77a57b5799c4..ff7a66850602 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -371,9 +371,11 @@ static int mounts_open(struct inode *inode, struct file *file)
 
         if (task) {
                 task_lock(task);
-                ns = task->nsproxy->mnt_ns;
-                if (ns)
-                        get_mnt_ns(ns);
+                if (task->nsproxy) {
+                        ns = task->nsproxy->mnt_ns;
+                        if (ns)
+                                get_mnt_ns(ns);
+                }
                 task_unlock(task);
                 put_task_struct(task);
         }
diff --git a/include/asm-i386/elf.h b/include/asm-i386/elf.h
index 45d21a0c95bf..369035dfe4b6 100644
--- a/include/asm-i386/elf.h
+++ b/include/asm-i386/elf.h
@@ -143,11 +143,8 @@ extern int dump_task_extended_fpu (struct task_struct *, struct user_fxsr_struct
 # define VDSO_PRELINK           0
 #endif
 
-#define VDSO_COMPAT_SYM(x) \
-                (VDSO_COMPAT_BASE + (unsigned long)(x) - VDSO_PRELINK)
-
 #define VDSO_SYM(x) \
-                (VDSO_BASE + (unsigned long)(x) - VDSO_PRELINK)
+                (VDSO_COMPAT_BASE + (unsigned long)(x) - VDSO_PRELINK)
 
 #define VDSO_HIGH_EHDR          ((const struct elfhdr *) VDSO_HIGH_BASE)
 #define VDSO_EHDR               ((const struct elfhdr *) VDSO_COMPAT_BASE)
@@ -156,10 +153,12 @@ extern void __kernel_vsyscall;
 
 #define VDSO_ENTRY              VDSO_SYM(&__kernel_vsyscall)
 
+#ifndef CONFIG_COMPAT_VDSO
 #define ARCH_HAS_SETUP_ADDITIONAL_PAGES
 struct linux_binprm;
 extern int arch_setup_additional_pages(struct linux_binprm *bprm,
                                        int executable_stack);
+#endif
 
 extern unsigned int vdso_enabled;
 
@@ -169,50 +168,6 @@ do if (vdso_enabled) {						\
                 NEW_AUX_ENT(AT_SYSINFO_EHDR, VDSO_COMPAT_BASE); \
 } while (0)
 
-/*
- * These macros parameterize elf_core_dump in fs/binfmt_elf.c to write out
- * extra segments containing the vsyscall DSO contents.  Dumping its
- * contents makes post-mortem fully interpretable later without matching up
- * the same kernel and hardware config to see what PC values meant.
- * Dumping its extra ELF program headers includes all the other information
- * a debugger needs to easily find how the vsyscall DSO was being used.
- */
-#define ELF_CORE_EXTRA_PHDRS            (VDSO_HIGH_EHDR->e_phnum)
-#define ELF_CORE_WRITE_EXTRA_PHDRS                                            \
-do {                                                                          \
-        const struct elf_phdr *const vsyscall_phdrs =                         \
-                (const struct elf_phdr *) (VDSO_HIGH_BASE                     \
-                                           + VDSO_HIGH_EHDR->e_phoff);    \
-        int i;                                                                \
-        Elf32_Off ofs = 0;                                                    \
-        for (i = 0; i < VDSO_HIGH_EHDR->e_phnum; ++i) {               \
-                struct elf_phdr phdr = vsyscall_phdrs[i];                     \
-                if (phdr.p_type == PT_LOAD) {                                 \
-                        BUG_ON(ofs != 0);                                     \
-                        ofs = phdr.p_offset = offset;                         \
-                        phdr.p_memsz = PAGE_ALIGN(phdr.p_memsz);              \
-                        phdr.p_filesz = phdr.p_memsz;                         \
-                        offset += phdr.p_filesz;                              \
-                }                                                             \
-                else                                                          \
-                        phdr.p_offset += ofs;                                 \
-                phdr.p_paddr = 0; /* match other core phdrs */                \
-                DUMP_WRITE(&phdr, sizeof(phdr));                              \
-        }                                                                     \
-} while (0)
-#define ELF_CORE_WRITE_EXTRA_DATA                                             \
-do {                                                                          \
-        const struct elf_phdr *const vsyscall_phdrs =                         \
-                (const struct elf_phdr *) (VDSO_HIGH_BASE                     \
-                                           + VDSO_HIGH_EHDR->e_phoff);    \
-        int i;                                                                \
-        for (i = 0; i < VDSO_HIGH_EHDR->e_phnum; ++i) {               \
-                if (vsyscall_phdrs[i].p_type == PT_LOAD)                      \
-                        DUMP_WRITE((void *) vsyscall_phdrs[i].p_vaddr,        \
-                                   PAGE_ALIGN(vsyscall_phdrs[i].p_memsz));    \
-        }                                                                     \
-} while (0)
-
 #endif
 
 #endif
diff --git a/include/asm-i386/fixmap.h b/include/asm-i386/fixmap.h
index 02428cb36621..3e9f610c35df 100644
--- a/include/asm-i386/fixmap.h
+++ b/include/asm-i386/fixmap.h
@@ -23,6 +23,8 @@
 extern unsigned long __FIXADDR_TOP;
 #else
 #define __FIXADDR_TOP  0xfffff000
+#define FIXADDR_USER_START      __fix_to_virt(FIX_VDSO)
+#define FIXADDR_USER_END        __fix_to_virt(FIX_VDSO - 1)
 #endif
 
 #ifndef __ASSEMBLY__
diff --git a/include/asm-i386/page.h b/include/asm-i386/page.h
index fd3f64ace248..7b19f454761d 100644
--- a/include/asm-i386/page.h
+++ b/include/asm-i386/page.h
@@ -143,7 +143,9 @@ extern int page_is_ram(unsigned long pagenr);
 #include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
+#ifndef CONFIG_COMPAT_VDSO
 #define __HAVE_ARCH_GATE_AREA 1
+#endif
 #endif /* __KERNEL__ */
 
 #endif /* _I386_PAGE_H */
diff --git a/include/asm-x86_64/uaccess.h b/include/asm-x86_64/uaccess.h
index d5dbc87274f8..c0eac519840b 100644
--- a/include/asm-x86_64/uaccess.h
+++ b/include/asm-x86_64/uaccess.h
@@ -157,7 +157,7 @@ do {									\
           case 1: __put_user_asm(x,ptr,retval,"b","b","iq",-EFAULT); break;\
           case 2: __put_user_asm(x,ptr,retval,"w","w","ir",-EFAULT); break;\
           case 4: __put_user_asm(x,ptr,retval,"l","k","ir",-EFAULT); break;\
-          case 8: __put_user_asm(x,ptr,retval,"q","","ir",-EFAULT); break;\
+          case 8: __put_user_asm(x,ptr,retval,"q","","Zr",-EFAULT); break;\
           default: __put_user_bad();                                    \
         }                                                               \
 } while (0)
diff --git a/include/linux/bitops.h b/include/linux/bitops.h
index 5d1eabcde5d5..638165f571da 100644
--- a/include/linux/bitops.h
+++ b/include/linux/bitops.h
@@ -31,9 +31,8 @@ static inline unsigned long hweight_long(unsigned long w)
         return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
 }
 
-/*
+/**
  * rol32 - rotate a 32-bit value left
- *
  * @word: value to rotate
  * @shift: bits to roll
  */
@@ -42,9 +41,8 @@ static inline __u32 rol32(__u32 word, unsigned int shift)
         return (word << shift) | (word >> (32 - shift));
 }
 
-/*
+/**
  * ror32 - rotate a 32-bit value right
- *
  * @word: value to rotate
  * @shift: bits to roll
  */
diff --git a/include/linux/kvm.h b/include/linux/kvm.h
index bc8b4616bad7..1be148f0fce4 100644
--- a/include/linux/kvm.h
+++ b/include/linux/kvm.h
@@ -46,6 +46,7 @@ enum kvm_exit_reason {
         KVM_EXIT_HLT              = 5,
         KVM_EXIT_MMIO             = 6,
         KVM_EXIT_IRQ_WINDOW_OPEN  = 7,
+        KVM_EXIT_SHUTDOWN         = 8,
 };
 
 /* for KVM_RUN */
diff --git a/include/linux/list.h b/include/linux/list.h
index a9c90287c0ff..611059d633f4 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -227,13 +227,13 @@ static inline void list_replace_init(struct list_head *old,
         INIT_LIST_HEAD(old);
 }
 
-/*
+/**
  * list_replace_rcu - replace old entry by new one
  * @old : the element to be replaced
  * @new : the new element to insert
  *
- * The old entry will be replaced with the new entry atomically.
- * Note: 'old' should not be empty.
+ * The @old entry will be replaced with the @new entry atomically.
+ * Note: @old should not be empty.
  */
 static inline void list_replace_rcu(struct list_head *old,
                                 struct list_head *new)
@@ -680,12 +680,12 @@ static inline void hlist_del_init(struct hlist_node *n)
         }
 }
 
-/*
+/**
  * hlist_replace_rcu - replace old entry by new one
  * @old : the element to be replaced
  * @new : the new element to insert
  *
- * The old entry will be replaced with the new entry atomically.
+ * The @old entry will be replaced with the @new entry atomically.
  */
 static inline void hlist_replace_rcu(struct hlist_node *old,
                                         struct hlist_node *new)
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 76912231af41..2d2c08d5f473 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -168,6 +168,7 @@ extern unsigned int kobjsize(const void *objp);
 #define VM_NONLINEAR    0x00800000      /* Is non-linear (remap_file_pages) */
 #define VM_MAPPED_COPY  0x01000000      /* T if mapped copy of data (nommu mmap) */
 #define VM_INSERTPAGE   0x02000000      /* The vma has had "vm_insert_page()" done on it */
+#define VM_ALWAYSDUMP   0x04000000      /* Always include in core dumps */
 
 #ifndef VM_STACK_DEFAULT_FLAGS          /* arch can override this */
 #define VM_STACK_DEFAULT_FLAGS VM_DATA_DEFAULT_FLAGS
diff --git a/include/linux/mutex.h b/include/linux/mutex.h
index a7544afd7582..b81bc2adaeff 100644
--- a/include/linux/mutex.h
+++ b/include/linux/mutex.h
@@ -105,7 +105,7 @@ do {							\
 extern void __mutex_init(struct mutex *lock, const char *name,
                          struct lock_class_key *key);
 
-/***
+/**
  * mutex_is_locked - is the mutex locked
  * @lock: the mutex to be queried
  *
diff --git a/include/linux/nfsd/nfsd.h b/include/linux/nfsd/nfsd.h
index 0727774772ba..4b7c4b568f6d 100644
--- a/include/linux/nfsd/nfsd.h
+++ b/include/linux/nfsd/nfsd.h
@@ -52,8 +52,6 @@
 struct readdir_cd {
         __be32                  err;    /* 0, nfserr, or nfserr_eof */
 };
-typedef int             (*encode_dent_fn)(struct readdir_cd *, const char *,
-                                                int, loff_t, ino_t, unsigned int);
 typedef int (*nfsd_dirop_t)(struct inode *, struct dentry *, int, int);
 
 extern struct svc_program       nfsd_program;
@@ -117,7 +115,7 @@ __be32		nfsd_unlink(struct svc_rqst *, struct svc_fh *, int type,
 int             nfsd_truncate(struct svc_rqst *, struct svc_fh *,
                                 unsigned long size);
 __be32          nfsd_readdir(struct svc_rqst *, struct svc_fh *,
-                             loff_t *, struct readdir_cd *, encode_dent_fn);
+                             loff_t *, struct readdir_cd *, filldir_t);
 __be32          nfsd_statfs(struct svc_rqst *, struct svc_fh *,
                                 struct kstatfs *);
 
diff --git a/include/linux/nfsd/nfsfh.h b/include/linux/nfsd/nfsfh.h
index f3b51d62ec7d..d9c6c382165d 100644
--- a/include/linux/nfsd/nfsfh.h
+++ b/include/linux/nfsd/nfsfh.h
@@ -217,11 +217,7 @@ void	fh_put(struct svc_fh *);
 static __inline__ struct svc_fh *
 fh_copy(struct svc_fh *dst, struct svc_fh *src)
 {
-        if (src->fh_dentry || src->fh_locked) {
-                struct dentry *dentry = src->fh_dentry;
-                printk(KERN_ERR "fh_copy: copying %s/%s, already verified!\n",
-                        dentry->d_parent->d_name.name, dentry->d_name.name);
-        }
+        WARN_ON(src->fh_dentry || src->fh_locked);
                         
         *dst = *src;
         return dst;
@@ -300,10 +296,8 @@ fh_lock_nested(struct svc_fh *fhp, unsigned int subclass)
         dfprintk(FILEOP, "nfsd: fh_lock(%s) locked = %d\n",
                         SVCFH_fmt(fhp), fhp->fh_locked);
 
-        if (!fhp->fh_dentry) {
-                printk(KERN_ERR "fh_lock: fh not verified!\n");
-                return;
-        }
+        BUG_ON(!dentry);
+
         if (fhp->fh_locked) {
                 printk(KERN_WARNING "fh_lock: %s/%s already locked!\n",
                         dentry->d_parent->d_name.name, dentry->d_name.name);
@@ -328,8 +322,7 @@ fh_lock(struct svc_fh *fhp)
 static inline void
 fh_unlock(struct svc_fh *fhp)
 {
-        if (!fhp->fh_dentry)
-                printk(KERN_ERR "fh_unlock: fh not verified!\n");
+        BUG_ON(!fhp->fh_dentry);
 
         if (fhp->fh_locked) {
                 fill_post_wcc(fhp);
diff --git a/include/linux/nfsd/xdr.h b/include/linux/nfsd/xdr.h
index 877192d3ae79..67885d5e6e50 100644
--- a/include/linux/nfsd/xdr.h
+++ b/include/linux/nfsd/xdr.h
@@ -165,8 +165,8 @@ int nfssvc_encode_readres(struct svc_rqst *, __be32 *, struct nfsd_readres *);
 int nfssvc_encode_statfsres(struct svc_rqst *, __be32 *, struct nfsd_statfsres *);
 int nfssvc_encode_readdirres(struct svc_rqst *, __be32 *, struct nfsd_readdirres *);
 
-int nfssvc_encode_entry(struct readdir_cd *, const char *name,
-                                int namlen, loff_t offset, ino_t ino, unsigned int);
+int nfssvc_encode_entry(void *, const char *name,
+                        int namlen, loff_t offset, u64 ino, unsigned int);
 
 int nfssvc_release_fhandle(struct svc_rqst *, __be32 *, struct nfsd_fhandle *);
 
diff --git a/include/linux/nfsd/xdr3.h b/include/linux/nfsd/xdr3.h
index 79963867b0d7..89d9d6061a62 100644
--- a/include/linux/nfsd/xdr3.h
+++ b/include/linux/nfsd/xdr3.h
@@ -331,11 +331,11 @@ int nfs3svc_release_fhandle(struct svc_rqst *, __be32 *,
                                 struct nfsd3_attrstat *);
 int nfs3svc_release_fhandle2(struct svc_rqst *, __be32 *,
                                 struct nfsd3_fhandle_pair *);
-int nfs3svc_encode_entry(struct readdir_cd *, const char *name,
-                                int namlen, loff_t offset, ino_t ino,
+int nfs3svc_encode_entry(void *, const char *name,
+                                int namlen, loff_t offset, u64 ino,
                                 unsigned int);
-int nfs3svc_encode_entry_plus(struct readdir_cd *, const char *name,
-                                int namlen, loff_t offset, ino_t ino,
+int nfs3svc_encode_entry_plus(void *, const char *name,
+                                int namlen, loff_t offset, u64 ino,
                                 unsigned int);
 /* Helper functions for NFSv3 ACL code */
 __be32 *nfs3svc_encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p,
diff --git a/include/linux/raid/md.h b/include/linux/raid/md.h
index 866a1e2b0ce0..fbaeda79b2e9 100644
--- a/include/linux/raid/md.h
+++ b/include/linux/raid/md.h
@@ -94,7 +94,7 @@ extern int sync_page_io(struct block_device *bdev, sector_t sector, int size,
                         struct page *page, int rw);
 extern void md_do_sync(mddev_t *mddev);
 extern void md_new_event(mddev_t *mddev);
-
+extern void md_allow_write(mddev_t *mddev);
 
 #endif /* CONFIG_MD */
 #endif 
diff --git a/include/linux/rtmutex.h b/include/linux/rtmutex.h
index b0090e9f7884..382bb7951166 100644
--- a/include/linux/rtmutex.h
+++ b/include/linux/rtmutex.h
@@ -16,7 +16,7 @@
 #include <linux/plist.h>
 #include <linux/spinlock_types.h>
 
-/*
+/**
  * The rt_mutex structure
  *
  * @wait_lock:  spinlock to protect the structure
@@ -71,7 +71,7 @@ struct hrtimer_sleeper;
 #define DEFINE_RT_MUTEX(mutexname) \
         struct rt_mutex mutexname = __RT_MUTEX_INITIALIZER(mutexname)
 
-/***
+/**
  * rt_mutex_is_locked - is the mutex locked
  * @lock: the mutex to be queried
  *
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h
index 965d6c20086e..64f3d60c72af 100644
--- a/include/linux/sunrpc/svc.h
+++ b/include/linux/sunrpc/svc.h
@@ -144,8 +144,11 @@ extern u32 svc_max_payload(const struct svc_rqst *rqstp);
  *
  * Each request/reply pair can have at most one "payload", plus two pages,
  * one for the request, and one for the reply.
+ * We using ->sendfile to return read data, we might need one extra page
+ * if the request is not page-aligned.  So add another '1'.
  */
-#define RPCSVC_MAXPAGES         ((RPCSVC_MAXPAYLOAD+PAGE_SIZE-1)/PAGE_SIZE + 2)
+#define RPCSVC_MAXPAGES         ((RPCSVC_MAXPAYLOAD+PAGE_SIZE-1)/PAGE_SIZE \
+                                + 2 + 1)
 
 static inline u32 svc_getnl(struct kvec *iov)
 {
diff --git a/include/linux/timer.h b/include/linux/timer.h
index eeef6643d4c6..fb5edaaf0ebd 100644
--- a/include/linux/timer.h
+++ b/include/linux/timer.h
@@ -41,7 +41,7 @@ static inline void setup_timer(struct timer_list * timer,
         init_timer(timer);
 }
 
-/***
+/**
  * timer_pending - is a timer pending?
  * @timer: the timer in question
  *
@@ -63,7 +63,7 @@ extern int mod_timer(struct timer_list *timer, unsigned long expires);
 
 extern unsigned long next_timer_interrupt(void);
 
-/***
+/**
  * add_timer - start a timer
  * @timer: the timer to be added
  *
diff --git a/mm/memory.c b/mm/memory.c
index af227d26e104..ef09f0acb1d8 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -2606,8 +2606,15 @@ static int __init gate_vma_init(void)
         gate_vma.vm_mm = NULL;
         gate_vma.vm_start = FIXADDR_USER_START;
         gate_vma.vm_end = FIXADDR_USER_END;
-        gate_vma.vm_page_prot = PAGE_READONLY;
-        gate_vma.vm_flags = 0;
+        gate_vma.vm_flags = VM_READ | VM_MAYREAD | VM_EXEC | VM_MAYEXEC;
+        gate_vma.vm_page_prot = __P101;
+        /*
+         * Make sure the vDSO gets into every core dump.
+         * Dumping its contents makes post-mortem fully interpretable later
+         * without matching up the same kernel and hardware config to see
+         * what PC values meant.
+         */
+        gate_vma.vm_flags |= VM_ALWAYSDUMP;
         return 0;
 }
 __initcall(gate_vma_init);
diff --git a/mm/truncate.c b/mm/truncate.c
index 6c79ca4a1ca7..5df947de7654 100644
--- a/mm/truncate.c
+++ b/mm/truncate.c
@@ -51,15 +51,22 @@ static inline void truncate_partial_page(struct page *page, unsigned partial)
                 do_invalidatepage(page, partial);
 }
 
+/*
+ * This cancels just the dirty bit on the kernel page itself, it
+ * does NOT actually remove dirty bits on any mmap's that may be
+ * around. It also leaves the page tagged dirty, so any sync
+ * activity will still find it on the dirty lists, and in particular,
+ * clear_page_dirty_for_io() will still look at the dirty bits in
+ * the VM.
+ *
+ * Doing this should *normally* only ever be done when a page
+ * is truncated, and is not actually mapped anywhere at all. However,
+ * fs/buffer.c does this when it notices that somebody has cleaned
+ * out all the buffers on a page without actually doing it through
+ * the VM. Can you say "ext3 is horribly ugly"? Tought you could.
+ */
 void cancel_dirty_page(struct page *page, unsigned int account_size)
 {
-        /* If we're cancelling the page, it had better not be mapped any more */
-        if (page_mapped(page)) {
-                static unsigned int warncount;
-
-                WARN_ON(++warncount < 5);
-        }
-                
         if (TestClearPageDirty(page)) {
                 struct address_space *mapping = page->mapping;
                 if (mapping && mapping_cap_account_dirty(mapping)) {
@@ -422,7 +429,6 @@ int invalidate_inode_pages2_range(struct address_space *mapping,
                 pagevec_release(&pvec);
                 cond_resched();
         }
-        WARN_ON_ONCE(ret);
         return ret;
 }
 EXPORT_SYMBOL_GPL(invalidate_inode_pages2_range);
diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c
index f3001f3626f6..bf21a2047010 100644
--- a/net/sunrpc/svc.c
+++ b/net/sunrpc/svc.c
@@ -910,7 +910,8 @@ err_bad_prog:
 
 err_bad_vers:
 #ifdef RPC_PARANOIA
-        printk("svc: unknown version (%d)\n", vers);
+        printk("svc: unknown version (%d for prog %d, %s)\n",
+               vers, prog, progp->pg_name);
 #endif
         serv->sv_stats->rpcbadfmt++;
         svc_putnl(resv, RPC_PROG_MISMATCH);
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index 99f54fb6d669..45120f268d03 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -1278,6 +1278,8 @@ svc_recv(struct svc_rqst *rqstp, long timeout)
                                 schedule_timeout_uninterruptible(msecs_to_jiffies(500));
                         rqstp->rq_pages[i] = p;
                 }
+        rqstp->rq_pages[i++] = NULL; /* this might be seen in nfs_read_actor */
+        BUG_ON(pages >= RPCSVC_MAXPAGES);
 
         /* Make arg->head point to first page and arg->pages point to rest */
         arg = &rqstp->rq_arg;