Initial commit: OpenHarmony-v4.0-ReleaseOpenHarmony-v4.0-Release

10 files changed, 974 insertions, 0 deletions

diff --git a/arch/mips/vdso/.gitignore b/arch/mips/vdso/.gitignore
new file mode 100644
index 000000000..1f43f6dd8
--- /dev/null
+++ b/arch/mips/vdso/.gitignore
@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: GPL-2.0-only
+*.so*
+vdso-*image.c
+genvdso
+vdso*.lds
diff --git a/arch/mips/vdso/Kconfig b/arch/mips/vdso/Kconfig
new file mode 100644
index 000000000..7aec72139
--- /dev/null
+++ b/arch/mips/vdso/Kconfig
@@ -0,0 +1,18 @@
+# For the pre-R6 code in arch/mips/vdso/vdso.h for locating
+# the base address of VDSO, the linker will emit a R_MIPS_PC32
+# relocation in binutils > 2.25 but it will fail with older versions
+# because that relocation is not supported for that symbol. As a result
+# of which we are forced to disable the VDSO symbols when building
+# with < 2.25 binutils on pre-R6 kernels. For more references on why we
+# can't use other methods to get the base address of VDSO please refer to
+# the comments on that file.
+#
+# GCC (at least up to version 9.2) appears to emit function calls that make use
+# of the GOT when targeting microMIPS, which we can't use in the VDSO due to
+# the lack of relocations. As such, we disable the VDSO for microMIPS builds.
+
+config MIPS_LD_CAN_LINK_VDSO
+        def_bool LD_VERSION >= 225000000 || LD_IS_LLD
+
+config MIPS_DISABLE_VDSO
+        def_bool CPU_MICROMIPS || (!CPU_MIPSR6 && !MIPS_LD_CAN_LINK_VDSO)
diff --git a/arch/mips/vdso/Makefile b/arch/mips/vdso/Makefile
new file mode 100644
index 000000000..2131d3fd7
--- /dev/null
+++ b/arch/mips/vdso/Makefile
@@ -0,0 +1,208 @@
+# SPDX-License-Identifier: GPL-2.0
+# Objects to go into the VDSO.
+
+# Absolute relocation type $(ARCH_REL_TYPE_ABS) needs to be defined before
+# the inclusion of generic Makefile.
+ARCH_REL_TYPE_ABS := R_MIPS_JUMP_SLOT|R_MIPS_GLOB_DAT
+include $(srctree)/lib/vdso/Makefile
+
+obj-vdso-y := elf.o vgettimeofday.o sigreturn.o
+
+# Common compiler flags between ABIs.
+ccflags-vdso := \
+        $(filter -I%,$(KBUILD_CFLAGS)) \
+        $(filter -E%,$(KBUILD_CFLAGS)) \
+        $(filter -mmicromips,$(KBUILD_CFLAGS)) \
+        $(filter -march=%,$(KBUILD_CFLAGS)) \
+        $(filter -m%-float,$(KBUILD_CFLAGS)) \
+        $(filter -mno-loongson-%,$(KBUILD_CFLAGS)) \
+        $(CLANG_FLAGS) \
+        -D__VDSO__
+
+ifndef CONFIG_64BIT
+ccflags-vdso += -DBUILD_VDSO32
+endif
+
+#
+# The -fno-jump-tables flag only prevents the compiler from generating
+# jump tables but does not prevent the compiler from emitting absolute
+# offsets.
+cflags-vdso := $(ccflags-vdso) \
+        $(filter -W%,$(filter-out -Wa$(comma)%,$(KBUILD_CFLAGS))) \
+        -O3 -g -fPIC -fno-strict-aliasing -fno-common -fno-builtin -G 0 \
+        -mrelax-pic-calls $(call cc-option, -mexplicit-relocs) \
+        -fno-stack-protector -fno-jump-tables -DDISABLE_BRANCH_PROFILING \
+        $(call cc-option, -fno-asynchronous-unwind-tables)
+aflags-vdso := $(ccflags-vdso) \
+        -D__ASSEMBLY__ -Wa,-gdwarf-2
+
+ifneq ($(c-gettimeofday-y),)
+CFLAGS_vgettimeofday.o = -include $(c-gettimeofday-y)
+
+# config-n32-o32-env.c prepares the environment to build a 32bit vDSO
+# library on a 64bit kernel.
+# Note: Needs to be included before than the generic library.
+CFLAGS_vgettimeofday-o32.o = -include $(srctree)/$(src)/config-n32-o32-env.c -include $(c-gettimeofday-y)
+CFLAGS_vgettimeofday-n32.o = -include $(srctree)/$(src)/config-n32-o32-env.c -include $(c-gettimeofday-y)
+endif
+
+CFLAGS_REMOVE_vgettimeofday.o = -pg
+
+ifdef CONFIG_MIPS_DISABLE_VDSO
+  ifndef CONFIG_MIPS_LD_CAN_LINK_VDSO
+    $(warning MIPS VDSO requires binutils >= 2.25)
+  endif
+  obj-vdso-y := $(filter-out vgettimeofday.o, $(obj-vdso-y))
+endif
+
+# VDSO linker flags.
+ldflags-y := -Bsymbolic --no-undefined -soname=linux-vdso.so.1 \
+        $(filter -E%,$(KBUILD_CFLAGS)) -nostdlib -shared \
+        -G 0 --eh-frame-hdr --hash-style=sysv --build-id=sha1 -T
+
+CFLAGS_REMOVE_vdso.o = -pg
+
+GCOV_PROFILE := n
+UBSAN_SANITIZE := n
+KCOV_INSTRUMENT := n
+
+# Check that we don't have PIC 'jalr t9' calls left
+quiet_cmd_vdso_mips_check = VDSOCHK $@
+      cmd_vdso_mips_check = if $(OBJDUMP) --disassemble $@ | egrep -h "jalr.*t9" > /dev/null; \
+                       then (echo >&2 "$@: PIC 'jalr t9' calls are not supported"; \
+                             rm -f $@; /bin/false); fi
+
+#
+# Shared build commands.
+#
+
+quiet_cmd_vdsold_and_vdso_check = LD      $@
+      cmd_vdsold_and_vdso_check = $(cmd_ld); $(cmd_vdso_check); $(cmd_vdso_mips_check)
+
+quiet_cmd_vdsoas_o_S = AS      $@
+      cmd_vdsoas_o_S = $(CC) $(a_flags) -c -o $@ $<
+
+# Strip rule for the raw .so files
+$(obj)/%.so.raw: OBJCOPYFLAGS := -S
+$(obj)/%.so.raw: $(obj)/%.so.dbg.raw FORCE
+        $(call if_changed,objcopy)
+
+hostprogs := genvdso
+
+quiet_cmd_genvdso = GENVDSO $@
+define cmd_genvdso
+        $(foreach file,$(filter %.raw,$^),cp $(file) $(file:%.raw=%) &&) \
+        $(obj)/genvdso $(<:%.raw=%) $(<:%.dbg.raw=%) $@ $(VDSO_NAME)
+endef
+
+#
+# Build native VDSO.
+#
+
+native-abi := $(filter -mabi=%,$(KBUILD_CFLAGS))
+
+targets += $(obj-vdso-y)
+targets += vdso.lds
+targets += vdso.so.dbg.raw vdso.so.raw
+targets += vdso.so.dbg vdso.so
+targets += vdso-image.c
+
+obj-vdso := $(obj-vdso-y:%.o=$(obj)/%.o)
+
+$(obj-vdso): KBUILD_CFLAGS := $(cflags-vdso) $(native-abi)
+$(obj-vdso): KBUILD_AFLAGS := $(aflags-vdso) $(native-abi)
+
+$(obj)/vdso.lds: KBUILD_CPPFLAGS := $(ccflags-vdso) $(native-abi)
+
+$(obj)/vdso.so.dbg.raw: $(obj)/vdso.lds $(obj-vdso) FORCE
+        $(call if_changed,vdsold_and_vdso_check)
+
+$(obj)/vdso-image.c: $(obj)/vdso.so.dbg.raw $(obj)/vdso.so.raw \
+                     $(obj)/genvdso FORCE
+        $(call if_changed,genvdso)
+
+obj-y += vdso-image.o
+
+#
+# Build O32 VDSO.
+#
+
+# Define these outside the ifdef to ensure they are picked up by clean.
+targets += $(obj-vdso-y:%.o=%-o32.o)
+targets += vdso-o32.lds
+targets += vdso-o32.so.dbg.raw vdso-o32.so.raw
+targets += vdso-o32.so.dbg vdso-o32.so
+targets += vdso-o32-image.c
+
+ifdef CONFIG_MIPS32_O32
+
+obj-vdso-o32 := $(obj-vdso-y:%.o=$(obj)/%-o32.o)
+
+$(obj-vdso-o32): KBUILD_CFLAGS := $(cflags-vdso) -mabi=32
+$(obj-vdso-o32): KBUILD_AFLAGS := $(aflags-vdso) -mabi=32
+
+$(obj)/%-o32.o: $(src)/%.S FORCE
+        $(call if_changed_dep,vdsoas_o_S)
+
+$(obj)/%-o32.o: $(src)/%.c FORCE
+        $(call cmd,force_checksrc)
+        $(call if_changed_rule,cc_o_c)
+
+$(obj)/vdso-o32.lds: KBUILD_CPPFLAGS := $(ccflags-vdso) -mabi=32
+$(obj)/vdso-o32.lds: $(src)/vdso.lds.S FORCE
+        $(call if_changed_dep,cpp_lds_S)
+
+$(obj)/vdso-o32.so.dbg.raw: $(obj)/vdso-o32.lds $(obj-vdso-o32) FORCE
+        $(call if_changed,vdsold_and_vdso_check)
+
+$(obj)/vdso-o32-image.c: VDSO_NAME := o32
+$(obj)/vdso-o32-image.c: $(obj)/vdso-o32.so.dbg.raw $(obj)/vdso-o32.so.raw \
+                         $(obj)/genvdso FORCE
+        $(call if_changed,genvdso)
+
+obj-y += vdso-o32-image.o
+
+endif
+
+#
+# Build N32 VDSO.
+#
+
+targets += $(obj-vdso-y:%.o=%-n32.o)
+targets += vdso-n32.lds
+targets += vdso-n32.so.dbg.raw vdso-n32.so.raw
+targets += vdso-n32.so.dbg vdso-n32.so
+targets += vdso-n32-image.c
+
+ifdef CONFIG_MIPS32_N32
+
+obj-vdso-n32 := $(obj-vdso-y:%.o=$(obj)/%-n32.o)
+
+$(obj-vdso-n32): KBUILD_CFLAGS := $(cflags-vdso) -mabi=n32
+$(obj-vdso-n32): KBUILD_AFLAGS := $(aflags-vdso) -mabi=n32
+
+$(obj)/%-n32.o: $(src)/%.S FORCE
+        $(call if_changed_dep,vdsoas_o_S)
+
+$(obj)/%-n32.o: $(src)/%.c FORCE
+        $(call cmd,force_checksrc)
+        $(call if_changed_rule,cc_o_c)
+
+$(obj)/vdso-n32.lds: KBUILD_CPPFLAGS := $(ccflags-vdso) -mabi=n32
+$(obj)/vdso-n32.lds: $(src)/vdso.lds.S FORCE
+        $(call if_changed_dep,cpp_lds_S)
+
+$(obj)/vdso-n32.so.dbg.raw: $(obj)/vdso-n32.lds $(obj-vdso-n32) FORCE
+        $(call if_changed,vdsold_and_vdso_check)
+
+$(obj)/vdso-n32-image.c: VDSO_NAME := n32
+$(obj)/vdso-n32-image.c: $(obj)/vdso-n32.so.dbg.raw $(obj)/vdso-n32.so.raw \
+                         $(obj)/genvdso FORCE
+        $(call if_changed,genvdso)
+
+obj-y += vdso-n32-image.o
+
+endif
+
+# FIXME: Need install rule for debug.
+# Needs to deal with dependency for generation of dbg by cmd_genvdso...
diff --git a/arch/mips/vdso/config-n32-o32-env.c b/arch/mips/vdso/config-n32-o32-env.c
new file mode 100644
index 000000000..0011a632a
--- /dev/null
+++ b/arch/mips/vdso/config-n32-o32-env.c
@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Configuration file for O32 and N32 binaries.
+ * Note: To be included before lib/vdso/gettimeofday.c
+ */
+#if defined(CONFIG_MIPS32_O32) || defined(CONFIG_MIPS32_N32)
+/*
+ * In case of a 32 bit VDSO for a 64 bit kernel fake a 32 bit kernel
+ * configuration.
+ */
+#undef CONFIG_64BIT
+
+#define BUILD_VDSO32
+#define CONFIG_32BIT 1
+#define CONFIG_GENERIC_ATOMIC64 1
+#define BUILD_VDSO32_64
+
+#endif
+
diff --git a/arch/mips/vdso/elf.S b/arch/mips/vdso/elf.S
new file mode 100644
index 000000000..a25cb147f
--- /dev/null
+++ b/arch/mips/vdso/elf.S
@@ -0,0 +1,62 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (C) 2015 Imagination Technologies
+ * Author: Alex Smith <alex.smith@imgtec.com>
+ */
+
+#include <asm/vdso/vdso.h>
+
+#include <asm/isa-rev.h>
+
+#include <linux/elfnote.h>
+#include <linux/version.h>
+
+ELFNOTE_START(Linux, 0, "a")
+        .long LINUX_VERSION_CODE
+ELFNOTE_END
+
+/*
+ * The .MIPS.abiflags section must be defined with the FP ABI flags set
+ * to 'any' to be able to link with both old and new libraries.
+ * Newer toolchains are capable of automatically generating this, but we want
+ * to work with older toolchains as well. Therefore, we define the contents of
+ * this section here (under different names), and then genvdso will patch
+ * it to have the correct name and type.
+ *
+ * We base the .MIPS.abiflags section on preprocessor definitions rather than
+ * CONFIG_* because we need to match the particular ABI we are building the
+ * VDSO for.
+ *
+ * See https://dmz-portal.mips.com/wiki/MIPS_O32_ABI_-_FR0_and_FR1_Interlinking
+ * for the .MIPS.abiflags section description.
+ */
+
+        .section .mips_abiflags, "a"
+        .align 3
+__mips_abiflags:
+        .hword  0               /* version */
+        .byte   __mips          /* isa_level */
+
+        /* isa_rev */
+        .byte   MIPS_ISA_REV
+
+        /* gpr_size */
+#ifdef __mips64
+        .byte   2               /* AFL_REG_64 */
+#else
+        .byte   1               /* AFL_REG_32 */
+#endif
+
+        /* cpr1_size */
+#if (MIPS_ISA_REV >= 6) || defined(__mips64)
+        .byte   2               /* AFL_REG_64 */
+#else
+        .byte   1               /* AFL_REG_32 */
+#endif
+
+        .byte   0               /* cpr2_size (AFL_REG_NONE) */
+        .byte   0               /* fp_abi (Val_GNU_MIPS_ABI_FP_ANY) */
+        .word   0               /* isa_ext */
+        .word   0               /* ases */
+        .word   0               /* flags1 */
+        .word   0               /* flags2 */
diff --git a/arch/mips/vdso/genvdso.c b/arch/mips/vdso/genvdso.c
new file mode 100644
index 000000000..abb06ae04
--- /dev/null
+++ b/arch/mips/vdso/genvdso.c
@@ -0,0 +1,312 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (C) 2015 Imagination Technologies
+ * Author: Alex Smith <alex.smith@imgtec.com>
+ */
+
+/*
+ * This tool is used to generate the real VDSO images from the raw image. It
+ * first patches up the MIPS ABI flags and GNU attributes sections defined in
+ * elf.S to have the correct name and type. It then generates a C source file
+ * to be compiled into the kernel containing the VDSO image data and a
+ * mips_vdso_image struct for it, including symbol offsets extracted from the
+ * image.
+ *
+ * We need to be passed both a stripped and unstripped VDSO image. The stripped
+ * image is compiled into the kernel, but we must also patch up the unstripped
+ * image's ABI flags sections so that it can be installed and used for
+ * debugging.
+ */
+
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <byteswap.h>
+#include <elf.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/* Define these in case the system elf.h is not new enough to have them. */
+#ifndef SHT_GNU_ATTRIBUTES
+# define SHT_GNU_ATTRIBUTES     0x6ffffff5
+#endif
+#ifndef SHT_MIPS_ABIFLAGS
+# define SHT_MIPS_ABIFLAGS      0x7000002a
+#endif
+
+enum {
+        ABI_O32 = (1 << 0),
+        ABI_N32 = (1 << 1),
+        ABI_N64 = (1 << 2),
+
+        ABI_ALL = ABI_O32 | ABI_N32 | ABI_N64,
+};
+
+/* Symbols the kernel requires offsets for. */
+static struct {
+        const char *name;
+        const char *offset_name;
+        unsigned int abis;
+} vdso_symbols[] = {
+        { "__vdso_sigreturn", "off_sigreturn", ABI_O32 },
+        { "__vdso_rt_sigreturn", "off_rt_sigreturn", ABI_ALL },
+        {}
+};
+
+static const char *program_name;
+static const char *vdso_name;
+static unsigned char elf_class;
+static unsigned int elf_abi;
+static bool need_swap;
+static FILE *out_file;
+
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+# define HOST_ORDER             ELFDATA2LSB
+#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+# define HOST_ORDER             ELFDATA2MSB
+#endif
+
+#define BUILD_SWAP(bits)                                                \
+        static uint##bits##_t swap_uint##bits(uint##bits##_t val)       \
+        {                                                               \
+                return need_swap ? bswap_##bits(val) : val;             \
+        }
+
+BUILD_SWAP(16)
+BUILD_SWAP(32)
+BUILD_SWAP(64)
+
+#define __FUNC(name, bits) name##bits
+#define _FUNC(name, bits) __FUNC(name, bits)
+#define FUNC(name) _FUNC(name, ELF_BITS)
+
+#define __ELF(x, bits) Elf##bits##_##x
+#define _ELF(x, bits) __ELF(x, bits)
+#define ELF(x) _ELF(x, ELF_BITS)
+
+/*
+ * Include genvdso.h twice with ELF_BITS defined differently to get functions
+ * for both ELF32 and ELF64.
+ */
+
+#define ELF_BITS 64
+#include "genvdso.h"
+#undef ELF_BITS
+
+#define ELF_BITS 32
+#include "genvdso.h"
+#undef ELF_BITS
+
+static void *map_vdso(const char *path, size_t *_size)
+{
+        int fd;
+        struct stat stat;
+        void *addr;
+        const Elf32_Ehdr *ehdr;
+
+        fd = open(path, O_RDWR);
+        if (fd < 0) {
+                fprintf(stderr, "%s: Failed to open '%s': %s\n", program_name,
+                        path, strerror(errno));
+                return NULL;
+        }
+
+        if (fstat(fd, &stat) != 0) {
+                fprintf(stderr, "%s: Failed to stat '%s': %s\n", program_name,
+                        path, strerror(errno));
+                close(fd);
+                return NULL;
+        }
+
+        addr = mmap(NULL, stat.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd,
+                    0);
+        if (addr == MAP_FAILED) {
+                fprintf(stderr, "%s: Failed to map '%s': %s\n", program_name,
+                        path, strerror(errno));
+                close(fd);
+                return NULL;
+        }
+
+        /* ELF32/64 header formats are the same for the bits we're checking. */
+        ehdr = addr;
+
+        if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG) != 0) {
+                fprintf(stderr, "%s: '%s' is not an ELF file\n", program_name,
+                        path);
+                close(fd);
+                return NULL;
+        }
+
+        elf_class = ehdr->e_ident[EI_CLASS];
+        switch (elf_class) {
+        case ELFCLASS32:
+        case ELFCLASS64:
+                break;
+        default:
+                fprintf(stderr, "%s: '%s' has invalid ELF class\n",
+                        program_name, path);
+                close(fd);
+                return NULL;
+        }
+
+        switch (ehdr->e_ident[EI_DATA]) {
+        case ELFDATA2LSB:
+        case ELFDATA2MSB:
+                need_swap = ehdr->e_ident[EI_DATA] != HOST_ORDER;
+                break;
+        default:
+                fprintf(stderr, "%s: '%s' has invalid ELF data order\n",
+                        program_name, path);
+                close(fd);
+                return NULL;
+        }
+
+        if (swap_uint16(ehdr->e_machine) != EM_MIPS) {
+                fprintf(stderr,
+                        "%s: '%s' has invalid ELF machine (expected EM_MIPS)\n",
+                        program_name, path);
+                close(fd);
+                return NULL;
+        } else if (swap_uint16(ehdr->e_type) != ET_DYN) {
+                fprintf(stderr,
+                        "%s: '%s' has invalid ELF type (expected ET_DYN)\n",
+                        program_name, path);
+                close(fd);
+                return NULL;
+        }
+
+        *_size = stat.st_size;
+        close(fd);
+        return addr;
+}
+
+static bool patch_vdso(const char *path, void *vdso)
+{
+        if (elf_class == ELFCLASS64)
+                return patch_vdso64(path, vdso);
+        else
+                return patch_vdso32(path, vdso);
+}
+
+static bool get_symbols(const char *path, void *vdso)
+{
+        if (elf_class == ELFCLASS64)
+                return get_symbols64(path, vdso);
+        else
+                return get_symbols32(path, vdso);
+}
+
+int main(int argc, char **argv)
+{
+        const char *dbg_vdso_path, *vdso_path, *out_path;
+        void *dbg_vdso, *vdso;
+        size_t dbg_vdso_size, vdso_size, i;
+
+        program_name = argv[0];
+
+        if (argc < 4 || argc > 5) {
+                fprintf(stderr,
+                        "Usage: %s <debug VDSO> <stripped VDSO> <output file> [<name>]\n",
+                        program_name);
+                return EXIT_FAILURE;
+        }
+
+        dbg_vdso_path = argv[1];
+        vdso_path = argv[2];
+        out_path = argv[3];
+        vdso_name = (argc > 4) ? argv[4] : "";
+
+        dbg_vdso = map_vdso(dbg_vdso_path, &dbg_vdso_size);
+        if (!dbg_vdso)
+                return EXIT_FAILURE;
+
+        vdso = map_vdso(vdso_path, &vdso_size);
+        if (!vdso)
+                return EXIT_FAILURE;
+
+        /* Patch both the VDSOs' ABI flags sections. */
+        if (!patch_vdso(dbg_vdso_path, dbg_vdso))
+                return EXIT_FAILURE;
+        if (!patch_vdso(vdso_path, vdso))
+                return EXIT_FAILURE;
+
+        if (msync(dbg_vdso, dbg_vdso_size, MS_SYNC) != 0) {
+                fprintf(stderr, "%s: Failed to sync '%s': %s\n", program_name,
+                        dbg_vdso_path, strerror(errno));
+                return EXIT_FAILURE;
+        } else if (msync(vdso, vdso_size, MS_SYNC) != 0) {
+                fprintf(stderr, "%s: Failed to sync '%s': %s\n", program_name,
+                        vdso_path, strerror(errno));
+                return EXIT_FAILURE;
+        }
+
+        out_file = fopen(out_path, "w");
+        if (!out_file) {
+                fprintf(stderr, "%s: Failed to open '%s': %s\n", program_name,
+                        out_path, strerror(errno));
+                return EXIT_FAILURE;
+        }
+
+        fprintf(out_file, "/* Automatically generated - do not edit */\n");
+        fprintf(out_file, "#include <linux/linkage.h>\n");
+        fprintf(out_file, "#include <linux/mm.h>\n");
+        fprintf(out_file, "#include <asm/vdso.h>\n");
+        fprintf(out_file, "static int vdso_mremap(\n");
+        fprintf(out_file, "     const struct vm_special_mapping *sm,\n");
+        fprintf(out_file, "     struct vm_area_struct *new_vma)\n");
+        fprintf(out_file, "{\n");
+        fprintf(out_file, "     unsigned long new_size =\n");
+        fprintf(out_file, "     new_vma->vm_end - new_vma->vm_start;\n");
+        fprintf(out_file, "     if (vdso_image.size != new_size)\n");
+        fprintf(out_file, "             return -EINVAL;\n");
+        fprintf(out_file, "     current->mm->context.vdso =\n");
+        fprintf(out_file, "     (void *)(new_vma->vm_start);\n");
+        fprintf(out_file, "     return 0;\n");
+        fprintf(out_file, "}\n");
+
+        /* Write out the stripped VDSO data. */
+        fprintf(out_file,
+                "static unsigned char vdso_data[PAGE_ALIGN(%zu)] __page_aligned_data = {\n\t",
+                vdso_size);
+        for (i = 0; i < vdso_size; i++) {
+                if (!(i % 10))
+                        fprintf(out_file, "\n\t");
+                fprintf(out_file, "0x%02x, ", ((unsigned char *)vdso)[i]);
+        }
+        fprintf(out_file, "\n};\n");
+
+        /* Preallocate a page array. */
+        fprintf(out_file,
+                "static struct page *vdso_pages[PAGE_ALIGN(%zu) / PAGE_SIZE];\n",
+                vdso_size);
+
+        fprintf(out_file, "struct mips_vdso_image vdso_image%s%s = {\n",
+                (vdso_name[0]) ? "_" : "", vdso_name);
+        fprintf(out_file, "\t.data = vdso_data,\n");
+        fprintf(out_file, "\t.size = PAGE_ALIGN(%zu),\n", vdso_size);
+        fprintf(out_file, "\t.mapping = {\n");
+        fprintf(out_file, "\t\t.name = \"[vdso]\",\n");
+        fprintf(out_file, "\t\t.pages = vdso_pages,\n");
+        fprintf(out_file, "\t\t.mremap = vdso_mremap,\n");
+        fprintf(out_file, "\t},\n");
+
+        /* Calculate and write symbol offsets to <output file> */
+        if (!get_symbols(dbg_vdso_path, dbg_vdso)) {
+                unlink(out_path);
+                fclose(out_file);
+                return EXIT_FAILURE;
+        }
+
+        fprintf(out_file, "};\n");
+        fclose(out_file);
+
+        return EXIT_SUCCESS;
+}
diff --git a/arch/mips/vdso/genvdso.h b/arch/mips/vdso/genvdso.h
new file mode 100644
index 000000000..9bfb87403
--- /dev/null
+++ b/arch/mips/vdso/genvdso.h
@@ -0,0 +1,132 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (C) 2015 Imagination Technologies
+ * Author: Alex Smith <alex.smith@imgtec.com>
+ */
+
+static inline bool FUNC(patch_vdso)(const char *path, void *vdso)
+{
+        const ELF(Ehdr) *ehdr = vdso;
+        void *shdrs;
+        ELF(Shdr) *shdr;
+        char *shstrtab, *name;
+        uint16_t sh_count, sh_entsize, i;
+
+        shdrs = vdso + FUNC(swap_uint)(ehdr->e_shoff);
+        sh_count = swap_uint16(ehdr->e_shnum);
+        sh_entsize = swap_uint16(ehdr->e_shentsize);
+
+        shdr = shdrs + (sh_entsize * swap_uint16(ehdr->e_shstrndx));
+        shstrtab = vdso + FUNC(swap_uint)(shdr->sh_offset);
+
+        for (i = 0; i < sh_count; i++) {
+                shdr = shdrs + (i * sh_entsize);
+                name = shstrtab + swap_uint32(shdr->sh_name);
+
+                /*
+                 * Ensure there are no relocation sections - ld.so does not
+                 * relocate the VDSO so if there are relocations things will
+                 * break.
+                 */
+                switch (swap_uint32(shdr->sh_type)) {
+                case SHT_REL:
+                case SHT_RELA:
+                        fprintf(stderr,
+                                "%s: '%s' contains relocation sections\n",
+                                program_name, path);
+                        return false;
+                }
+
+                /* Check for existing sections. */
+                if (strcmp(name, ".MIPS.abiflags") == 0) {
+                        fprintf(stderr,
+                                "%s: '%s' already contains a '.MIPS.abiflags' section\n",
+                                program_name, path);
+                        return false;
+                }
+
+                if (strcmp(name, ".mips_abiflags") == 0) {
+                        strcpy(name, ".MIPS.abiflags");
+                        shdr->sh_type = swap_uint32(SHT_MIPS_ABIFLAGS);
+                        shdr->sh_entsize = shdr->sh_size;
+                }
+        }
+
+        return true;
+}
+
+static inline bool FUNC(get_symbols)(const char *path, void *vdso)
+{
+        const ELF(Ehdr) *ehdr = vdso;
+        void *shdrs, *symtab;
+        ELF(Shdr) *shdr;
+        const ELF(Sym) *sym;
+        char *strtab, *name;
+        uint16_t sh_count, sh_entsize, st_count, st_entsize, i, j;
+        uint64_t offset;
+        uint32_t flags;
+
+        shdrs = vdso + FUNC(swap_uint)(ehdr->e_shoff);
+        sh_count = swap_uint16(ehdr->e_shnum);
+        sh_entsize = swap_uint16(ehdr->e_shentsize);
+
+        for (i = 0; i < sh_count; i++) {
+                shdr = shdrs + (i * sh_entsize);
+
+                if (swap_uint32(shdr->sh_type) == SHT_SYMTAB)
+                        break;
+        }
+
+        if (i == sh_count) {
+                fprintf(stderr, "%s: '%s' has no symbol table\n", program_name,
+                        path);
+                return false;
+        }
+
+        /* Get flags */
+        flags = swap_uint32(ehdr->e_flags);
+        if (elf_class == ELFCLASS64)
+                elf_abi = ABI_N64;
+        else if (flags & EF_MIPS_ABI2)
+                elf_abi = ABI_N32;
+        else
+                elf_abi = ABI_O32;
+
+        /* Get symbol table. */
+        symtab = vdso + FUNC(swap_uint)(shdr->sh_offset);
+        st_entsize = FUNC(swap_uint)(shdr->sh_entsize);
+        st_count = FUNC(swap_uint)(shdr->sh_size) / st_entsize;
+
+        /* Get string table. */
+        shdr = shdrs + (swap_uint32(shdr->sh_link) * sh_entsize);
+        strtab = vdso + FUNC(swap_uint)(shdr->sh_offset);
+
+        /* Write offsets for symbols needed by the kernel. */
+        for (i = 0; vdso_symbols[i].name; i++) {
+                if (!(vdso_symbols[i].abis & elf_abi))
+                        continue;
+
+                for (j = 0; j < st_count; j++) {
+                        sym = symtab + (j * st_entsize);
+                        name = strtab + swap_uint32(sym->st_name);
+
+                        if (!strcmp(name, vdso_symbols[i].name)) {
+                                offset = FUNC(swap_uint)(sym->st_value);
+
+                                fprintf(out_file,
+                                        "\t.%s = 0x%" PRIx64 ",\n",
+                                        vdso_symbols[i].offset_name, offset);
+                                break;
+                        }
+                }
+
+                if (j == st_count) {
+                        fprintf(stderr,
+                                "%s: '%s' is missing required symbol '%s'\n",
+                                program_name, path, vdso_symbols[i].name);
+                        return false;
+                }
+        }
+
+        return true;
+}
diff --git a/arch/mips/vdso/sigreturn.S b/arch/mips/vdso/sigreturn.S
new file mode 100644
index 000000000..e5c0ab98a
--- /dev/null
+++ b/arch/mips/vdso/sigreturn.S
@@ -0,0 +1,35 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (C) 2015 Imagination Technologies
+ * Author: Alex Smith <alex.smith@imgtec.com>
+ */
+
+#include <asm/vdso/vdso.h>
+
+#include <uapi/asm/unistd.h>
+
+#include <asm/regdef.h>
+#include <asm/asm.h>
+
+        .section        .text
+        .cfi_sections   .debug_frame
+
+LEAF(__vdso_rt_sigreturn)
+        .cfi_signal_frame
+
+        li      v0, __NR_rt_sigreturn
+        syscall
+
+        END(__vdso_rt_sigreturn)
+
+#if _MIPS_SIM == _MIPS_SIM_ABI32
+
+LEAF(__vdso_sigreturn)
+        .cfi_signal_frame
+
+        li      v0, __NR_sigreturn
+        syscall
+
+        END(__vdso_sigreturn)
+
+#endif
diff --git a/arch/mips/vdso/vdso.lds.S b/arch/mips/vdso/vdso.lds.S
new file mode 100644
index 000000000..d90b65724
--- /dev/null
+++ b/arch/mips/vdso/vdso.lds.S
@@ -0,0 +1,105 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (C) 2015 Imagination Technologies
+ * Author: Alex Smith <alex.smith@imgtec.com>
+ */
+
+#include <asm/sgidefs.h>
+
+#if _MIPS_SIM == _MIPS_SIM_ABI64
+OUTPUT_FORMAT("elf64-tradlittlemips", "elf64-tradbigmips", "elf64-tradlittlemips")
+#elif _MIPS_SIM == _MIPS_SIM_NABI32
+OUTPUT_FORMAT("elf32-ntradlittlemips", "elf32-ntradbigmips", "elf32-ntradlittlemips")
+#else
+OUTPUT_FORMAT("elf32-tradlittlemips", "elf32-tradbigmips", "elf32-tradlittlemips")
+#endif
+
+OUTPUT_ARCH(mips)
+
+SECTIONS
+{
+        PROVIDE(_start = .);
+        . = SIZEOF_HEADERS;
+
+        /*
+         * In order to retain compatibility with older toolchains we provide the
+         * ABI flags section ourself. Newer assemblers will automatically
+         * generate .MIPS.abiflags sections so we discard such input sections,
+         * and then manually define our own section here. genvdso will patch
+         * this section to have the correct name/type.
+         */
+        .mips_abiflags  : { *(.mips_abiflags) }         :text :abiflags
+
+        .reginfo        : { *(.reginfo) }               :text :reginfo
+
+        .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
+
+        .text           : { *(.text*) }                 :text
+        PROVIDE (__etext = .);
+        PROVIDE (_etext = .);
+        PROVIDE (etext = .);
+
+        .eh_frame_hdr   : { *(.eh_frame_hdr) }          :text :eh_frame_hdr
+        .eh_frame       : { KEEP (*(.eh_frame)) }       :text
+
+        .dynamic        : { *(.dynamic) }               :text :dynamic
+
+        .rodata         : { *(.rodata*) }               :text
+
+        _end = .;
+        PROVIDE(end = .);
+
+        /DISCARD/       : {
+                *(.MIPS.abiflags)
+                *(.gnu.attributes)
+                *(.note.GNU-stack)
+                *(.data .data.* .gnu.linkonce.d.* .sdata*)
+                *(.bss .sbss .dynbss .dynsbss)
+        }
+}
+
+PHDRS
+{
+        /*
+         * Provide a PT_MIPS_ABIFLAGS header to assign the ABI flags section
+         * to. We can specify the header type directly here so no modification
+         * is needed later on.
+         */
+        abiflags        0x70000003;
+
+        /*
+         * The ABI flags header must exist directly after the PT_INTERP header,
+         * so we must explicitly place the PT_MIPS_REGINFO header after it to
+         * stop the linker putting one in at the start.
+         */
+        reginfo         0x70000000;
+
+        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 {
+#ifndef CONFIG_MIPS_DISABLE_VDSO
+        global:
+                __vdso_clock_gettime;
+                __vdso_gettimeofday;
+                __vdso_clock_getres;
+#if _MIPS_SIM != _MIPS_SIM_ABI64
+                __vdso_clock_gettime64;
+#endif
+#endif
+        local: *;
+        };
+}
diff --git a/arch/mips/vdso/vgettimeofday.c b/arch/mips/vdso/vgettimeofday.c
new file mode 100644
index 000000000..6b83b6376
--- /dev/null
+++ b/arch/mips/vdso/vgettimeofday.c
@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * MIPS64 and compat userspace implementations of gettimeofday()
+ * and similar.
+ *
+ * Copyright (C) 2015 Imagination Technologies
+ * Copyright (C) 2018 ARM Limited
+ *
+ */
+#include <linux/time.h>
+#include <linux/types.h>
+
+#if _MIPS_SIM != _MIPS_SIM_ABI64
+int __vdso_clock_gettime(clockid_t clock,
+                         struct old_timespec32 *ts)
+{
+        return __cvdso_clock_gettime32(clock, ts);
+}
+
+#ifdef CONFIG_MIPS_CLOCK_VSYSCALL
+
+/*
+ * This is behind the ifdef so that we don't provide the symbol when there's no
+ * possibility of there being a usable clocksource, because there's nothing we
+ * can do without it. When libc fails the symbol lookup it should fall back on
+ * the standard syscall path.
+ */
+int __vdso_gettimeofday(struct __kernel_old_timeval *tv,
+                        struct timezone *tz)
+{
+        return __cvdso_gettimeofday(tv, tz);
+}
+
+#endif /* CONFIG_MIPS_CLOCK_VSYSCALL */
+
+int __vdso_clock_getres(clockid_t clock_id,
+                        struct old_timespec32 *res)
+{
+        return __cvdso_clock_getres_time32(clock_id, res);
+}
+
+int __vdso_clock_gettime64(clockid_t clock,
+                           struct __kernel_timespec *ts)
+{
+        return __cvdso_clock_gettime(clock, ts);
+}
+
+#else
+
+int __vdso_clock_gettime(clockid_t clock,
+                         struct __kernel_timespec *ts)
+{
+        return __cvdso_clock_gettime(clock, ts);
+}
+
+#ifdef CONFIG_MIPS_CLOCK_VSYSCALL
+
+/*
+ * This is behind the ifdef so that we don't provide the symbol when there's no
+ * possibility of there being a usable clocksource, because there's nothing we
+ * can do without it. When libc fails the symbol lookup it should fall back on
+ * the standard syscall path.
+ */
+int __vdso_gettimeofday(struct __kernel_old_timeval *tv,
+                        struct timezone *tz)
+{
+        return __cvdso_gettimeofday(tv, tz);
+}
+
+#endif /* CONFIG_MIPS_CLOCK_VSYSCALL */
+
+int __vdso_clock_getres(clockid_t clock_id,
+                        struct __kernel_timespec *res)
+{
+        return __cvdso_clock_getres(clock_id, res);
+}
+
+#endif