30 files changed, 1271 insertions, 69 deletions

diff --git a/arch/arm/Makefile b/arch/arm/Makefile
index 7d980706bfb4..e9d1fd6067c6 100644
--- a/arch/arm/Makefile
+++ b/arch/arm/Makefile
@@ -263,6 +263,7 @@ core-$(CONFIG_FPE_FASTFPE)	+= $(FASTFPE_OBJ)
 core-$(CONFIG_VFP)              += arch/arm/vfp/
 core-$(CONFIG_XEN)              += arch/arm/xen/
 core-$(CONFIG_KVM_ARM_HOST)     += arch/arm/kvm/
+core-$(CONFIG_VDSO)             += arch/arm/vdso/
 
 # If we have a machine-specific directory, then include it in the build.
 core-y                          += arch/arm/kernel/ arch/arm/mm/ arch/arm/common/
@@ -320,6 +321,12 @@ dtbs: prepare scripts
 dtbs_install:
         $(Q)$(MAKE) $(dtbinst)=$(boot)/dts
 
+PHONY += vdso_install
+vdso_install:
+ifeq ($(CONFIG_VDSO),y)
+        $(Q)$(MAKE) $(build)=arch/arm/vdso $@
+endif
+
 # We use MRPROPER_FILES and CLEAN_FILES now
 archclean:
         $(Q)$(MAKE) $(clean)=$(boot)
@@ -344,4 +351,5 @@ define archhelp
   echo  '                  Install using (your) ~/bin/$(INSTALLKERNEL) or'
   echo  '                  (distribution) /sbin/$(INSTALLKERNEL) or'
   echo  '                  install to $$(INSTALL_PATH) and run lilo'
+  echo  '  vdso_install  - Install unstripped vdso.so to $$(INSTALL_MOD_PATH)/vdso'
 endef
diff --git a/arch/arm/include/asm/Kbuild b/arch/arm/include/asm/Kbuild
index fe74c0d1e485..eb0f43f3e3f1 100644
--- a/arch/arm/include/asm/Kbuild
+++ b/arch/arm/include/asm/Kbuild
@@ -1,6 +1,5 @@
 
 
-generic-y += auxvec.h
 generic-y += bitsperlong.h
 generic-y += cputime.h
 generic-y += current.h
diff --git a/arch/arm/include/asm/auxvec.h b/arch/arm/include/asm/auxvec.h
new file mode 100644
index 000000000000..fbd388c46299
--- /dev/null
+++ b/arch/arm/include/asm/auxvec.h
@@ -0,0 +1 @@
+#include <uapi/asm/auxvec.h>
diff --git a/arch/arm/include/asm/elf.h b/arch/arm/include/asm/elf.h
index afb9cafd3786..e2f4781630f6 100644
--- a/arch/arm/include/asm/elf.h
+++ b/arch/arm/include/asm/elf.h
@@ -1,7 +1,9 @@
 #ifndef __ASMARM_ELF_H
 #define __ASMARM_ELF_H
 
+#include <asm/auxvec.h>
 #include <asm/hwcap.h>
+#include <asm/vdso_datapage.h>
 
 /*
  * ELF register definitions..
@@ -115,7 +117,7 @@ int dump_task_regs(struct task_struct *t, elf_gregset_t *elfregs);
    the loader.  We need to make sure that it is out of the way of the program
    that it will "exec", and that there is sufficient room for the brk.  */
 
-#define ELF_ET_DYN_BASE (2 * TASK_SIZE / 3)
+#define ELF_ET_DYN_BASE (TASK_SIZE / 3 * 2)
 
 /* When the program starts, a1 contains a pointer to a function to be 
    registered with atexit, as per the SVR4 ABI.  A value of 0 means we 
@@ -130,6 +132,13 @@ extern unsigned long arch_randomize_brk(struct mm_struct *mm);
 #define arch_randomize_brk arch_randomize_brk
 
 #ifdef CONFIG_MMU
+#ifdef CONFIG_VDSO
+#define ARCH_DLINFO                                             \
+do {                                                            \
+        NEW_AUX_ENT(AT_SYSINFO_EHDR,                            \
+                    (elf_addr_t)current->mm->context.vdso);     \
+} while (0)
+#endif
 #define ARCH_HAS_SETUP_ADDITIONAL_PAGES 1
 struct linux_binprm;
 int arch_setup_additional_pages(struct linux_binprm *, int);
diff --git a/arch/arm/include/asm/mmu.h b/arch/arm/include/asm/mmu.h
index 64fd15159b7d..a5b47421059d 100644
--- a/arch/arm/include/asm/mmu.h
+++ b/arch/arm/include/asm/mmu.h
@@ -11,6 +11,9 @@ typedef struct {
 #endif
         unsigned int    vmalloc_seq;
         unsigned long   sigpage;
+#ifdef CONFIG_VDSO
+        unsigned long   vdso;
+#endif
 } mm_context_t;
 
 #ifdef CONFIG_CPU_HAS_ASID
diff --git a/arch/arm/include/asm/vdso.h b/arch/arm/include/asm/vdso.h
new file mode 100644
index 000000000000..d0295f1dd1a3
--- /dev/null
+++ b/arch/arm/include/asm/vdso.h
@@ -0,0 +1,32 @@
+#ifndef __ASM_VDSO_H
+#define __ASM_VDSO_H
+
+#ifdef __KERNEL__
+
+#ifndef __ASSEMBLY__
+
+struct mm_struct;
+
+#ifdef CONFIG_VDSO
+
+void arm_install_vdso(struct mm_struct *mm, unsigned long addr);
+
+extern char vdso_start, vdso_end;
+
+extern unsigned int vdso_total_pages;
+
+#else /* CONFIG_VDSO */
+
+static inline void arm_install_vdso(struct mm_struct *mm, unsigned long addr)
+{
+}
+
+#define vdso_total_pages 0
+
+#endif /* CONFIG_VDSO */
+
+#endif /* __ASSEMBLY__ */
+
+#endif /* __KERNEL__ */
+
+#endif /* __ASM_VDSO_H */
diff --git a/arch/arm/include/asm/vdso_datapage.h b/arch/arm/include/asm/vdso_datapage.h
new file mode 100644
index 000000000000..9be259442fca
--- /dev/null
+++ b/arch/arm/include/asm/vdso_datapage.h
@@ -0,0 +1,60 @@
+/*
+ * Adapted from arm64 version.
+ *
+ * Copyright (C) 2012 ARM Limited
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef __ASM_VDSO_DATAPAGE_H
+#define __ASM_VDSO_DATAPAGE_H
+
+#ifdef __KERNEL__
+
+#ifndef __ASSEMBLY__
+
+#include <asm/page.h>
+
+/* Try to be cache-friendly on systems that don't implement the
+ * generic timer: fit the unconditionally updated fields in the first
+ * 32 bytes.
+ */
+struct vdso_data {
+        u32 seq_count;          /* sequence count - odd during updates */
+        u16 tk_is_cntvct;       /* fall back to syscall if false */
+        u16 cs_shift;           /* clocksource shift */
+        u32 xtime_coarse_sec;   /* coarse time */
+        u32 xtime_coarse_nsec;
+
+        u32 wtm_clock_sec;      /* wall to monotonic offset */
+        u32 wtm_clock_nsec;
+        u32 xtime_clock_sec;    /* CLOCK_REALTIME - seconds */
+        u32 cs_mult;            /* clocksource multiplier */
+
+        u64 cs_cycle_last;      /* last cycle value */
+        u64 cs_mask;            /* clocksource mask */
+
+        u64 xtime_clock_snsec;  /* CLOCK_REALTIME sub-ns base */
+        u32 tz_minuteswest;     /* timezone info for gettimeofday(2) */
+        u32 tz_dsttime;
+};
+
+union vdso_data_store {
+        struct vdso_data data;
+        u8 page[PAGE_SIZE];
+};
+
+#endif /* !__ASSEMBLY__ */
+
+#endif /* __KERNEL__ */
+
+#endif /* __ASM_VDSO_DATAPAGE_H */
diff --git a/arch/arm/include/uapi/asm/Kbuild b/arch/arm/include/uapi/asm/Kbuild
index 70a1c9da30ca..a1c05f93d920 100644
--- a/arch/arm/include/uapi/asm/Kbuild
+++ b/arch/arm/include/uapi/asm/Kbuild
@@ -1,6 +1,7 @@
 # UAPI Header export list
 include include/uapi/asm-generic/Kbuild.asm
 
+header-y += auxvec.h
 header-y += byteorder.h
 header-y += fcntl.h
 header-y += hwcap.h
diff --git a/arch/arm/include/uapi/asm/auxvec.h b/arch/arm/include/uapi/asm/auxvec.h
new file mode 100644
index 000000000000..cb02a767a500
--- /dev/null
+++ b/arch/arm/include/uapi/asm/auxvec.h
@@ -0,0 +1,7 @@
+#ifndef __ASM_AUXVEC_H
+#define __ASM_AUXVEC_H
+
+/* VDSO location */
+#define AT_SYSINFO_EHDR 33
+
+#endif
diff --git a/arch/arm/kernel/Makefile b/arch/arm/kernel/Makefile
index b6544abe2f5e..ba5f83226011 100644
--- a/arch/arm/kernel/Makefile
+++ b/arch/arm/kernel/Makefile
@@ -75,6 +75,7 @@ obj-$(CONFIG_HW_PERF_EVENTS)	+= perf_event.o perf_event_cpu.o
 CFLAGS_pj4-cp0.o                := -marm
 AFLAGS_iwmmxt.o                 := -Wa,-mcpu=iwmmxt
 obj-$(CONFIG_ARM_CPU_TOPOLOGY)  += topology.o
+obj-$(CONFIG_VDSO)              += vdso.o
 
 ifneq ($(CONFIG_ARCH_EBSA110),y)
   obj-y         += io.o
diff --git a/arch/arm/kernel/asm-offsets.c b/arch/arm/kernel/asm-offsets.c
index 2d2d6087b9b1..9147008f0d51 100644
--- a/arch/arm/kernel/asm-offsets.c
+++ b/arch/arm/kernel/asm-offsets.c
@@ -25,6 +25,7 @@
 #include <asm/memory.h>
 #include <asm/procinfo.h>
 #include <asm/suspend.h>
+#include <asm/vdso_datapage.h>
 #include <asm/hardware/cache-l2x0.h>
 #include <linux/kbuild.h>
 
@@ -210,5 +211,9 @@ int main(void)
 #endif
   DEFINE(KVM_VTTBR,             offsetof(struct kvm, arch.vttbr));
 #endif
+  BLANK();
+#ifdef CONFIG_VDSO
+  DEFINE(VDSO_DATA_SIZE,        sizeof(union vdso_data_store));
+#endif
   return 0; 
 }
diff --git a/arch/arm/kernel/process.c b/arch/arm/kernel/process.c
index f810a6cc3790..f192a2a41719 100644
--- a/arch/arm/kernel/process.c
+++ b/arch/arm/kernel/process.c
@@ -334,7 +334,7 @@ const char *arch_vma_name(struct vm_area_struct *vma)
 }
 
 /* If possible, provide a placement hint at a random offset from the
- * stack for the signal page.
+ * stack for the sigpage and vdso pages.
  */
 static unsigned long sigpage_addr(const struct mm_struct *mm,
                                   unsigned int npages)
@@ -378,6 +378,7 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
 {
         struct mm_struct *mm = current->mm;
         struct vm_area_struct *vma;
+        unsigned long npages;
         unsigned long addr;
         unsigned long hint;
         int ret = 0;
@@ -387,9 +388,12 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
         if (!signal_page)
                 return -ENOMEM;
 
+        npages = 1; /* for sigpage */
+        npages += vdso_total_pages;
+
         down_write(&mm->mmap_sem);
-        hint = sigpage_addr(mm, 1);
-        addr = get_unmapped_area(NULL, hint, PAGE_SIZE, 0, 0);
+        hint = sigpage_addr(mm, npages);
+        addr = get_unmapped_area(NULL, hint, npages << PAGE_SHIFT, 0, 0);
         if (IS_ERR_VALUE(addr)) {
                 ret = addr;
                 goto up_fail;
@@ -406,6 +410,12 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
 
         mm->context.sigpage = addr;
 
+        /* Unlike the sigpage, failure to install the vdso is unlikely
+         * to be fatal to the process, so no error check needed
+         * here.
+         */
+        arm_install_vdso(mm, addr + PAGE_SIZE);
+
  up_fail:
         up_write(&mm->mmap_sem);
         return ret;
diff --git a/arch/arm/kernel/setup.c b/arch/arm/kernel/setup.c
index 910bb1796946..6c777e908a24 100644
--- a/arch/arm/kernel/setup.c
+++ b/arch/arm/kernel/setup.c
@@ -246,12 +246,9 @@ static int __get_cpu_architecture(void)
                 if (cpu_arch)
                         cpu_arch += CPU_ARCH_ARMv3;
         } else if ((read_cpuid_id() & 0x000f0000) == 0x000f0000) {
-                unsigned int mmfr0;
-
                 /* Revised CPUID format. Read the Memory Model Feature
                  * Register 0 and check for VMSAv7 or PMSAv7 */
-                asm("mrc        p15, 0, %0, c0, c1, 4"
-                    : "=r" (mmfr0));
+                unsigned int mmfr0 = read_cpuid_ext(CPUID_EXT_MMFR0);
                 if ((mmfr0 & 0x0000000f) >= 0x00000003 ||
                     (mmfr0 & 0x000000f0) >= 0x00000030)
                         cpu_arch = CPU_ARCH_ARMv7;
diff --git a/arch/arm/kernel/vdso.c b/arch/arm/kernel/vdso.c
new file mode 100644
index 000000000000..0d31d3ccab81
--- /dev/null
+++ b/arch/arm/kernel/vdso.c
@@ -0,0 +1,337 @@
+/*
+ * Adapted from arm64 version.
+ *
+ * Copyright (C) 2012 ARM Limited
+ * Copyright (C) 2015 Mentor Graphics Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/elf.h>
+#include <linux/err.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/of.h>
+#include <linux/printk.h>
+#include <linux/slab.h>
+#include <linux/timekeeper_internal.h>
+#include <linux/vmalloc.h>
+#include <asm/arch_timer.h>
+#include <asm/barrier.h>
+#include <asm/cacheflush.h>
+#include <asm/page.h>
+#include <asm/vdso.h>
+#include <asm/vdso_datapage.h>
+#include <clocksource/arm_arch_timer.h>
+
+#define MAX_SYMNAME     64
+
+static struct page **vdso_text_pagelist;
+
+/* Total number of pages needed for the data and text portions of the VDSO. */
+unsigned int vdso_total_pages __read_mostly;
+
+/*
+ * The VDSO data page.
+ */
+static union vdso_data_store vdso_data_store __page_aligned_data;
+static struct vdso_data *vdso_data = &vdso_data_store.data;
+
+static struct page *vdso_data_page;
+static struct vm_special_mapping vdso_data_mapping = {
+        .name = "[vvar]",
+        .pages = &vdso_data_page,
+};
+
+static struct vm_special_mapping vdso_text_mapping = {
+        .name = "[vdso]",
+};
+
+struct elfinfo {
+        Elf32_Ehdr      *hdr;           /* ptr to ELF */
+        Elf32_Sym       *dynsym;        /* ptr to .dynsym section */
+        unsigned long   dynsymsize;     /* size of .dynsym section */
+        char            *dynstr;        /* ptr to .dynstr section */
+};
+
+/* Cached result of boot-time check for whether the arch timer exists,
+ * and if so, whether the virtual counter is useable.
+ */
+static bool cntvct_ok __read_mostly;
+
+static bool __init cntvct_functional(void)
+{
+        struct device_node *np;
+        bool ret = false;
+
+        if (!IS_ENABLED(CONFIG_ARM_ARCH_TIMER))
+                goto out;
+
+        /* The arm_arch_timer core should export
+         * arch_timer_use_virtual or similar so we don't have to do
+         * this.
+         */
+        np = of_find_compatible_node(NULL, NULL, "arm,armv7-timer");
+        if (!np)
+                goto out_put;
+
+        if (of_property_read_bool(np, "arm,cpu-registers-not-fw-configured"))
+                goto out_put;
+
+        ret = true;
+
+out_put:
+        of_node_put(np);
+out:
+        return ret;
+}
+
+static void * __init find_section(Elf32_Ehdr *ehdr, const char *name,
+                                  unsigned long *size)
+{
+        Elf32_Shdr *sechdrs;
+        unsigned int i;
+        char *secnames;
+
+        /* Grab section headers and strings so we can tell who is who */
+        sechdrs = (void *)ehdr + ehdr->e_shoff;
+        secnames = (void *)ehdr + sechdrs[ehdr->e_shstrndx].sh_offset;
+
+        /* Find the section they want */
+        for (i = 1; i < ehdr->e_shnum; i++) {
+                if (strcmp(secnames + sechdrs[i].sh_name, name) == 0) {
+                        if (size)
+                                *size = sechdrs[i].sh_size;
+                        return (void *)ehdr + sechdrs[i].sh_offset;
+                }
+        }
+
+        if (size)
+                *size = 0;
+        return NULL;
+}
+
+static Elf32_Sym * __init find_symbol(struct elfinfo *lib, const char *symname)
+{
+        unsigned int i;
+
+        for (i = 0; i < (lib->dynsymsize / sizeof(Elf32_Sym)); i++) {
+                char name[MAX_SYMNAME], *c;
+
+                if (lib->dynsym[i].st_name == 0)
+                        continue;
+                strlcpy(name, lib->dynstr + lib->dynsym[i].st_name,
+                        MAX_SYMNAME);
+                c = strchr(name, '@');
+                if (c)
+                        *c = 0;
+                if (strcmp(symname, name) == 0)
+                        return &lib->dynsym[i];
+        }
+        return NULL;
+}
+
+static void __init vdso_nullpatch_one(struct elfinfo *lib, const char *symname)
+{
+        Elf32_Sym *sym;
+
+        sym = find_symbol(lib, symname);
+        if (!sym)
+                return;
+
+        sym->st_name = 0;
+}
+
+static void __init patch_vdso(void *ehdr)
+{
+        struct elfinfo einfo;
+
+        einfo = (struct elfinfo) {
+                .hdr = ehdr,
+        };
+
+        einfo.dynsym = find_section(einfo.hdr, ".dynsym", &einfo.dynsymsize);
+        einfo.dynstr = find_section(einfo.hdr, ".dynstr", NULL);
+
+        /* If the virtual counter is absent or non-functional we don't
+         * want programs to incur the slight additional overhead of
+         * dispatching through the VDSO only to fall back to syscalls.
+         */
+        if (!cntvct_ok) {
+                vdso_nullpatch_one(&einfo, "__vdso_gettimeofday");
+                vdso_nullpatch_one(&einfo, "__vdso_clock_gettime");
+        }
+}
+
+static int __init vdso_init(void)
+{
+        unsigned int text_pages;
+        int i;
+
+        if (memcmp(&vdso_start, "\177ELF", 4)) {
+                pr_err("VDSO is not a valid ELF object!\n");
+                return -ENOEXEC;
+        }
+
+        text_pages = (&vdso_end - &vdso_start) >> PAGE_SHIFT;
+        pr_debug("vdso: %i text pages at base %p\n", text_pages, &vdso_start);
+
+        /* Allocate the VDSO text pagelist */
+        vdso_text_pagelist = kcalloc(text_pages, sizeof(struct page *),
+                                     GFP_KERNEL);
+        if (vdso_text_pagelist == NULL)
+                return -ENOMEM;
+
+        /* Grab the VDSO data page. */
+        vdso_data_page = virt_to_page(vdso_data);
+
+        /* Grab the VDSO text pages. */
+        for (i = 0; i < text_pages; i++) {
+                struct page *page;
+
+                page = virt_to_page(&vdso_start + i * PAGE_SIZE);
+                vdso_text_pagelist[i] = page;
+        }
+
+        vdso_text_mapping.pages = vdso_text_pagelist;
+
+        vdso_total_pages = 1; /* for the data/vvar page */
+        vdso_total_pages += text_pages;
+
+        cntvct_ok = cntvct_functional();
+
+        patch_vdso(&vdso_start);
+
+        return 0;
+}
+arch_initcall(vdso_init);
+
+static int install_vvar(struct mm_struct *mm, unsigned long addr)
+{
+        struct vm_area_struct *vma;
+
+        vma = _install_special_mapping(mm, addr, PAGE_SIZE,
+                                       VM_READ | VM_MAYREAD,
+                                       &vdso_data_mapping);
+
+        return IS_ERR(vma) ? PTR_ERR(vma) : 0;
+}
+
+/* assumes mmap_sem is write-locked */
+void arm_install_vdso(struct mm_struct *mm, unsigned long addr)
+{
+        struct vm_area_struct *vma;
+        unsigned long len;
+
+        mm->context.vdso = 0;
+
+        if (vdso_text_pagelist == NULL)
+                return;
+
+        if (install_vvar(mm, addr))
+                return;
+
+        /* Account for vvar page. */
+        addr += PAGE_SIZE;
+        len = (vdso_total_pages - 1) << PAGE_SHIFT;
+
+        vma = _install_special_mapping(mm, addr, len,
+                VM_READ | VM_EXEC | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC,
+                &vdso_text_mapping);
+
+        if (!IS_ERR(vma))
+                mm->context.vdso = addr;
+}
+
+static void vdso_write_begin(struct vdso_data *vdata)
+{
+        ++vdso_data->seq_count;
+        smp_wmb(); /* Pairs with smp_rmb in vdso_read_retry */
+}
+
+static void vdso_write_end(struct vdso_data *vdata)
+{
+        smp_wmb(); /* Pairs with smp_rmb in vdso_read_begin */
+        ++vdso_data->seq_count;
+}
+
+static bool tk_is_cntvct(const struct timekeeper *tk)
+{
+        if (!IS_ENABLED(CONFIG_ARM_ARCH_TIMER))
+                return false;
+
+        if (strcmp(tk->tkr.clock->name, "arch_sys_counter") != 0)
+                return false;
+
+        return true;
+}
+
+/**
+ * update_vsyscall - update the vdso data page
+ *
+ * Increment the sequence counter, making it odd, indicating to
+ * userspace that an update is in progress.  Update the fields used
+ * for coarse clocks and, if the architected system timer is in use,
+ * the fields used for high precision clocks.  Increment the sequence
+ * counter again, making it even, indicating to userspace that the
+ * update is finished.
+ *
+ * Userspace is expected to sample seq_count before reading any other
+ * fields from the data page.  If seq_count is odd, userspace is
+ * expected to wait until it becomes even.  After copying data from
+ * the page, userspace must sample seq_count again; if it has changed
+ * from its previous value, userspace must retry the whole sequence.
+ *
+ * Calls to update_vsyscall are serialized by the timekeeping core.
+ */
+void update_vsyscall(struct timekeeper *tk)
+{
+        struct timespec xtime_coarse;
+        struct timespec64 *wtm = &tk->wall_to_monotonic;
+
+        if (!cntvct_ok) {
+                /* The entry points have been zeroed, so there is no
+                 * point in updating the data page.
+                 */
+                return;
+        }
+
+        vdso_write_begin(vdso_data);
+
+        xtime_coarse = __current_kernel_time();
+        vdso_data->tk_is_cntvct                 = tk_is_cntvct(tk);
+        vdso_data->xtime_coarse_sec             = xtime_coarse.tv_sec;
+        vdso_data->xtime_coarse_nsec            = xtime_coarse.tv_nsec;
+        vdso_data->wtm_clock_sec                = wtm->tv_sec;
+        vdso_data->wtm_clock_nsec               = wtm->tv_nsec;
+
+        if (vdso_data->tk_is_cntvct) {
+                vdso_data->cs_cycle_last        = tk->tkr.cycle_last;
+                vdso_data->xtime_clock_sec      = tk->xtime_sec;
+                vdso_data->xtime_clock_snsec    = tk->tkr.xtime_nsec;
+                vdso_data->cs_mult              = tk->tkr.mult;
+                vdso_data->cs_shift             = tk->tkr.shift;
+                vdso_data->cs_mask              = tk->tkr.mask;
+        }
+
+        vdso_write_end(vdso_data);
+
+        flush_dcache_page(virt_to_page(vdso_data));
+}
+
+void update_vsyscall_tz(void)
+{
+        vdso_data->tz_minuteswest       = sys_tz.tz_minuteswest;
+        vdso_data->tz_dsttime           = sys_tz.tz_dsttime;
+        flush_dcache_page(virt_to_page(vdso_data));
+}
diff --git a/arch/arm/mach-vexpress/Kconfig b/arch/arm/mach-vexpress/Kconfig
index 3c2509b4b694..4be537977040 100644
--- a/arch/arm/mach-vexpress/Kconfig
+++ b/arch/arm/mach-vexpress/Kconfig
@@ -42,6 +42,7 @@ if ARCH_VEXPRESS
 config ARCH_VEXPRESS_CORTEX_A5_A9_ERRATA
         bool "Enable A5 and A9 only errata work-arounds"
         default y
+        select ARM_ERRATA_643719 if SMP
         select ARM_ERRATA_720789
         select PL310_ERRATA_753970 if CACHE_L2X0
         help
diff --git a/arch/arm/mm/Kconfig b/arch/arm/mm/Kconfig
index 9b4f29e595a4..b7644310236b 100644
--- a/arch/arm/mm/Kconfig
+++ b/arch/arm/mm/Kconfig
@@ -738,7 +738,7 @@ config CPU_ICACHE_DISABLE
 
 config CPU_DCACHE_DISABLE
         bool "Disable D-Cache (C-bit)"
-        depends on CPU_CP15
+        depends on CPU_CP15 && !SMP
         help
           Say Y here to disable the processor data cache. Unless
           you have a reason not to or are unsure, say N.
@@ -825,6 +825,20 @@ config KUSER_HELPERS
           Say N here only if you are absolutely certain that you do not
           need these helpers; otherwise, the safe option is to say Y.
 
+config VDSO
+        bool "Enable VDSO for acceleration of some system calls"
+        depends on AEABI && MMU
+        default y if ARM_ARCH_TIMER
+        select GENERIC_TIME_VSYSCALL
+        help
+          Place in the process address space an ELF shared object
+          providing fast implementations of gettimeofday and
+          clock_gettime.  Systems that implement the ARM architected
+          timer will receive maximum benefit.
+
+          You must have glibc 2.22 or later for programs to seamlessly
+          take advantage of this.
+
 config DMA_CACHE_RWFO
         bool "Enable read/write for ownership DMA cache maintenance"
         depends on CPU_V6K && SMP
diff --git a/arch/arm/mm/cache-l2x0.c b/arch/arm/mm/cache-l2x0.c
index 8b933dc43e24..e309c8f35af5 100644
--- a/arch/arm/mm/cache-l2x0.c
+++ b/arch/arm/mm/cache-l2x0.c
@@ -1131,23 +1131,22 @@ static void __init l2c310_of_parse(const struct device_node *np,
         }
 
         ret = l2x0_cache_size_of_parse(np, aux_val, aux_mask, &assoc, SZ_512K);
-        if (ret)
-                return;
-
-        switch (assoc) {
-        case 16:
-                *aux_val &= ~L2X0_AUX_CTRL_ASSOC_MASK;
-                *aux_val |= L310_AUX_CTRL_ASSOCIATIVITY_16;
-                *aux_mask &= ~L2X0_AUX_CTRL_ASSOC_MASK;
-                break;
-        case 8:
-                *aux_val &= ~L2X0_AUX_CTRL_ASSOC_MASK;
-                *aux_mask &= ~L2X0_AUX_CTRL_ASSOC_MASK;
-                break;
-        default:
-                pr_err("L2C-310 OF cache associativity %d invalid, only 8 or 16 permitted\n",
-                       assoc);
-                break;
+        if (!ret) {
+                switch (assoc) {
+                case 16:
+                        *aux_val &= ~L2X0_AUX_CTRL_ASSOC_MASK;
+                        *aux_val |= L310_AUX_CTRL_ASSOCIATIVITY_16;
+                        *aux_mask &= ~L2X0_AUX_CTRL_ASSOC_MASK;
+                        break;
+                case 8:
+                        *aux_val &= ~L2X0_AUX_CTRL_ASSOC_MASK;
+                        *aux_mask &= ~L2X0_AUX_CTRL_ASSOC_MASK;
+                        break;
+                default:
+                        pr_err("L2C-310 OF cache associativity %d invalid, only 8 or 16 permitted\n",
+                               assoc);
+                        break;
+                }
         }
 
         prefetch = l2x0_saved_regs.prefetch_ctrl;
diff --git a/arch/arm/mm/dma-mapping.c b/arch/arm/mm/dma-mapping.c
index b8fe72080108..3866f81c70bc 100644
--- a/arch/arm/mm/dma-mapping.c
+++ b/arch/arm/mm/dma-mapping.c
@@ -171,7 +171,7 @@ static int __dma_supported(struct device *dev, u64 mask, bool warn)
          */
         if (sizeof(mask) != sizeof(dma_addr_t) &&
             mask > (dma_addr_t)~0 &&
-            dma_to_pfn(dev, ~0) < max_pfn) {
+            dma_to_pfn(dev, ~0) < max_pfn - 1) {
                 if (warn) {
                         dev_warn(dev, "Coherent DMA mask %#llx is larger than dma_addr_t allows\n",
                                  mask);
@@ -1150,13 +1150,28 @@ static struct page **__iommu_alloc_buffer(struct device *dev, size_t size,
         gfp |= __GFP_NOWARN | __GFP_HIGHMEM;
 
         while (count) {
-                int j, order = __fls(count);
+                int j, order;
+
+                for (order = __fls(count); order > 0; --order) {
+                        /*
+                         * We do not want OOM killer to be invoked as long
+                         * as we can fall back to single pages, so we force
+                         * __GFP_NORETRY for orders higher than zero.
+                         */
+                        pages[i] = alloc_pages(gfp | __GFP_NORETRY, order);
+                        if (pages[i])
+                                break;
+                }
 
-                pages[i] = alloc_pages(gfp, order);
-                while (!pages[i] && order)
-                        pages[i] = alloc_pages(gfp, --order);
-                if (!pages[i])
-                        goto error;
+                if (!pages[i]) {
+                        /*
+                         * Fall back to single page allocation.
+                         * Might invoke OOM killer as last resort.
+                         */
+                        pages[i] = alloc_pages(gfp, 0);
+                        if (!pages[i])
+                                goto error;
+                }
 
                 if (order) {
                         split_page(pages[i], order);
diff --git a/arch/arm/mm/fault.c b/arch/arm/mm/fault.c
index a982dc3190df..6333d9c17875 100644
--- a/arch/arm/mm/fault.c
+++ b/arch/arm/mm/fault.c
@@ -552,6 +552,7 @@ do_DataAbort(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
 
         pr_alert("Unhandled fault: %s (0x%03x) at 0x%08lx\n",
                 inf->name, fsr, addr);
+        show_pte(current->mm, addr);
 
         info.si_signo = inf->sig;
         info.si_errno = 0;
diff --git a/arch/arm/mm/pageattr.c b/arch/arm/mm/pageattr.c
index 004e35cdcfff..cf30daff8932 100644
--- a/arch/arm/mm/pageattr.c
+++ b/arch/arm/mm/pageattr.c
@@ -49,7 +49,10 @@ static int change_memory_common(unsigned long addr, int numpages,
                 WARN_ON_ONCE(1);
         }
 
-        if (!is_module_address(start) || !is_module_address(end - 1))
+        if (start < MODULES_VADDR || start >= MODULES_END)
+                return -EINVAL;
+
+        if (end < MODULES_VADDR || start >= MODULES_END)
                 return -EINVAL;
 
         data.set_mask = set_mask;
diff --git a/arch/arm/mm/proc-arm940.S b/arch/arm/mm/proc-arm940.S
index 0a0b7a9167b6..ee5b66f847c4 100644
--- a/arch/arm/mm/proc-arm940.S
+++ b/arch/arm/mm/proc-arm940.S
@@ -297,26 +297,16 @@ __arm940_setup:
         mcr     p15, 0, r0, c6, c0, 1
 
         ldr     r0, =(CONFIG_DRAM_BASE & 0xFFFFF000) @ base[31:12] of RAM
-        ldr     r1, =(CONFIG_DRAM_SIZE >> 12)   @ size of RAM (must be >= 4KB)
-        mov     r2, #10                         @ 11 is the minimum (4KB)
-1:      add     r2, r2, #1                      @ area size *= 2
-        mov     r1, r1, lsr #1
-        bne     1b                              @ count not zero r-shift
-        orr     r0, r0, r2, lsl #1              @ the area register value
-        orr     r0, r0, #1                      @ set enable bit
-        mcr     p15, 0, r0, c6, c1, 0           @ set area 1, RAM
-        mcr     p15, 0, r0, c6, c1, 1
+        ldr     r7, =CONFIG_DRAM_SIZE >> 12     @ size of RAM (must be >= 4KB)
+        pr_val  r3, r0, r7, #1
+        mcr     p15, 0, r3, c6, c1, 0           @ set area 1, RAM
+        mcr     p15, 0, r3, c6, c1, 1
 
         ldr     r0, =(CONFIG_FLASH_MEM_BASE & 0xFFFFF000) @ base[31:12] of FLASH
-        ldr     r1, =(CONFIG_FLASH_SIZE >> 12)  @ size of FLASH (must be >= 4KB)
-        mov     r2, #10                         @ 11 is the minimum (4KB)
-1:      add     r2, r2, #1                      @ area size *= 2
-        mov     r1, r1, lsr #1
-        bne     1b                              @ count not zero r-shift
-        orr     r0, r0, r2, lsl #1              @ the area register value
-        orr     r0, r0, #1                      @ set enable bit
-        mcr     p15, 0, r0, c6, c2, 0           @ set area 2, ROM/FLASH
-        mcr     p15, 0, r0, c6, c2, 1
+        ldr     r7, =CONFIG_FLASH_SIZE          @ size of FLASH (must be >= 4KB)
+        pr_val  r3, r0, r6, #1
+        mcr     p15, 0, r3, c6, c2, 0           @ set area 2, ROM/FLASH
+        mcr     p15, 0, r3, c6, c2, 1
 
         mov     r0, #0x06
         mcr     p15, 0, r0, c2, c0, 0           @ Region 1&2 cacheable
diff --git a/arch/arm/mm/proc-arm946.S b/arch/arm/mm/proc-arm946.S
index c85b40d2117e..7361837edc31 100644
--- a/arch/arm/mm/proc-arm946.S
+++ b/arch/arm/mm/proc-arm946.S
@@ -343,24 +343,14 @@ __arm946_setup:
         mcr     p15, 0, r0, c6, c0, 0           @ set region 0, default
 
         ldr     r0, =(CONFIG_DRAM_BASE & 0xFFFFF000) @ base[31:12] of RAM
-        ldr     r1, =(CONFIG_DRAM_SIZE >> 12)   @ size of RAM (must be >= 4KB)
-        mov     r2, #10                         @ 11 is the minimum (4KB)
-1:      add     r2, r2, #1                      @ area size *= 2
-        mov     r1, r1, lsr #1
-        bne     1b                              @ count not zero r-shift
-        orr     r0, r0, r2, lsl #1              @ the region register value
-        orr     r0, r0, #1                      @ set enable bit
-        mcr     p15, 0, r0, c6, c1, 0           @ set region 1, RAM
+        ldr     r7, =CONFIG_DRAM_SIZE           @ size of RAM (must be >= 4KB)
+        pr_val  r3, r0, r7, #1
+        mcr     p15, 0, r3, c6, c1, 0
 
         ldr     r0, =(CONFIG_FLASH_MEM_BASE & 0xFFFFF000) @ base[31:12] of FLASH
-        ldr     r1, =(CONFIG_FLASH_SIZE >> 12)  @ size of FLASH (must be >= 4KB)
-        mov     r2, #10                         @ 11 is the minimum (4KB)
-1:      add     r2, r2, #1                      @ area size *= 2
-        mov     r1, r1, lsr #1
-        bne     1b                              @ count not zero r-shift
-        orr     r0, r0, r2, lsl #1              @ the region register value
-        orr     r0, r0, #1                      @ set enable bit
-        mcr     p15, 0, r0, c6, c2, 0           @ set region 2, ROM/FLASH
+        ldr     r7, =CONFIG_FLASH_SIZE          @ size of FLASH (must be >= 4KB)
+        pr_val  r3, r0, r7, #1
+        mcr     p15, 0, r3, c6, c2, 0
 
         mov     r0, #0x06
         mcr     p15, 0, r0, c2, c0, 0           @ region 1,2 d-cacheable
diff --git a/arch/arm/mm/proc-macros.S b/arch/arm/mm/proc-macros.S
index 0f13b5f9281e..c671f345266a 100644
--- a/arch/arm/mm/proc-macros.S
+++ b/arch/arm/mm/proc-macros.S
@@ -335,3 +335,27 @@ ENTRY(\name\()_tlb_fns)
 .macro  initfn, func, base
         .long   \func - \base
 .endm
+
+        /*
+         * Macro to calculate the log2 size for the protection region
+         * registers. This calculates rd = log2(size) - 1.  tmp must
+         * not be the same register as rd.
+         */
+.macro  pr_sz, rd, size, tmp
+        mov     \tmp, \size, lsr #12
+        mov     \rd, #11
+1:      movs    \tmp, \tmp, lsr #1
+        addne   \rd, \rd, #1
+        bne     1b
+.endm
+
+        /*
+         * Macro to generate a protection region register value
+         * given a pre-masked address, size, and enable bit.
+         * Corrupts size.
+         */
+.macro  pr_val, dest, addr, size, enable
+        pr_sz   \dest, \size, \size             @ calculate log2(size) - 1
+        orr     \dest, \addr, \dest, lsl #1     @ mask in the region size
+        orr     \dest, \dest, \enable
+.endm
diff --git a/arch/arm/vdso/.gitignore b/arch/arm/vdso/.gitignore
new file mode 100644
index 000000000000..f8b69d84238e
--- /dev/null
+++ b/arch/arm/vdso/.gitignore
@@ -0,0 +1 @@
+vdso.lds
diff --git a/arch/arm/vdso/Makefile b/arch/arm/vdso/Makefile
new file mode 100644
index 000000000000..bab0a8be7924
--- /dev/null
+++ b/arch/arm/vdso/Makefile
@@ -0,0 +1,74 @@
+hostprogs-y := vdsomunge
+
+obj-vdso := vgettimeofday.o datapage.o
+
+# Build rules
+targets := $(obj-vdso) vdso.so vdso.so.dbg vdso.so.raw vdso.lds
+obj-vdso := $(addprefix $(obj)/, $(obj-vdso))
+
+ccflags-y := -shared -fPIC -fno-common -fno-builtin -fno-stack-protector
+ccflags-y += -nostdlib -Wl,-soname=linux-vdso.so.1 -DDISABLE_BRANCH_PROFILING
+ccflags-y += -Wl,--no-undefined $(call cc-ldoption, -Wl$(comma)--hash-style=sysv)
+
+obj-y += vdso.o
+extra-y += vdso.lds
+CPPFLAGS_vdso.lds += -P -C -U$(ARCH)
+
+CFLAGS_REMOVE_vdso.o = -pg
+
+# Force -O2 to avoid libgcc dependencies
+CFLAGS_REMOVE_vgettimeofday.o = -pg -Os
+CFLAGS_vgettimeofday.o = -O2
+
+# Disable gcov profiling for VDSO code
+GCOV_PROFILE := n
+
+# Force dependency
+$(obj)/vdso.o : $(obj)/vdso.so
+
+# Link rule for the .so file
+$(obj)/vdso.so.raw: $(src)/vdso.lds $(obj-vdso) FORCE
+        $(call if_changed,vdsold)
+
+$(obj)/vdso.so.dbg: $(obj)/vdso.so.raw $(obj)/vdsomunge FORCE
+        $(call if_changed,vdsomunge)
+
+# Strip rule for the .so file
+$(obj)/%.so: OBJCOPYFLAGS := -S
+$(obj)/%.so: $(obj)/%.so.dbg FORCE
+        $(call if_changed,objcopy)
+
+# Actual build commands
+quiet_cmd_vdsold = VDSO    $@
+      cmd_vdsold = $(CC) $(c_flags) -Wl,-T $(filter %.lds,$^) $(filter %.o,$^) \
+                   $(call cc-ldoption, -Wl$(comma)--build-id) \
+                   -Wl,-Bsymbolic -Wl,-z,max-page-size=4096 \
+                   -Wl,-z,common-page-size=4096 -o $@
+
+quiet_cmd_vdsomunge = MUNGE   $@
+      cmd_vdsomunge = $(objtree)/$(obj)/vdsomunge $< $@
+
+#
+# Install the unstripped copy of vdso.so.dbg.  If our toolchain
+# supports build-id, install .build-id links as well.
+#
+# Cribbed from arch/x86/vdso/Makefile.
+#
+quiet_cmd_vdso_install = INSTALL $<
+define cmd_vdso_install
+        cp $< "$(MODLIB)/vdso/vdso.so"; \
+        if readelf -n $< | grep -q 'Build ID'; then \
+          buildid=`readelf -n $< |grep 'Build ID' |sed -e 's/^.*Build ID: \(.*\)$$/\1/'`; \
+          first=`echo $$buildid | cut -b-2`; \
+          last=`echo $$buildid | cut -b3-`; \
+          mkdir -p "$(MODLIB)/vdso/.build-id/$$first"; \
+          ln -sf "../../vdso.so" "$(MODLIB)/vdso/.build-id/$$first/$$last.debug"; \
+        fi
+endef
+
+$(MODLIB)/vdso: FORCE
+        @mkdir -p $(MODLIB)/vdso
+
+PHONY += vdso_install
+vdso_install: $(obj)/vdso.so.dbg $(MODLIB)/vdso FORCE
+        $(call cmd,vdso_install)
diff --git a/arch/arm/vdso/datapage.S b/arch/arm/vdso/datapage.S
new file mode 100644
index 000000000000..a2e60367931b
--- /dev/null
+++ b/arch/arm/vdso/datapage.S
@@ -0,0 +1,15 @@
+#include <linux/linkage.h>
+#include <asm/asm-offsets.h>
+
+        .align 2
+.L_vdso_data_ptr:
+        .long   _start - . - VDSO_DATA_SIZE
+
+ENTRY(__get_datapage)
+        .fnstart
+        adr     r0, .L_vdso_data_ptr
+        ldr     r1, [r0]
+        add     r0, r0, r1
+        bx      lr
+        .fnend
+ENDPROC(__get_datapage)
diff --git a/arch/arm/vdso/vdso.S b/arch/arm/vdso/vdso.S
new file mode 100644
index 000000000000..b2b97e3e7bab
--- /dev/null
+++ b/arch/arm/vdso/vdso.S
@@ -0,0 +1,35 @@
+/*
+ * Adapted from arm64 version.
+ *
+ * Copyright (C) 2012 ARM Limited
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Will Deacon <will.deacon@arm.com>
+ */
+
+#include <linux/init.h>
+#include <linux/linkage.h>
+#include <linux/const.h>
+#include <asm/page.h>
+
+        __PAGE_ALIGNED_DATA
+
+        .globl vdso_start, vdso_end
+        .balign PAGE_SIZE
+vdso_start:
+        .incbin "arch/arm/vdso/vdso.so"
+        .balign PAGE_SIZE
+vdso_end:
+
+        .previous
diff --git a/arch/arm/vdso/vdso.lds.S b/arch/arm/vdso/vdso.lds.S
new file mode 100644
index 000000000000..89ca89f12d23
--- /dev/null
+++ b/arch/arm/vdso/vdso.lds.S
@@ -0,0 +1,87 @@
+/*
+ * Adapted from arm64 version.
+ *
+ * GNU linker script for the VDSO library.
+ *
+ * Copyright (C) 2012 ARM Limited
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Will Deacon <will.deacon@arm.com>
+ * Heavily based on the vDSO linker scripts for other archs.
+ */
+
+#include <linux/const.h>
+#include <asm/page.h>
+#include <asm/vdso.h>
+
+OUTPUT_FORMAT("elf32-littlearm", "elf32-bigarm", "elf32-littlearm")
+OUTPUT_ARCH(arm)
+
+SECTIONS
+{
+        PROVIDE(_start = .);
+
+        . = SIZEOF_HEADERS;
+
+        .hash           : { *(.hash) }                  :text
+        .gnu.hash       : { *(.gnu.hash) }
+        .dynsym         : { *(.dynsym) }
+        .dynstr         : { *(.dynstr) }
+        .gnu.version    : { *(.gnu.version) }
+        .gnu.version_d  : { *(.gnu.version_d) }
+        .gnu.version_r  : { *(.gnu.version_r) }
+
+        .note           : { *(.note.*) }                :text   :note
+
+
+        .eh_frame_hdr   : { *(.eh_frame_hdr) }          :text   :eh_frame_hdr
+        .eh_frame       : { KEEP (*(.eh_frame)) }       :text
+
+        .dynamic        : { *(.dynamic) }               :text   :dynamic
+
+        .rodata         : { *(.rodata*) }               :text
+
+        .text           : { *(.text*) }                 :text   =0xe7f001f2
+
+        .got            : { *(.got) }
+        .rel.plt        : { *(.rel.plt) }
+
+        /DISCARD/       : {
+                *(.note.GNU-stack)
+                *(.data .data.* .gnu.linkonce.d.* .sdata*)
+                *(.bss .sbss .dynbss .dynsbss)
+        }
+}
+
+/*
+ * We must supply the ELF program headers explicitly to get just one
+ * PT_LOAD segment, and set the flags explicitly to make segments read-only.
+ */
+PHDRS
+{
+        text            PT_LOAD         FLAGS(5) FILEHDR PHDRS; /* PF_R|PF_X */
+        dynamic         PT_DYNAMIC      FLAGS(4);               /* PF_R */
+        note            PT_NOTE         FLAGS(4);               /* PF_R */
+        eh_frame_hdr    PT_GNU_EH_FRAME;
+}
+
+VERSION
+{
+        LINUX_2.6 {
+        global:
+                __vdso_clock_gettime;
+                __vdso_gettimeofday;
+        local: *;
+        };
+}
diff --git a/arch/arm/vdso/vdsomunge.c b/arch/arm/vdso/vdsomunge.c
new file mode 100644
index 000000000000..9005b07296c8
--- /dev/null
+++ b/arch/arm/vdso/vdsomunge.c
@@ -0,0 +1,201 @@
+/*
+ * Copyright 2015 Mentor Graphics Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; version 2 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ *
+ * vdsomunge - Host program which produces a shared object
+ * architecturally specified to be usable by both soft- and hard-float
+ * programs.
+ *
+ * The Procedure Call Standard for the ARM Architecture (ARM IHI
+ * 0042E) says:
+ *
+ *      6.4.1 VFP and Base Standard Compatibility
+ *
+ *      Code compiled for the VFP calling standard is compatible with
+ *      the base standard (and vice-versa) if no floating-point or
+ *      containerized vector arguments or results are used.
+ *
+ * And ELF for the ARM Architecture (ARM IHI 0044E) (Table 4-2) says:
+ *
+ *      If both EF_ARM_ABI_FLOAT_XXXX bits are clear, conformance to the
+ *      base procedure-call standard is implied.
+ *
+ * The VDSO is built with -msoft-float, as with the rest of the ARM
+ * kernel, and uses no floating point arguments or results.  The build
+ * process will produce a shared object that may or may not have the
+ * EF_ARM_ABI_FLOAT_SOFT flag set (it seems to depend on the binutils
+ * version; binutils starting with 2.24 appears to set it).  The
+ * EF_ARM_ABI_FLOAT_HARD flag should definitely not be set, and this
+ * program will error out if it is.
+ *
+ * If the soft-float flag is set, this program clears it.  That's all
+ * it does.
+ */
+
+#define _GNU_SOURCE
+
+#include <byteswap.h>
+#include <elf.h>
+#include <errno.h>
+#include <error.h>
+#include <fcntl.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#define HOST_ORDER ELFDATA2LSB
+#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#define HOST_ORDER ELFDATA2MSB
+#endif
+
+/* Some of the ELF constants we'd like to use were added to <elf.h>
+ * relatively recently.
+ */
+#ifndef EF_ARM_EABI_VER5
+#define EF_ARM_EABI_VER5 0x05000000
+#endif
+
+#ifndef EF_ARM_ABI_FLOAT_SOFT
+#define EF_ARM_ABI_FLOAT_SOFT 0x200
+#endif
+
+#ifndef EF_ARM_ABI_FLOAT_HARD
+#define EF_ARM_ABI_FLOAT_HARD 0x400
+#endif
+
+static const char *outfile;
+
+static void cleanup(void)
+{
+        if (error_message_count > 0 && outfile != NULL)
+                unlink(outfile);
+}
+
+static Elf32_Word read_elf_word(Elf32_Word word, bool swap)
+{
+        return swap ? bswap_32(word) : word;
+}
+
+static Elf32_Half read_elf_half(Elf32_Half half, bool swap)
+{
+        return swap ? bswap_16(half) : half;
+}
+
+static void write_elf_word(Elf32_Word val, Elf32_Word *dst, bool swap)
+{
+        *dst = swap ? bswap_32(val) : val;
+}
+
+int main(int argc, char **argv)
+{
+        const Elf32_Ehdr *inhdr;
+        bool clear_soft_float;
+        const char *infile;
+        Elf32_Word e_flags;
+        const void *inbuf;
+        struct stat stat;
+        void *outbuf;
+        bool swap;
+        int outfd;
+        int infd;
+
+        atexit(cleanup);
+
+        if (argc != 3)
+                error(EXIT_FAILURE, 0, "Usage: %s [infile] [outfile]", argv[0]);
+
+        infile = argv[1];
+        outfile = argv[2];
+
+        infd = open(infile, O_RDONLY);
+        if (infd < 0)
+                error(EXIT_FAILURE, errno, "Cannot open %s", infile);
+
+        if (fstat(infd, &stat) != 0)
+                error(EXIT_FAILURE, errno, "Failed stat for %s", infile);
+
+        inbuf = mmap(NULL, stat.st_size, PROT_READ, MAP_PRIVATE, infd, 0);
+        if (inbuf == MAP_FAILED)
+                error(EXIT_FAILURE, errno, "Failed to map %s", infile);
+
+        close(infd);
+
+        inhdr = inbuf;
+
+        if (memcmp(&inhdr->e_ident, ELFMAG, SELFMAG) != 0)
+                error(EXIT_FAILURE, 0, "Not an ELF file");
+
+        if (inhdr->e_ident[EI_CLASS] != ELFCLASS32)
+                error(EXIT_FAILURE, 0, "Unsupported ELF class");
+
+        swap = inhdr->e_ident[EI_DATA] != HOST_ORDER;
+
+        if (read_elf_half(inhdr->e_type, swap) != ET_DYN)
+                error(EXIT_FAILURE, 0, "Not a shared object");
+
+        if (read_elf_half(inhdr->e_machine, swap) != EM_ARM) {
+                error(EXIT_FAILURE, 0, "Unsupported architecture %#x",
+                      inhdr->e_machine);
+        }
+
+        e_flags = read_elf_word(inhdr->e_flags, swap);
+
+        if (EF_ARM_EABI_VERSION(e_flags) != EF_ARM_EABI_VER5) {
+                error(EXIT_FAILURE, 0, "Unsupported EABI version %#x",
+                      EF_ARM_EABI_VERSION(e_flags));
+        }
+
+        if (e_flags & EF_ARM_ABI_FLOAT_HARD)
+                error(EXIT_FAILURE, 0,
+                      "Unexpected hard-float flag set in e_flags");
+
+        clear_soft_float = !!(e_flags & EF_ARM_ABI_FLOAT_SOFT);
+
+        outfd = open(outfile, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
+        if (outfd < 0)
+                error(EXIT_FAILURE, errno, "Cannot open %s", outfile);
+
+        if (ftruncate(outfd, stat.st_size) != 0)
+                error(EXIT_FAILURE, errno, "Cannot truncate %s", outfile);
+
+        outbuf = mmap(NULL, stat.st_size, PROT_READ | PROT_WRITE, MAP_SHARED,
+                      outfd, 0);
+        if (outbuf == MAP_FAILED)
+                error(EXIT_FAILURE, errno, "Failed to map %s", outfile);
+
+        close(outfd);
+
+        memcpy(outbuf, inbuf, stat.st_size);
+
+        if (clear_soft_float) {
+                Elf32_Ehdr *outhdr;
+
+                outhdr = outbuf;
+                e_flags &= ~EF_ARM_ABI_FLOAT_SOFT;
+                write_elf_word(e_flags, &outhdr->e_flags, swap);
+        }
+
+        if (msync(outbuf, stat.st_size, MS_SYNC) != 0)
+                error(EXIT_FAILURE, errno, "Failed to sync %s", outfile);
+
+        return EXIT_SUCCESS;
+}
diff --git a/arch/arm/vdso/vgettimeofday.c b/arch/arm/vdso/vgettimeofday.c
new file mode 100644
index 000000000000..79214d5ff097
--- /dev/null
+++ b/arch/arm/vdso/vgettimeofday.c
@@ -0,0 +1,282 @@
+/*
+ * Copyright 2015 Mentor Graphics Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; version 2 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/compiler.h>
+#include <linux/hrtimer.h>
+#include <linux/time.h>
+#include <asm/arch_timer.h>
+#include <asm/barrier.h>
+#include <asm/bug.h>
+#include <asm/page.h>
+#include <asm/unistd.h>
+#include <asm/vdso_datapage.h>
+
+#ifndef CONFIG_AEABI
+#error This code depends on AEABI system call conventions
+#endif
+
+extern struct vdso_data *__get_datapage(void);
+
+static notrace u32 __vdso_read_begin(const struct vdso_data *vdata)
+{
+        u32 seq;
+repeat:
+        seq = ACCESS_ONCE(vdata->seq_count);
+        if (seq & 1) {
+                cpu_relax();
+                goto repeat;
+        }
+        return seq;
+}
+
+static notrace u32 vdso_read_begin(const struct vdso_data *vdata)
+{
+        u32 seq;
+
+        seq = __vdso_read_begin(vdata);
+
+        smp_rmb(); /* Pairs with smp_wmb in vdso_write_end */
+        return seq;
+}
+
+static notrace int vdso_read_retry(const struct vdso_data *vdata, u32 start)
+{
+        smp_rmb(); /* Pairs with smp_wmb in vdso_write_begin */
+        return vdata->seq_count != start;
+}
+
+static notrace long clock_gettime_fallback(clockid_t _clkid,
+                                           struct timespec *_ts)
+{
+        register struct timespec *ts asm("r1") = _ts;
+        register clockid_t clkid asm("r0") = _clkid;
+        register long ret asm ("r0");
+        register long nr asm("r7") = __NR_clock_gettime;
+
+        asm volatile(
+        "       swi #0\n"
+        : "=r" (ret)
+        : "r" (clkid), "r" (ts), "r" (nr)
+        : "memory");
+
+        return ret;
+}
+
+static notrace int do_realtime_coarse(struct timespec *ts,
+                                      struct vdso_data *vdata)
+{
+        u32 seq;
+
+        do {
+                seq = vdso_read_begin(vdata);
+
+                ts->tv_sec = vdata->xtime_coarse_sec;
+                ts->tv_nsec = vdata->xtime_coarse_nsec;
+
+        } while (vdso_read_retry(vdata, seq));
+
+        return 0;
+}
+
+static notrace int do_monotonic_coarse(struct timespec *ts,
+                                       struct vdso_data *vdata)
+{
+        struct timespec tomono;
+        u32 seq;
+
+        do {
+                seq = vdso_read_begin(vdata);
+
+                ts->tv_sec = vdata->xtime_coarse_sec;
+                ts->tv_nsec = vdata->xtime_coarse_nsec;
+
+                tomono.tv_sec = vdata->wtm_clock_sec;
+                tomono.tv_nsec = vdata->wtm_clock_nsec;
+
+        } while (vdso_read_retry(vdata, seq));
+
+        ts->tv_sec += tomono.tv_sec;
+        timespec_add_ns(ts, tomono.tv_nsec);
+
+        return 0;
+}
+
+#ifdef CONFIG_ARM_ARCH_TIMER
+
+static notrace u64 get_ns(struct vdso_data *vdata)
+{
+        u64 cycle_delta;
+        u64 cycle_now;
+        u64 nsec;
+
+        cycle_now = arch_counter_get_cntvct();
+
+        cycle_delta = (cycle_now - vdata->cs_cycle_last) & vdata->cs_mask;
+
+        nsec = (cycle_delta * vdata->cs_mult) + vdata->xtime_clock_snsec;
+        nsec >>= vdata->cs_shift;
+
+        return nsec;
+}
+
+static notrace int do_realtime(struct timespec *ts, struct vdso_data *vdata)
+{
+        u64 nsecs;
+        u32 seq;
+
+        do {
+                seq = vdso_read_begin(vdata);
+
+                if (!vdata->tk_is_cntvct)
+                        return -1;
+
+                ts->tv_sec = vdata->xtime_clock_sec;
+                nsecs = get_ns(vdata);
+
+        } while (vdso_read_retry(vdata, seq));
+
+        ts->tv_nsec = 0;
+        timespec_add_ns(ts, nsecs);
+
+        return 0;
+}
+
+static notrace int do_monotonic(struct timespec *ts, struct vdso_data *vdata)
+{
+        struct timespec tomono;
+        u64 nsecs;
+        u32 seq;
+
+        do {
+                seq = vdso_read_begin(vdata);
+
+                if (!vdata->tk_is_cntvct)
+                        return -1;
+
+                ts->tv_sec = vdata->xtime_clock_sec;
+                nsecs = get_ns(vdata);
+
+                tomono.tv_sec = vdata->wtm_clock_sec;
+                tomono.tv_nsec = vdata->wtm_clock_nsec;
+
+        } while (vdso_read_retry(vdata, seq));
+
+        ts->tv_sec += tomono.tv_sec;
+        ts->tv_nsec = 0;
+        timespec_add_ns(ts, nsecs + tomono.tv_nsec);
+
+        return 0;
+}
+
+#else /* CONFIG_ARM_ARCH_TIMER */
+
+static notrace int do_realtime(struct timespec *ts, struct vdso_data *vdata)
+{
+        return -1;
+}
+
+static notrace int do_monotonic(struct timespec *ts, struct vdso_data *vdata)
+{
+        return -1;
+}
+
+#endif /* CONFIG_ARM_ARCH_TIMER */
+
+notrace int __vdso_clock_gettime(clockid_t clkid, struct timespec *ts)
+{
+        struct vdso_data *vdata;
+        int ret = -1;
+
+        vdata = __get_datapage();
+
+        switch (clkid) {
+        case CLOCK_REALTIME_COARSE:
+                ret = do_realtime_coarse(ts, vdata);
+                break;
+        case CLOCK_MONOTONIC_COARSE:
+                ret = do_monotonic_coarse(ts, vdata);
+                break;
+        case CLOCK_REALTIME:
+                ret = do_realtime(ts, vdata);
+                break;
+        case CLOCK_MONOTONIC:
+                ret = do_monotonic(ts, vdata);
+                break;
+        default:
+                break;
+        }
+
+        if (ret)
+                ret = clock_gettime_fallback(clkid, ts);
+
+        return ret;
+}
+
+static notrace long gettimeofday_fallback(struct timeval *_tv,
+                                          struct timezone *_tz)
+{
+        register struct timezone *tz asm("r1") = _tz;
+        register struct timeval *tv asm("r0") = _tv;
+        register long ret asm ("r0");
+        register long nr asm("r7") = __NR_gettimeofday;
+
+        asm volatile(
+        "       swi #0\n"
+        : "=r" (ret)
+        : "r" (tv), "r" (tz), "r" (nr)
+        : "memory");
+
+        return ret;
+}
+
+notrace int __vdso_gettimeofday(struct timeval *tv, struct timezone *tz)
+{
+        struct timespec ts;
+        struct vdso_data *vdata;
+        int ret;
+
+        vdata = __get_datapage();
+
+        ret = do_realtime(&ts, vdata);
+        if (ret)
+                return gettimeofday_fallback(tv, tz);
+
+        if (tv) {
+                tv->tv_sec = ts.tv_sec;
+                tv->tv_usec = ts.tv_nsec / 1000;
+        }
+        if (tz) {
+                tz->tz_minuteswest = vdata->tz_minuteswest;
+                tz->tz_dsttime = vdata->tz_dsttime;
+        }
+
+        return ret;
+}
+
+/* Avoid unresolved references emitted by GCC */
+
+void __aeabi_unwind_cpp_pr0(void)
+{
+}
+
+void __aeabi_unwind_cpp_pr1(void)
+{
+}
+
+void __aeabi_unwind_cpp_pr2(void)
+{
+}