1. Re-initialize linux porting dir.

2. Add BUILD.gn and its components
Signed-off-by: Nzhuoli <pengzhuoli@huawei.com>

BUILD.gn

+import("musl_template.gni")
+
+group("musl_all") {
+  deps = [
+    ":musl_headers",
+    ":soft_libs",
+    ":a7_soft_libs",
+    ":a7_softfp_neon_libs",
+    # ":a7_hard_neon_libs",
+  ]
+}
+
+musl_libs("soft") {
+  target_abi = "soft"
+}
+
+musl_libs("a7_soft") {
+  target_abi = "a7_soft"
+}
+
+musl_libs("a7_softfp_neon") {
+  target_abi = "a7_softfp_neon-vfpv4"
+}
+
+musl_libs("a7_hard_neon") {
+  target_abi = "a7_hard_neon-vfpv4"
+}
+
+group("musl_headers") {
+  deps = [
+    ":create_alltypes_h",
+    ":create_syscall_h",
+    ":create_version_h",
+    ":musl_copy_inc_arpa",
+    ":musl_copy_inc_bits",
+    ":musl_copy_inc_net",
+    ":musl_copy_inc_netinet",
+    ":musl_copy_inc_netpacket",
+    ":musl_copy_inc_root",
+    ":musl_copy_inc_scsi",
+    ":musl_copy_inc_sys",
+  ]
+}
+
+action("create_porting_src") {
+  script = "scripts/porting.sh"
+
+  sources = [
+    "//third_party/musl",
+  ]
+
+  outdir = [ "${target_out_dir}/${musl_ported_dir}" ]
+
+  src_files = musl_src_arch_file
+  src_files += musl_src_file
+  src_files += musl_src_ldso
+  src_files += musl_inc_bits_files
+  src_files += musl_inc_arpa_files
+  src_files += musl_inc_net_files
+  src_files += musl_inc_netinet_files
+  src_files += musl_inc_netpacket_files
+  src_files += musl_inc_scsi_files
+  src_files += musl_inc_sys_files
+  src_files += musl_inc_root_files
+  src_files += [
+    "crt/${musl_arch}/crti.s",
+    "crt/${musl_arch}/crtn.s",
+    "crt/Scrt1.c",
+    "crt/crt1.c",
+    "crt/rcrt1.c",
+    "tools/mkalltypes.sed",
+    "arch/${musl_arch}/bits/alltypes.h.in",
+    "arch/${musl_arch}/bits/syscall.h.in",
+    "include/alltypes.h.in",
+    "VERSION",
+    "tools/version.sh",
+    "tools/install.sh",
+    "scripts/install.py",
+    "scripts/create_alltypes.sh",
+    "scripts/create_vesion.sh",
+    "scripts/create_syscall.sh",
+  ]
+
+  outputs = []
+  foreach(s, src_files) {
+    outputs += [ "${target_out_dir}/${musl_ported_dir}/${s}" ]
+  }
+ 
+  args = [ "-i" ] + rebase_path(sources)
+  args += [ "-o" ] + rebase_path(outdir) 
+  args += [ "-p" ] + [ "${musl_target_os}" ]
+}
+
+action("create_alltypes_h") {
+  script = "${target_out_dir}/${musl_ported_dir}/scripts/create_alltypes.sh"
+
+  outputs = [ "${target_out_dir}/${musl_inc_out_dir}/bits/alltypes.h" ]
+
+  sources = [
+    "${target_out_dir}/${musl_ported_dir}/tools/mkalltypes.sed",
+    "${target_out_dir}/${musl_ported_dir}/arch/${musl_arch}/bits/alltypes.h.in",
+    "${target_out_dir}/${musl_ported_dir}/include/alltypes.h.in",
+  ]
+
+  args = [ "-o" ] + rebase_path(outputs, root_build_dir)
+  args += rebase_path(sources, root_build_dir)
+
+  deps = [ ":create_porting_src" ]
+}
+
+action("create_version_h") {
+  script = "${target_out_dir}/${musl_ported_dir}/scripts/create_vesion.sh"
+
+  outputs = [ "${target_out_dir}/${musl_inc_out_dir}/version.h" ]
+
+  sources = [
+    "${target_out_dir}/${musl_ported_dir}/VERSION",
+    "${target_out_dir}/${musl_ported_dir}/tools/version.sh",
+  ]
+
+  args = rebase_path(sources, root_build_dir)
+  args +=
+      [ rebase_path("${target_out_dir}/${musl_inc_out_dir}", root_build_dir) ]
+
+  deps = [ ":create_porting_src" ]
+}
+
+action("create_syscall_h") {
+  script = "${target_out_dir}/${musl_ported_dir}/scripts/create_syscall.sh"
+
+  outputs = [ "${target_out_dir}/${musl_inc_out_dir}/bits/syscall.h" ]
+
+  sources = [ "${target_out_dir}/${musl_ported_dir}/arch/${musl_arch}/bits/syscall.h.in" ]
+
+  args = rebase_path(sources, root_build_dir)
+  args += rebase_path(outputs, root_build_dir)
+
+  deps = [ ":create_porting_src" ]
+}
+
+copy("musl_copy_inc_bits") {
+  sources = []
+  sources_orig = musl_inc_bits_files
+  foreach(s, sources_orig) {
+    sources += [ "${target_out_dir}/${musl_ported_dir}/${s}" ]
+  }
+  outputs =
+      [ "${target_out_dir}/${musl_inc_out_dir}/bits/{{source_file_part}}" ]
+  deps = [ ":create_porting_src" ]
+}
+
+copy("musl_copy_inc_arpa") {
+  sources = []
+  sources_orig = musl_inc_arpa_files
+  foreach(s, sources_orig) {
+    sources += [ "${target_out_dir}/${musl_ported_dir}/${s}" ]
+  }
+  outputs =
+      [ "${target_out_dir}/${musl_inc_out_dir}/arpa/{{source_file_part}}" ]
+  deps = [ ":create_porting_src" ]
+}
+
+copy("musl_copy_inc_net") {
+  sources = []
+  sources_orig = musl_inc_net_files
+  foreach(s, sources_orig) {
+    sources += [ "${target_out_dir}/${musl_ported_dir}/${s}" ]
+  }
+  outputs = [ "${target_out_dir}/${musl_inc_out_dir}/net/{{source_file_part}}" ]
+  deps = [ ":create_porting_src" ]
+}
+
+copy("musl_copy_inc_netinet") {
+  sources = []
+  sources_orig = musl_inc_netinet_files
+  foreach(s, sources_orig) {
+    sources += [ "${target_out_dir}/${musl_ported_dir}/${s}" ]
+  }
+  outputs =
+      [ "${target_out_dir}/${musl_inc_out_dir}/netinet/{{source_file_part}}" ]
+  deps = [ ":create_porting_src" ]
+}
+
+copy("musl_copy_inc_netpacket") {
+  sources = []
+  sources_orig = musl_inc_netpacket_files
+  foreach(s, sources_orig) {
+    sources += [ "${target_out_dir}/${musl_ported_dir}/${s}" ]
+  }
+  outputs =
+      [ "${target_out_dir}/${musl_inc_out_dir}/netpacket/{{source_file_part}}" ]
+  deps = [ ":create_porting_src" ]
+}
+
+copy("musl_copy_inc_scsi") {
+  sources = []
+  sources_orig = musl_inc_scsi_files
+  foreach(s, sources_orig) {
+    sources += [ "${target_out_dir}/${musl_ported_dir}/${s}" ]
+  }
+  outputs =
+      [ "${target_out_dir}/${musl_inc_out_dir}/scsi/{{source_file_part}}" ]
+  deps = [ ":create_porting_src" ]
+}
+
+copy("musl_copy_inc_sys") {
+  sources = []
+  sources_orig = musl_inc_sys_files
+  foreach(s, sources_orig) {
+    sources += [ "${target_out_dir}/${musl_ported_dir}/${s}" ]
+  }
+  outputs = [ "${target_out_dir}/${musl_inc_out_dir}/sys/{{source_file_part}}" ]
+  deps = [ ":create_porting_src" ]
+}
+
+copy("musl_copy_inc_root") {
+  sources = []
+  sources_orig = musl_inc_root_files
+  foreach(s, sources_orig) {
+    sources += [ "${target_out_dir}/${musl_ported_dir}/${s}" ]
+  }
+  outputs = [ "${target_out_dir}/${musl_inc_out_dir}/{{source_file_part}}" ]
+  deps = [ ":create_porting_src" ]
+}

musl_config.gni

+# Copyright 2014 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+import("//build/config/sanitizers/sanitizers.gni")
+
+declare_args() {
+  if (target_cpu == "arm") {
+    musl_arch = "arm"
+  } else if (target_cpu == "arm64") {
+    musl_arch = "aarch64"
+  }
+  # musl_root = "$root_out_dir/obj/third_party/musl"
+  # musl_sub_arch = ""
+  # musl_syslib_dir = "/system/bin"
+  # musl_linker_extension = "so.1"
+}
+
+declare_args() {
+  if ((defined(target_os) && target_os == "ohos") ||
+      (defined(ohos_kernel_type) && ohos_kernel_type == "linux")) {
+    musl_target_os = "linux"
+    musl_target_triple = "${musl_arch}-linux-ohosmusl"
+  } else if (defined(ohos_kernel_type) && ohos_kernel_type == "liteos_a") {
+    musl_target_os = "liteos_a"
+    musl_target_triple = "arm-liteos"
+  }
+}
+
+declare_args() {
+  user_custom_libc = true
+  musl_ported_dir = "intermidiates/${musl_target_os}/musl_src_ported" 
+  musl_inc_out_dir = "usr/include/${musl_target_triple}"
+
+  # if (is_asan) {
+  #   musl_linker_asan_name =
+  #       musl_syslib_dir + "/ld-musl-${musl_arch}${musl_sub_arch}-asan"
+  #   musl_ldso_path =
+  #       musl_syslib_dir + "/ld-musl-${musl_arch}${musl_sub_arch}-asan." +
+  #       musl_linker_extension
+  # } else {
+  #   musl_ldso_path =
+  #       musl_syslib_dir + "/ld-musl-${musl_arch}${musl_sub_arch}." +
+  #       musl_linker_extension
+  # }
+}

musl_template.gni

+import("//build/ohos.gni")
+import("musl_src.gni")
+
+template("musl_libs") {
+
+  no_default_deps = true
+
+  forward_variables_from(invoker, ["target_abi"])
+  template_prefix = "${target_name}"
+  
+  porting_deps = [
+    "//third_party/musl:create_porting_src",
+    "//third_party/musl:create_alltypes_h",
+    "//third_party/musl:create_syscall_h",
+    "//third_party/musl:create_version_h",
+  ]
+
+  if (target_abi == "soft") {
+    static_lib_out_dir = "usr/lib/${musl_target_triple}"
+    shared_lib_out_dir = "."
+  } else {
+    static_lib_out_dir = "usr/lib/${musl_target_triple}/${target_abi}"
+    shared_lib_out_dir = "${target_abi}"
+  }
+
+  group("${template_prefix}_libs") {
+    deps = [
+      ":${template_prefix}_libc_musl_shared",
+      ":${template_prefix}_libc_musl_static",
+      ":${template_prefix}_libcrypt",
+      ":${template_prefix}_libdl",
+      ":${template_prefix}_libm",
+      ":${template_prefix}_libpthread",
+      ":${template_prefix}_libresolv",
+      ":${template_prefix}_librt",
+      ":${template_prefix}_libutil",
+      ":${template_prefix}_libxnet",
+      ":${template_prefix}_musl_crt_install_action",
+      ":${template_prefix}_create_linker",
+    ]
+  }
+
+  musl_inherited_configs = [
+    "//build/config/compiler:afdo",
+    "//build/config/compiler:afdo_optimize_size",
+    "//build/config/compiler:compiler",
+    "//build/config/compiler:compiler_arm_fpu",
+    "//build/config/compiler:compiler_arm_thumb",
+    "//build/config/compiler:chromium_code",
+    "//build/config/compiler:default_include_dirs",
+    "//build/config/compiler:default_optimization",
+    "//build/config/compiler:default_stack_frames",
+    "//build/config/compiler:default_symbols",
+    "//build/config/compiler:export_dynamic",
+    "//build/config/compiler:no_exceptions",
+    "//build/config/compiler:no_rtti",
+    "//build/config/compiler:runtime_library",
+    "//build/config/sanitizers:default_sanitizer_flags",
+  ]
+
+  config("${template_prefix}_musl_abi_config") {
+    if (target_abi == "soft") {
+      cflags = [ "-mfloat-abi=soft" ]
+    } else if (target_abi == "a7_soft") {
+      cflags = [
+        "-mcpu=cortex-a7",
+        "-mfloat-abi=soft",
+      ]
+    } else if (target_abi == "a7_softfp_neon-vfpv4") {
+      cflags = [
+        "-mcpu=cortex-a7",
+        "-mfloat-abi=softfp",
+        "-mfpu=neon-vfpv4",
+      ]
+    } else if (target_abi == "a7_hard_neon-vfpv4") {
+      cflags = [
+        "-mcpu=cortex-a7",
+        "-mfloat-abi=hard",
+        "-mfpu=neon-vfpv4",
+      ]
+    }
+  }
+
+  config("${template_prefix}_musl_config") {
+    configs = [ ":${template_prefix}_musl_abi_config" ]
+
+    include_dirs = [
+      "${target_out_dir}/${musl_ported_dir}/arch/${musl_arch}",
+      "${target_out_dir}/${musl_ported_dir}/arch/generic",
+      "${target_out_dir}/${musl_ported_dir}/src/internal",
+      "${target_out_dir}/${musl_ported_dir}/src/include",
+      "${target_out_dir}/${musl_ported_dir}/include",
+      "${target_out_dir}/${musl_inc_out_dir}",
+    ]
+
+    cflags = [
+      "--target=${musl_target_triple}",
+      "-std=c99",
+      "-nostdinc",
+      "-ffreestanding",
+      "-Wa,--noexecstack",
+      "-D_XOPEN_SOURCE=700",
+      "-Os",
+      "-pipe",
+      "-fno-omit-frame-pointer",
+      "-funwind-tables",
+      "-fasynchronous-unwind-tables",
+      "-ffunction-sections",
+      "-fdata-sections",
+      "-Werror=implicit-function-declaration",
+      "-Werror=implicit-int",
+      "-Werror=pointer-sign",
+      "-Werror=pointer-arith",
+      "-Wno-bitwise-op-parentheses",
+      "-Wno-shift-op-parentheses",
+    ]
+
+    if (musl_arch == "aarch64") {
+      cflags += [ "-Qunused-arguments" ]
+    }
+
+    ldflags = [
+      "--target=${musl_target_triple}",
+      "-fuse-ld=lld",
+    ]
+    asmflags = cflags
+  }
+
+  source_set("${template_prefix}_musl_crt") {
+    cflags = []
+    sources = [
+      "${target_out_dir}/${musl_ported_dir}/crt/${musl_arch}/crti.s",
+      "${target_out_dir}/${musl_ported_dir}/crt/${musl_arch}/crtn.s",
+      "${target_out_dir}/${musl_ported_dir}/crt/Scrt1.c",
+      "${target_out_dir}/${musl_ported_dir}/crt/crt1.c",
+      "${target_out_dir}/${musl_ported_dir}/crt/rcrt1.c",
+    ]
+
+    cflags += [
+      "-fPIC",
+      "-fno-stack-protector",
+    ]
+
+    defines = [ "CRT" ]
+
+    configs -= musl_inherited_configs
+    configs += [ ":${template_prefix}_musl_config" ]
+
+    deps = porting_deps
+
+    asmflags = cflags
+  }
+
+  source_set("${template_prefix}_musl_src") {
+    cflags = []
+    sources_orig = []
+    sources = []
+    set_sources_assignment_filter([])
+
+    sources_orig = musl_src_arch_file + musl_src_file
+    sources_orig -= musl_src_filterout
+
+    foreach(s, sources_orig) {
+      sources += [ "${target_out_dir}/${musl_ported_dir}/${s}" ]
+    }
+
+    cflags += [
+      "-fPIC",
+      "-fno-stack-protector",
+    ]
+
+    configs -= musl_inherited_configs
+    configs += [ ":${template_prefix}_musl_config" ]
+
+    deps = porting_deps
+  }
+
+  source_set("${template_prefix}_musl_ldso") {
+    cflags = []
+    cflags = [ "-fPIC" ]
+    sources = []
+    sources_orig = musl_src_ldso
+
+    foreach(s, sources_orig) {
+      sources += [ "${target_out_dir}/${musl_ported_dir}/${s}" ]
+    }
+
+    configs -= musl_inherited_configs
+    configs += [ ":${template_prefix}_musl_config" ]
+
+    deps = porting_deps
+  }
+
+  static_library("${template_prefix}_libc_musl_static") {
+    output_name = "libc"
+    complete_static_lib = true
+
+    output_dir = "${target_out_dir}/${static_lib_out_dir}"
+    deps = [ ":${template_prefix}_musl_src" ]
+  }
+
+  static_library("${template_prefix}_libm") {
+    output_dir = "${target_out_dir}/${static_lib_out_dir}"
+  }
+
+  static_library("${template_prefix}_librt") {
+    output_dir = "${target_out_dir}/${static_lib_out_dir}"
+  }
+
+  static_library("${template_prefix}_libpthread") {
+    output_dir = "${target_out_dir}/${static_lib_out_dir}"
+  }
+
+  static_library("${template_prefix}_libcrypt") {
+    output_dir = "${target_out_dir}/${static_lib_out_dir}"
+  }
+
+  static_library("${template_prefix}_libutil") {
+    output_dir = "${target_out_dir}/${static_lib_out_dir}"
+  }
+
+  static_library("${template_prefix}_libresolv") {
+    output_dir = "${target_out_dir}/${static_lib_out_dir}"
+  }
+
+  static_library("${template_prefix}_libxnet") {
+    output_dir = "${target_out_dir}/${static_lib_out_dir}"
+  }
+
+  static_library("${template_prefix}_libdl") {
+    output_dir = "${target_out_dir}/${static_lib_out_dir}"
+  }
+
+  ohos_shared_library("${template_prefix}_libc_musl_shared") {
+    output_name = "libc/${shared_lib_out_dir}/libc"
+    output_extension = "so"
+
+    ldflags = [
+      "-nostdlib",
+      "-Wl,-e,_dlstart",
+    ]
+
+    remove_configs = musl_inherited_configs
+    remove_configs += [ "//build/config:default_libs" ]
+
+    configs = [ ":${template_prefix}_musl_config" ]
+
+    deps = [
+      ":${template_prefix}_musl_ldso",
+      ":${template_prefix}_musl_src",
+    ]
+  }
+
+  action_foreach("${template_prefix}_musl_crt_install_action") {
+    redir = "${root_out_dir}/obj"
+    script = "${target_out_dir}/${musl_ported_dir}/scripts/install.py"
+    sources = [
+      "${redir}/${target_out_dir}/${musl_ported_dir}/crt/${musl_arch}/${template_prefix}_musl_crt/crti.o",
+      "${redir}/${target_out_dir}/${musl_ported_dir}/crt/${musl_arch}/${template_prefix}_musl_crt/crtn.o",
+      "${redir}/${target_out_dir}/${musl_ported_dir}/crt/${template_prefix}_musl_crt/Scrt1.o",
+      "${redir}/${target_out_dir}/${musl_ported_dir}/crt/${template_prefix}_musl_crt/crt1.o",
+      "${redir}/${target_out_dir}/${musl_ported_dir}/crt/${template_prefix}_musl_crt/rcrt1.o",
+     ]
+
+    outputs = [ "${target_out_dir}/${static_lib_out_dir}/{{source_file_part}}" ]
+
+    args = [
+      "--input",
+      "{{source}}",
+    ]
+    args += [ "--output" ] + rebase_path(outputs, root_build_dir)
+
+    deps = [ ":${template_prefix}_musl_crt" ]
+  }
+
+  action("${template_prefix}_create_linker") {
+    script = "${target_out_dir}/${musl_ported_dir}/tools/install.sh"
+    
+    sources = [ "${root_out_dir}/common/common/libc/${shared_lib_out_dir}/libc.so" ]
+
+    outputs = [ "${root_out_dir}/common/common/libc/${shared_lib_out_dir}/ld-musl-${musl_arch}.so.1" ]
+
+    args = [ 
+      "-D",
+      "-r",
+    ]
+    args +=  rebase_path(sources)
+    args +=  rebase_path(outputs)
+
+    deps = [ ":${template_prefix}_libc_musl_shared" ]
+  }
+
+}

porting/linux/user/Makefile

+#
+# Makefile for musl (requires GNU make)
+#
+# This is how simple every makefile should be...
+# No, I take that back - actually most should be less than half this size.
+#
+# Use config.mak to override any of the following variables.
+# Do not make changes here.
+#
+
+srcdir = .
+exec_prefix = /usr/local
+bindir = $(exec_prefix)/bin
+
+prefix = /usr/local/musl
+includedir = $(prefix)/include
+libdir = $(prefix)/lib
+syslibdir = /lib
+
+SRC_DIRS = $(addprefix $(srcdir)/,src/* crt ldso $(COMPAT_SRC_DIRS))
+BASE_GLOBS = $(addsuffix /*.c,$(SRC_DIRS))
+ARCH_GLOBS = $(addsuffix /$(ARCH)/*.[csS],$(SRC_DIRS))
+BASE_SRCS = $(sort $(wildcard $(BASE_GLOBS)))
+ARCH_SRCS = $(sort $(wildcard $(ARCH_GLOBS)))
+BASE_OBJS = $(patsubst $(srcdir)/%,%.o,$(basename $(BASE_SRCS)))
+ARCH_OBJS = $(patsubst $(srcdir)/%,%.o,$(basename $(ARCH_SRCS)))
+REPLACED_OBJS = $(sort $(subst /$(ARCH)/,/,$(ARCH_OBJS)))
+ALL_OBJS = $(addprefix obj/, $(filter-out $(REPLACED_OBJS), $(sort $(BASE_OBJS) $(ARCH_OBJS))))
+
+LIBC_OBJS = $(filter obj/src/%,$(ALL_OBJS)) $(filter obj/compat/%,$(ALL_OBJS))
+LDSO_OBJS = $(filter obj/ldso/%,$(ALL_OBJS:%.o=%.lo))
+CRT_OBJS = $(filter obj/crt/%,$(ALL_OBJS))
+
+AOBJS = $(LIBC_OBJS)
+LOBJS = $(LIBC_OBJS:.o=.lo)
+GENH = obj/include/bits/alltypes.h obj/include/bits/syscall.h
+GENH_INT = obj/src/internal/version.h
+IMPH = $(addprefix $(srcdir)/, src/internal/stdio_impl.h src/internal/pthread_impl.h src/internal/locale_impl.h src/internal/libc.h)
+
+LDFLAGS =
+LDFLAGS_AUTO =
+LIBCC = -lgcc
+CPPFLAGS =
+CFLAGS =
+CFLAGS_AUTO = -Os -pipe
+CFLAGS_C99FSE = -std=c99 -ffreestanding -nostdinc 
+
+CFLAGS_ALL = $(CFLAGS_C99FSE)
+CFLAGS_ALL += -D_XOPEN_SOURCE=700 -I$(srcdir)/arch/$(ARCH) -I$(srcdir)/arch/generic -Iobj/src/internal -I$(srcdir)/src/include -I$(srcdir)/src/internal -Iobj/include -I$(srcdir)/include
+CFLAGS_ALL += $(CPPFLAGS) $(CFLAGS_AUTO) $(CFLAGS)
+
+LDFLAGS_ALL = $(LDFLAGS_AUTO) $(LDFLAGS)
+
+AR      = $(CROSS_COMPILE)ar
+RANLIB  = $(CROSS_COMPILE)ranlib
+INSTALL = $(srcdir)/tools/install.sh
+
+ARCH_INCLUDES = $(wildcard $(srcdir)/arch/$(ARCH)/bits/*.h)
+GENERIC_INCLUDES = $(wildcard $(srcdir)/arch/generic/bits/*.h)
+INCLUDES = $(wildcard $(srcdir)/include/*.h $(srcdir)/include/*/*.h)
+ALL_INCLUDES = $(sort $(INCLUDES:$(srcdir)/%=%) $(GENH:obj/%=%) $(ARCH_INCLUDES:$(srcdir)/arch/$(ARCH)/%=include/%) $(GENERIC_INCLUDES:$(srcdir)/arch/generic/%=include/%))
+
+EMPTY_LIB_NAMES = m rt pthread crypt util xnet resolv dl
+EMPTY_LIBS = $(EMPTY_LIB_NAMES:%=lib/lib%.a)
+CRT_LIBS = $(addprefix lib/,$(notdir $(CRT_OBJS)))
+STATIC_LIBS = lib/libc.a
+SHARED_LIBS = lib/libc.so
+TOOL_LIBS = lib/musl-gcc.specs
+ALL_LIBS = $(CRT_LIBS) $(STATIC_LIBS) $(SHARED_LIBS) $(EMPTY_LIBS) $(TOOL_LIBS)
+ALL_TOOLS = obj/musl-gcc
+
+WRAPCC_GCC = gcc
+WRAPCC_CLANG = clang
+
+LDSO_PATHNAME = $(syslibdir)/ld-musl-$(ARCH)$(SUBARCH).so.1
+
+-include config.mak
+-include $(srcdir)/arch/$(ARCH)/arch.mak
+
+ifeq ($(ARCH),)
+
+all:
+	@echo "Please set ARCH in config.mak before running make."
+	@exit 1
+
+else
+
+all: $(ALL_LIBS) $(ALL_TOOLS)
+
+OBJ_DIRS = $(sort $(patsubst %/,%,$(dir $(ALL_LIBS) $(ALL_TOOLS) $(ALL_OBJS) $(GENH) $(GENH_INT))) obj/include)
+
+$(ALL_LIBS) $(ALL_TOOLS) $(ALL_OBJS) $(ALL_OBJS:%.o=%.lo) $(GENH) $(GENH_INT): | $(OBJ_DIRS)
+
+$(OBJ_DIRS):
+	mkdir -p $@
+
+obj/include/bits/alltypes.h: $(srcdir)/arch/$(ARCH)/bits/alltypes.h.in $(srcdir)/include/alltypes.h.in $(srcdir)/tools/mkalltypes.sed
+	sed -f $(srcdir)/tools/mkalltypes.sed $(srcdir)/arch/$(ARCH)/bits/alltypes.h.in $(srcdir)/include/alltypes.h.in > $@
+
+obj/include/bits/syscall.h: $(srcdir)/arch/$(ARCH)/bits/syscall.h.in
+	cp $< $@
+	sed -n -e s/__NR_/SYS_/p < $< >> $@
+
+obj/src/internal/version.h: $(wildcard $(srcdir)/VERSION $(srcdir)/.git)
+	printf '#define VERSION "%s"\n' "$$(cd $(srcdir); sh tools/version.sh)" > $@
+
+obj/src/internal/version.o obj/src/internal/version.lo: obj/src/internal/version.h
+
+obj/crt/rcrt1.o obj/ldso/dlstart.lo obj/ldso/dynlink.lo: $(srcdir)/src/internal/dynlink.h $(srcdir)/arch/$(ARCH)/reloc.h
+
+obj/crt/crt1.o obj/crt/scrt1.o obj/crt/rcrt1.o obj/ldso/dlstart.lo: $(srcdir)/arch/$(ARCH)/crt_arch.h
+
+obj/crt/rcrt1.o: $(srcdir)/ldso/dlstart.c
+
+obj/crt/Scrt1.o obj/crt/rcrt1.o: CFLAGS_ALL += -fPIC
+
+OPTIMIZE_SRCS = $(wildcard $(OPTIMIZE_GLOBS:%=$(srcdir)/src/%))
+$(OPTIMIZE_SRCS:$(srcdir)/%.c=obj/%.o) $(OPTIMIZE_SRCS:$(srcdir)/%.c=obj/%.lo): CFLAGS += -O3
+
+MEMOPS_OBJS = $(filter %/memcpy.o %/memmove.o %/memcmp.o %/memset.o, $(LIBC_OBJS))
+$(MEMOPS_OBJS) $(MEMOPS_OBJS:%.o=%.lo): CFLAGS_ALL += $(CFLAGS_MEMOPS)
+
+NOSSP_OBJS = $(CRT_OBJS) $(LDSO_OBJS) $(filter \
+	%/__libc_start_main.o %/__init_tls.o %/__stack_chk_fail.o \
+	%/__set_thread_area.o %/memset.o %/memcpy.o \
+	, $(LIBC_OBJS))
+$(NOSSP_OBJS) $(NOSSP_OBJS:%.o=%.lo): CFLAGS_ALL += $(CFLAGS_NOSSP)
+
+$(CRT_OBJS): CFLAGS_ALL += -DCRT
+
+$(LOBJS) $(LDSO_OBJS): CFLAGS_ALL += -fPIC
+
+CC_CMD = $(CC) $(CFLAGS_ALL) -c -o $@ $<
+
+# Choose invocation of assembler to be used
+ifeq ($(ADD_CFI),yes)
+	AS_CMD = LC_ALL=C awk -f $(srcdir)/tools/add-cfi.common.awk -f $(srcdir)/tools/add-cfi.$(ARCH).awk $< | $(CC) $(CFLAGS_ALL) -x assembler -c -o $@ -
+else
+	AS_CMD = $(CC_CMD)
+endif
+
+obj/%.o: $(srcdir)/%.s
+	$(AS_CMD)
+
+obj/%.o: $(srcdir)/%.S
+	$(CC_CMD)
+
+obj/%.o: $(srcdir)/%.c $(GENH) $(IMPH)
+	$(CC_CMD)
+
+obj/%.lo: $(srcdir)/%.s
+	$(AS_CMD)
+
+obj/%.lo: $(srcdir)/%.S
+	$(CC_CMD)
+
+obj/%.lo: $(srcdir)/%.c $(GENH) $(IMPH)
+	$(CC_CMD)
+
+lib/libc.so: $(LOBJS) $(LDSO_OBJS)
+	$(CC) $(CFLAGS_ALL) $(LDFLAGS_ALL) -nostdlib -shared \
+	-Wl,-e,_dlstart -o $@ $(LOBJS) $(LDSO_OBJS) $(LIBCC)
+
+lib/libc.a: $(AOBJS)
+	rm -f $@
+	$(AR) rc $@ $(AOBJS)
+	$(RANLIB) $@
+
+$(EMPTY_LIBS):
+	rm -f $@
+	$(AR) rc $@
+
+lib/%.o: obj/crt/$(ARCH)/%.o
+	cp $< $@
+
+lib/%.o: obj/crt/%.o
+	cp $< $@
+
+lib/musl-gcc.specs: $(srcdir)/tools/musl-gcc.specs.sh config.mak
+	sh $< "$(includedir)" "$(libdir)" "$(LDSO_PATHNAME)" > $@
+
+obj/musl-gcc: config.mak
+	printf '#!/bin/sh\nexec "$${REALGCC:-$(WRAPCC_GCC)}" "$$@" -specs "%s/musl-gcc.specs"\n' "$(libdir)" > $@
+	chmod +x $@
+
+obj/%-clang: $(srcdir)/tools/%-clang.in config.mak
+	sed -e 's!@CC@!$(WRAPCC_CLANG)!g' -e 's!@PREFIX@!$(prefix)!g' -e 's!@INCDIR@!$(includedir)!g' -e 's!@LIBDIR@!$(libdir)!g' -e 's!@LDSO@!$(LDSO_PATHNAME)!g' $< > $@
+	chmod +x $@
+
+$(DESTDIR)$(bindir)/%: obj/%
+	$(INSTALL) -D $< $@
+
+$(DESTDIR)$(libdir)/%.so: lib/%.so
+	$(INSTALL) -D -m 755 $< $@
+
+$(DESTDIR)$(libdir)/%: lib/%
+	$(INSTALL) -D -m 644 $< $@
+
+$(DESTDIR)$(includedir)/bits/%: $(srcdir)/arch/$(ARCH)/bits/%
+	$(INSTALL) -D -m 644 $< $@
+
+$(DESTDIR)$(includedir)/bits/%: $(srcdir)/arch/generic/bits/%
+	$(INSTALL) -D -m 644 $< $@
+
+$(DESTDIR)$(includedir)/bits/%: obj/include/bits/%
+	$(INSTALL) -D -m 644 $< $@
+
+$(DESTDIR)$(includedir)/%: $(srcdir)/include/%
+	$(INSTALL) -D -m 644 $< $@
+
+$(DESTDIR)$(LDSO_PATHNAME): $(DESTDIR)$(libdir)/libc.so
+	$(INSTALL) -D -r $(DESTDIR)$(libdir)/libc.so $@ || true
+
+install-libs: $(ALL_LIBS:lib/%=$(DESTDIR)$(libdir)/%) $(if $(SHARED_LIBS),$(DESTDIR)$(LDSO_PATHNAME),)
+
+install-headers: $(ALL_INCLUDES:include/%=$(DESTDIR)$(includedir)/%)
+
+install-tools: $(ALL_TOOLS:obj/%=$(DESTDIR)$(bindir)/%)
+
+install: install-libs install-headers install-tools
+
+musl-git-%.tar.gz: .git
+	 git --git-dir=$(srcdir)/.git archive --format=tar.gz --prefix=$(patsubst %.tar.gz,%,$@)/ -o $@ $(patsubst musl-git-%.tar.gz,%,$@)
+
+musl-%.tar.gz: .git
+	 git --git-dir=$(srcdir)/.git archive --format=tar.gz --prefix=$(patsubst %.tar.gz,%,$@)/ -o $@ v$(patsubst musl-%.tar.gz,%,$@)
+
+endif
+
+clean:
+	rm -rf obj lib
+
+distclean: clean
+	rm -f config.mak
+
+.PHONY: all clean install install-libs install-headers install-tools

porting/linux/user/arch/arm/bits/fenv.h

-#ifndef __ARM_PCS_VFP
-#define FE_ALL_EXCEPT 0
-#define FE_TONEAREST  0
-#else
-#define FE_INVALID    1
-#define FE_DIVBYZERO  2
-#define FE_OVERFLOW   4
-#define FE_UNDERFLOW  8
-#define FE_INEXACT    16
-#define FE_ALL_EXCEPT 31
-#define FE_TONEAREST  0
-#define FE_TOWARDZERO 0xc00000
-#endif
-#define FE_DOWNWARD   0x800000
-#define FE_UPWARD     0x400000
-
-typedef unsigned long fexcept_t;
-
-typedef struct {
-	unsigned long __cw;
-} fenv_t;
-
-#define FE_DFL_ENV      ((const fenv_t *) -1)

porting/linux/user/arch/generic/bits/shm.h

+#define SHMLBA (4*4096)
+
+struct shmid_ds {
+	struct ipc_perm shm_perm;
+	size_t shm_segsz;
+	time_t shm_atime;
+	time_t shm_dtime;
+	time_t shm_ctime;
+	pid_t shm_cpid;
+	pid_t shm_lpid;
+	unsigned long shm_nattch;
+	unsigned long __pad1;
+	unsigned long __pad2;
+};
+
+struct shminfo {
+	unsigned long shmmax, shmmin, shmmni, shmseg, shmall, __unused[4];
+};
+
+struct shm_info {
+	int __used_ids;
+	unsigned long shm_tot, shm_rss, shm_swp;
+	unsigned long __swap_attempts, __swap_successes;
+};

porting/linux/user/include/sys/capability.h

-/*
- * Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020, Huawei Device Co., Ltd. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice, this list of
- *    conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright notice, this list
- *    of conditions and the following disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- *
- * 3. Neither the name of the copyright holder nor the names of its contributors may be used
- *    to endorse or promote products derived from this software without specific prior written
- *    permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
- * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef _SYS_CAPABILITY_H
-#define _SYS_CAPABILITY_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <linux/capability.h>
-
-int capget(cap_user_header_t hdr_ptr, cap_user_data_t data_ptr);
-int capset(cap_user_header_t hdr_ptr, const cap_user_data_t data_ptr);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _SYS_CAPABILITY_H */
+int capset(void *a, void *b);
+int capget(void *a, void *b);

porting/linux/user/include/sys/socket.h

-#ifndef	_SYS_SOCKET_H
-#define	_SYS_SOCKET_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <features.h>
-
-#define __NEED_socklen_t
-#define __NEED_sa_family_t
-#define __NEED_size_t
-#define __NEED_ssize_t
-#define __NEED_uid_t
-#define __NEED_pid_t
-#define __NEED_gid_t
-#define __NEED_struct_iovec
-
-#include <bits/alltypes.h>
-
-#include <bits/socket.h>
-
-struct msghdr {
-	void *msg_name;
-	socklen_t msg_namelen;
-	struct iovec *msg_iov;
-#if __LONG_MAX > 0x7fffffff && __BYTE_ORDER == __BIG_ENDIAN
-	int __pad1;
-#endif
-	int msg_iovlen;
-#if __LONG_MAX > 0x7fffffff && __BYTE_ORDER == __LITTLE_ENDIAN
-	int __pad1;
-#endif
-	void *msg_control;
-#if __LONG_MAX > 0x7fffffff && __BYTE_ORDER == __BIG_ENDIAN
-	int __pad2;
-#endif
-	socklen_t msg_controllen;
-#if __LONG_MAX > 0x7fffffff && __BYTE_ORDER == __LITTLE_ENDIAN
-	int __pad2;
-#endif
-	int msg_flags;
-};
-
-struct cmsghdr {
-#if __LONG_MAX > 0x7fffffff && __BYTE_ORDER == __BIG_ENDIAN
-	int __pad1;
-#endif
-	socklen_t cmsg_len;
-#if __LONG_MAX > 0x7fffffff && __BYTE_ORDER == __LITTLE_ENDIAN
-	int __pad1;
-#endif
-	int cmsg_level;
-	int cmsg_type;
-};
-
-#ifdef _GNU_SOURCE
-struct ucred {
-	pid_t pid;
-	uid_t uid;
-	gid_t gid;
-};
-
-struct mmsghdr {
-	struct msghdr msg_hdr;
-	unsigned int  msg_len;
-};
-
-struct timespec;
-
-int sendmmsg (int, struct mmsghdr *, unsigned int, unsigned int);
-int recvmmsg (int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *);
-#endif
-
-struct linger {
-	int l_onoff;
-	int l_linger;
-};
-
-#define SHUT_RD 0
-#define SHUT_WR 1
-#define SHUT_RDWR 2
-
-#ifndef SOCK_STREAM
-#define SOCK_STREAM    1
-#define SOCK_DGRAM     2
-#endif
-
-#define SOCK_RAW       3
-#define SOCK_RDM       4
-#define SOCK_SEQPACKET 5
-#define SOCK_DCCP      6
-#define SOCK_PACKET    10
-
-#ifndef SOCK_CLOEXEC
-#define SOCK_CLOEXEC   02000000
-#define SOCK_NONBLOCK  04000
-#endif
-
-#define PF_UNSPEC       0
-#define PF_LOCAL        1
-#define PF_UNIX         PF_LOCAL
-#define PF_FILE         PF_LOCAL
-#define PF_INET         2
-#define PF_AX25         3
-#define PF_IPX          4
-#define PF_APPLETALK    5
-#define PF_NETROM       6
-#define PF_BRIDGE       7
-#define PF_ATMPVC       8
-#define PF_X25          9
-#define PF_INET6        10
-#define PF_ROSE         11
-#define PF_DECnet       12
-#define PF_NETBEUI      13
-#define PF_SECURITY     14
-#define PF_KEY          15
-#define PF_NETLINK      16
-#define PF_ROUTE        PF_NETLINK
-#define PF_PACKET       17
-#define PF_ASH          18
-#define PF_ECONET       19
-#define PF_ATMSVC       20
-#define PF_RDS          21
-#define PF_SNA          22
-#define PF_IRDA         23
-#define PF_PPPOX        24
-#define PF_WANPIPE      25
-#define PF_LLC          26
-#define PF_IB           27
-#define PF_MPLS         28
-#define PF_CAN          29
-#define PF_TIPC         30
-#define PF_BLUETOOTH    31
-#define PF_IUCV         32
-#define PF_RXRPC        33
-#define PF_ISDN         34
-#define PF_PHONET       35
-#define PF_IEEE802154   36
-#define PF_CAIF         37
-#define PF_ALG          38
-#define PF_NFC          39
-#define PF_VSOCK        40
-#define PF_KCM          41
-#define PF_QIPCRTR      42
-#define PF_SMC          43
-#define PF_XDP          44
-#define PF_MAX          45
-
-#define AF_UNSPEC       PF_UNSPEC
-#define AF_LOCAL        PF_LOCAL
-#define AF_UNIX         AF_LOCAL
-#define AF_FILE         AF_LOCAL
-#define AF_INET         PF_INET
-#define AF_AX25         PF_AX25
-#define AF_IPX          PF_IPX
-#define AF_APPLETALK    PF_APPLETALK
-#define AF_NETROM       PF_NETROM
-#define AF_BRIDGE       PF_BRIDGE
-#define AF_ATMPVC       PF_ATMPVC
-#define AF_X25          PF_X25
-#define AF_INET6        PF_INET6
-#define AF_ROSE         PF_ROSE
-#define AF_DECnet       PF_DECnet
-#define AF_NETBEUI      PF_NETBEUI
-#define AF_SECURITY     PF_SECURITY
-#define AF_KEY          PF_KEY
-#define AF_NETLINK      PF_NETLINK
-#define AF_ROUTE        PF_ROUTE
-#define AF_PACKET       PF_PACKET
-#define AF_ASH          PF_ASH
-#define AF_ECONET       PF_ECONET
-#define AF_ATMSVC       PF_ATMSVC
-#define AF_RDS          PF_RDS
-#define AF_SNA          PF_SNA
-#define AF_IRDA         PF_IRDA
-#define AF_PPPOX        PF_PPPOX
-#define AF_WANPIPE      PF_WANPIPE
-#define AF_LLC          PF_LLC
-#define AF_IB           PF_IB
-#define AF_MPLS         PF_MPLS
-#define AF_CAN          PF_CAN
-#define AF_TIPC         PF_TIPC
-#define AF_BLUETOOTH    PF_BLUETOOTH
-#define AF_IUCV         PF_IUCV
-#define AF_RXRPC        PF_RXRPC
-#define AF_ISDN         PF_ISDN
-#define AF_PHONET       PF_PHONET
-#define AF_IEEE802154   PF_IEEE802154
-#define AF_CAIF         PF_CAIF
-#define AF_ALG          PF_ALG
-#define AF_NFC          PF_NFC
-#define AF_VSOCK        PF_VSOCK
-#define AF_KCM          PF_KCM
-#define AF_QIPCRTR      PF_QIPCRTR
-#define AF_SMC          PF_SMC
-#define AF_XDP          PF_XDP
-#define AF_MAX          PF_MAX
-
-#ifndef SO_DEBUG
-#define SO_DEBUG        1
-#define SO_REUSEADDR    2
-#define SO_TYPE         3
-#define SO_ERROR        4
-#define SO_DONTROUTE    5
-#define SO_BROADCAST    6
-#define SO_SNDBUF       7
-#define SO_RCVBUF       8
-#define SO_KEEPALIVE    9
-#define SO_OOBINLINE    10
-#define SO_NO_CHECK     11
-#define SO_PRIORITY     12
-#define SO_LINGER       13
-#define SO_BSDCOMPAT    14
-#define SO_REUSEPORT    15
-#define SO_PASSCRED     16
-#define SO_PEERCRED     17
-#define SO_RCVLOWAT     18
-#define SO_SNDLOWAT     19
-#define SO_ACCEPTCONN   30
-#define SO_PEERSEC      31
-#define SO_SNDBUFFORCE  32
-#define SO_RCVBUFFORCE  33
-#define SO_PROTOCOL     38
-#define SO_DOMAIN       39
-#endif
-
-#ifndef SO_RCVTIMEO
-#if __LONG_MAX == 0x7fffffff
-#define SO_RCVTIMEO     66
-#define SO_SNDTIMEO     67
-#else
-#define SO_RCVTIMEO     20
-#define SO_SNDTIMEO     21
-#endif
-#endif
-
-#ifndef SO_TIMESTAMP
-#if __LONG_MAX == 0x7fffffff
-#define SO_TIMESTAMP    63
-#define SO_TIMESTAMPNS  64
-#define SO_TIMESTAMPING 65
-#else
-#define SO_TIMESTAMP    29
-#define SO_TIMESTAMPNS  35
-#define SO_TIMESTAMPING 37
-#endif
-#endif
-
-#define SO_SECURITY_AUTHENTICATION              22
-#define SO_SECURITY_ENCRYPTION_TRANSPORT        23
-#define SO_SECURITY_ENCRYPTION_NETWORK          24
-
-#define SO_BINDTODEVICE 25
-
-#define SO_ATTACH_FILTER        26
-#define SO_DETACH_FILTER        27
-#define SO_GET_FILTER           SO_ATTACH_FILTER
-
-#define SO_PEERNAME             28
-#define SCM_TIMESTAMP           SO_TIMESTAMP
-#define SO_PASSSEC              34
-#define SCM_TIMESTAMPNS         SO_TIMESTAMPNS
-#define SO_MARK                 36
-#define SCM_TIMESTAMPING        SO_TIMESTAMPING
-#define SO_RXQ_OVFL             40
-#define SO_WIFI_STATUS          41
-#define SCM_WIFI_STATUS         SO_WIFI_STATUS
-#define SO_PEEK_OFF             42
-#define SO_NOFCS                43
-#define SO_LOCK_FILTER          44
-#define SO_SELECT_ERR_QUEUE     45
-#define SO_BUSY_POLL            46
-#define SO_MAX_PACING_RATE      47
-#define SO_BPF_EXTENSIONS       48
-#define SO_INCOMING_CPU         49
-#define SO_ATTACH_BPF           50
-#define SO_DETACH_BPF           SO_DETACH_FILTER
-#define SO_ATTACH_REUSEPORT_CBPF 51
-#define SO_ATTACH_REUSEPORT_EBPF 52
-#define SO_CNX_ADVICE           53
-#define SCM_TIMESTAMPING_OPT_STATS 54
-#define SO_MEMINFO              55
-#define SO_INCOMING_NAPI_ID     56
-#define SO_COOKIE               57
-#define SCM_TIMESTAMPING_PKTINFO 58
-#define SO_PEERGROUPS           59
-#define SO_ZEROCOPY             60
-#define SO_TXTIME               61
-#define SCM_TXTIME              SO_TXTIME
-#define SO_BINDTOIFINDEX        62
-#define SO_DETACH_REUSEPORT_BPF 68
-
-#ifndef SOL_SOCKET
-#define SOL_SOCKET      1
-#endif
-
-#define SOL_IP          0
-#define SOL_IPV6        41
-#define SOL_ICMPV6      58
-
-#define SOL_RAW         255
-#define SOL_DECNET      261
-#define SOL_X25         262
-#define SOL_PACKET      263
-#define SOL_ATM         264
-#define SOL_AAL         265
-#define SOL_IRDA        266
-#define SOL_NETBEUI     267
-#define SOL_LLC         268
-#define SOL_DCCP        269
-#define SOL_NETLINK     270
-#define SOL_TIPC        271
-#define SOL_RXRPC       272
-#define SOL_PPPOL2TP    273
-#define SOL_BLUETOOTH   274
-#define SOL_PNPIPE      275
-#define SOL_RDS         276
-#define SOL_IUCV        277
-#define SOL_CAIF        278
-#define SOL_ALG         279
-#define SOL_NFC         280
-#define SOL_KCM         281
-#define SOL_TLS         282
-#define SOL_XDP         283
-
-#define SOMAXCONN       128
-
-#define MSG_OOB       0x0001
-#define MSG_PEEK      0x0002
-#define MSG_DONTROUTE 0x0004
-#define MSG_CTRUNC    0x0008
-#define MSG_PROXY     0x0010
-#define MSG_TRUNC     0x0020
-#define MSG_DONTWAIT  0x0040
-#define MSG_EOR       0x0080
-#define MSG_WAITALL   0x0100
-#define MSG_FIN       0x0200
-#define MSG_SYN       0x0400
-#define MSG_CONFIRM   0x0800
-#define MSG_RST       0x1000
-#define MSG_ERRQUEUE  0x2000
-#define MSG_NOSIGNAL  0x4000
-#define MSG_MORE      0x8000
-#define MSG_WAITFORONE 0x10000
-#define MSG_BATCH     0x40000
-#define MSG_ZEROCOPY  0x4000000
-#define MSG_FASTOPEN  0x20000000
-#define MSG_CMSG_CLOEXEC 0x40000000
-
-#define __CMSG_LEN(cmsg) (((cmsg)->cmsg_len + sizeof(long) - 1) & ~(long)(sizeof(long) - 1))
-#define __CMSG_NEXT(cmsg) ((unsigned char *)(cmsg) + __CMSG_LEN(cmsg))
-#define __MHDR_END(mhdr) ((unsigned char *)(mhdr)->msg_control + (mhdr)->msg_controllen)
-
-#define CMSG_DATA(cmsg) ((unsigned char *) (((struct cmsghdr *)(cmsg)) + 1))
-#define CMSG_NXTHDR(mhdr, cmsg) ((cmsg)->cmsg_len < sizeof (struct cmsghdr) || \
-	__CMSG_LEN(cmsg) + sizeof(struct cmsghdr) >= __MHDR_END(mhdr) - (unsigned char *)(cmsg) \
-	? 0 : (struct cmsghdr *)__CMSG_NEXT(cmsg))
-#define CMSG_FIRSTHDR(mhdr) ((size_t) (mhdr)->msg_controllen >= sizeof (struct cmsghdr) ? (struct cmsghdr *) (mhdr)->msg_control : (struct cmsghdr *) 0)
-
-#define CMSG_ALIGN(len) (((len) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1))
-#define CMSG_SPACE(len) (CMSG_ALIGN (len) + CMSG_ALIGN (sizeof (struct cmsghdr)))
-#define CMSG_LEN(len)   (CMSG_ALIGN (sizeof (struct cmsghdr)) + (len))
-
-#define SCM_RIGHTS      0x01
-#define SCM_CREDENTIALS 0x02
-
-struct sockaddr {
-	sa_family_t sa_family;
-	char sa_data[14];
-};
-
-#define __kernel_sockaddr_storage sockaddr_storage
-#include <linux/socket.h>
-#undef __kernel_sockaddr_storage
-
-int socket (int, int, int);
-int socketpair (int, int, int, int [2]);
-
-int shutdown (int, int);
-
-int bind (int, const struct sockaddr *, socklen_t);
-int connect (int, const struct sockaddr *, socklen_t);
-int listen (int, int);
-int accept (int, struct sockaddr *__restrict, socklen_t *__restrict);
-int accept4(int, struct sockaddr *__restrict, socklen_t *__restrict, int);
-
-int getsockname (int, struct sockaddr *__restrict, socklen_t *__restrict);
-int getpeername (int, struct sockaddr *__restrict, socklen_t *__restrict);
-
-ssize_t send (int, const void *, size_t, int);
-ssize_t recv (int, void *, size_t, int);
-ssize_t sendto (int, const void *, size_t, int, const struct sockaddr *, socklen_t);
-ssize_t recvfrom (int, void *__restrict, size_t, int, struct sockaddr *__restrict, socklen_t *__restrict);
-ssize_t sendmsg (int, const struct msghdr *, int);
-ssize_t recvmsg (int, struct msghdr *, int);
-
-int getsockopt (int, int, int, void *__restrict, socklen_t *__restrict);
-int setsockopt (int, int, int, const void *, socklen_t);
-
-int sockatmark (int);
-
-#if _REDIR_TIME64
-#ifdef _GNU_SOURCE
-__REDIR(recvmmsg, __recvmmsg_time64);
-#endif
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif

porting/linux/user/include/unistd.h

@@ -463,19 +463,6 @@ pid_t gettid(void);
 #define _CS_V6_ENV	1148
 #define _CS_V7_ENV	1149
 
-#ifdef _GNU_SOURCE
-#ifndef TEMP_FAILURE_RETRY
-#define MUSL_TEMP_FAILURE_RETRY(expression) \  
-    (__extension__ \
-        ({ long int __result; \
-            do __result = (long int)(expression); \
-            while(__result == -1L&& errno == EINTR); \
-        __result;}))
-
-#define TEMP_FAILURE_RETRY(expression) MUSL_TEMP_FAILURE_RETRY(expression)
-#endif
-#endif
-
 #ifdef __cplusplus
 }
 #endif

porting/linux/user/src/internal/pthread_impl.h

+#ifndef _PTHREAD_IMPL_H
+#define _PTHREAD_IMPL_H
+
+#include <pthread.h>
+#include <signal.h>
+#include <errno.h>
+#include <limits.h>
+#include <sys/mman.h>
+#include "libc.h"
+#include "syscall.h"
+#include "atomic.h"
+#include "futex.h"
+
+#define pthread __pthread
+
+struct pthread {
+	/* Part 1 -- these fields may be external or
+	 * internal (accessed via asm) ABI. Do not change. */
+	struct pthread *self;
+	uintptr_t *dtv;
+	struct pthread *prev, *next; /* non-ABI */
+	uintptr_t sysinfo;
+	uintptr_t canary, canary2;
+
+	/* Part 2 -- implementation details, non-ABI. */
+	int tid;
+	int errno_val;
+	volatile int detach_state;
+	volatile int cancel;
+	volatile unsigned char canceldisable, cancelasync;
+	unsigned char tsd_used:1;
+	unsigned char dlerror_flag:1;
+	unsigned char *map_base;
+	size_t map_size;
+	void *stack;
+	size_t stack_size;
+	size_t guard_size;
+	void *result;
+	struct __ptcb *cancelbuf;
+	void **tsd;
+	struct {
+		volatile void *volatile head;
+		long off;
+		volatile void *volatile pending;
+	} robust_list;
+	volatile int timer_id;
+	locale_t locale;
+	volatile int killlock[1];
+	char *dlerror_buf;
+	void *stdio_locks;
+
+	/* Part 3 -- the positions of these fields relative to
+	 * the end of the structure is external and internal ABI. */
+	uintptr_t canary_at_end;
+	uintptr_t *dtv_copy;
+};
+
+enum {
+	DT_EXITING = 0,
+	DT_JOINABLE,
+	DT_DETACHED,
+};
+
+struct __timer {
+	int timerid;
+	pthread_t thread;
+};
+
+#define __SU (sizeof(size_t)/sizeof(int))
+
+#define _a_stacksize __u.__s[0]
+#define _a_guardsize __u.__s[1]
+#define _a_stackaddr __u.__s[2]
+#define _a_detach __u.__i[3*__SU+0]
+#define _a_sched __u.__i[3*__SU+1]
+#define _a_policy __u.__i[3*__SU+2]
+#define _a_prio __u.__i[3*__SU+3]
+
+/* we define the original value of _m_* in include/pthread.h
+ * as macros MUTEX_* to make the user be able to
+ * access the inner attribute of the mutex struct.
+ * Then, we modify the value of _m_* macros to MUTEX_* here,
+ * so that we can immediately be aware of the changes that
+ * the open source society has made to these original macros,
+ * because patching will fail if the value of the _m_* are
+ * changed by musl society */
+#define _m_type MUTEX_TYPE
+#define _m_lock MUTEX_LOCK
+#define _m_waiters MUTEX_WAITERS
+#define _m_prev MUTEX_PREV
+#define _m_next MUTEX_NEXT
+#define _m_count MUTEX_COUNT
+
+#define _c_shared __u.__p[0]
+#define _c_seq __u.__vi[2]
+#define _c_waiters __u.__vi[3]
+#define _c_clock __u.__i[4]
+#define _c_lock __u.__vi[8]
+#define _c_head __u.__p[1]
+#define _c_tail __u.__p[5]
+#define _rw_lock __u.__vi[0]
+#define _rw_waiters __u.__vi[1]
+#define _rw_shared __u.__i[2]
+#define _b_lock __u.__vi[0]
+#define _b_waiters __u.__vi[1]
+#define _b_limit __u.__i[2]
+#define _b_count __u.__vi[3]
+#define _b_waiters2 __u.__vi[4]
+#define _b_inst __u.__p[3]
+
+#include "pthread_arch.h"
+
+#ifndef CANARY
+#define CANARY canary
+#endif
+
+#ifndef DTP_OFFSET
+#define DTP_OFFSET 0
+#endif
+
+#ifndef tls_mod_off_t
+#define tls_mod_off_t size_t
+#endif
+
+#define SIGTIMER 32
+#define SIGCANCEL 33
+#define SIGSYNCCALL 34
+
+#define SIGALL_SET ((sigset_t *)(const unsigned long long [2]){ -1,-1 })
+#define SIGPT_SET \
+	((sigset_t *)(const unsigned long [_NSIG/8/sizeof(long)]){ \
+	[sizeof(long)==4] = 3UL<<(32*(sizeof(long)>4)) })
+#define SIGTIMER_SET \
+	((sigset_t *)(const unsigned long [_NSIG/8/sizeof(long)]){ \
+	 0x80000000 })
+
+void *__tls_get_addr(tls_mod_off_t *);
+hidden int __init_tp(void *);
+hidden void *__copy_tls(unsigned char *);
+hidden void __reset_tls();
+
+hidden void __membarrier_init(void);
+hidden void __dl_thread_cleanup(void);
+hidden void __testcancel();
+hidden void __do_cleanup_push(struct __ptcb *);
+hidden void __do_cleanup_pop(struct __ptcb *);
+hidden void __pthread_tsd_run_dtors();
+
+hidden void __pthread_key_delete_synccall(void (*)(void *), void *);
+hidden int __pthread_key_delete_impl(pthread_key_t);
+
+extern hidden volatile size_t __pthread_tsd_size;
+extern hidden void *__pthread_tsd_main[];
+extern hidden volatile int __aio_fut;
+extern hidden volatile int __eintr_valid_flag;
+
+hidden int __clone(int (*)(void *), void *, int, void *, ...);
+hidden int __set_thread_area(void *);
+hidden int __libc_sigaction(int, const struct sigaction *, struct sigaction *);
+hidden void __unmapself(void *, size_t);
+
+hidden int __timedwait(volatile int *, int, clockid_t, const struct timespec *, int);
+hidden int __timedwait_cp(volatile int *, int, clockid_t, const struct timespec *, int);
+hidden void __wait(volatile int *, volatile int *, int, int);
+static inline void __wake(volatile void *addr, int cnt, int priv)
+{
+	if (priv) priv = FUTEX_PRIVATE;
+	if (cnt<0) cnt = INT_MAX;
+	__syscall(SYS_futex, addr, FUTEX_WAKE|priv, cnt) != -ENOSYS ||
+	__syscall(SYS_futex, addr, FUTEX_WAKE, cnt);
+}
+static inline void __futexwait(volatile void *addr, int val, int priv)
+{
+	if (priv) priv = FUTEX_PRIVATE;
+	__syscall(SYS_futex, addr, FUTEX_WAIT|priv, val, 0) != -ENOSYS ||
+	__syscall(SYS_futex, addr, FUTEX_WAIT, val, 0);
+}
+
+hidden void __acquire_ptc(void);
+hidden void __release_ptc(void);
+hidden void __inhibit_ptc(void);
+
+hidden void __tl_lock(void);
+hidden void __tl_unlock(void);
+hidden void __tl_sync(pthread_t);
+
+extern hidden volatile int __thread_list_lock;
+
+extern hidden unsigned __default_stacksize;
+extern hidden unsigned __default_guardsize;
+
+#define DEFAULT_STACK_SIZE 131072
+#define DEFAULT_GUARD_SIZE 8192
+
+#define DEFAULT_STACK_MAX (8<<20)
+#define DEFAULT_GUARD_MAX (1<<20)
+
+#define __ATTRP_C11_THREAD ((void*)(uintptr_t)-1)
+
+#endif

porting/linux/user/src/internal/syscall.h

+#ifndef _INTERNAL_SYSCALL_H
+#define _INTERNAL_SYSCALL_H
+
+#include <features.h>
+#include <sys/syscall.h>
+#include "syscall_arch.h"
+
+#ifndef SYSCALL_RLIM_INFINITY
+#define SYSCALL_RLIM_INFINITY (~0ULL)
+#endif
+
+#ifndef SYSCALL_MMAP2_UNIT
+#define SYSCALL_MMAP2_UNIT 4096ULL
+#endif
+
+#ifndef __SYSCALL_LL_PRW
+#define __SYSCALL_LL_PRW(x) __SYSCALL_LL_O(x)
+#endif
+
+#ifndef __scc
+#define __scc(X) ((long) (X))
+typedef long syscall_arg_t;
+#endif
+
+hidden long __syscall_ret(unsigned long),
+	__syscall_cp(syscall_arg_t, syscall_arg_t, syscall_arg_t, syscall_arg_t,
+	             syscall_arg_t, syscall_arg_t, syscall_arg_t);
+
+#define __syscall1(n,a) __syscall1(n,__scc(a))
+#define __syscall2(n,a,b) __syscall2(n,__scc(a),__scc(b))
+#define __syscall3(n,a,b,c) __syscall3(n,__scc(a),__scc(b),__scc(c))
+#define __syscall4(n,a,b,c,d) __syscall4(n,__scc(a),__scc(b),__scc(c),__scc(d))
+#define __syscall5(n,a,b,c,d,e) __syscall5(n,__scc(a),__scc(b),__scc(c),__scc(d),__scc(e))
+#define __syscall6(n,a,b,c,d,e,f) __syscall6(n,__scc(a),__scc(b),__scc(c),__scc(d),__scc(e),__scc(f))
+#define __syscall7(n,a,b,c,d,e,f,g) __syscall7(n,__scc(a),__scc(b),__scc(c),__scc(d),__scc(e),__scc(f),__scc(g))
+
+#define __SYSCALL_NARGS_X(a,b,c,d,e,f,g,h,n,...) n
+#define __SYSCALL_NARGS(...) __SYSCALL_NARGS_X(__VA_ARGS__,7,6,5,4,3,2,1,0,)
+#define __SYSCALL_CONCAT_X(a,b) a##b
+#define __SYSCALL_CONCAT(a,b) __SYSCALL_CONCAT_X(a,b)
+#define __SYSCALL_DISP(b,...) __SYSCALL_CONCAT(b,__SYSCALL_NARGS(__VA_ARGS__))(__VA_ARGS__)
+
+#define __syscall(...) __SYSCALL_DISP(__syscall,__VA_ARGS__)
+#define syscall(...) __syscall_ret(__syscall(__VA_ARGS__))
+
+#define socketcall(nm,a,b,c,d,e,f) __syscall_ret(__socketcall(nm,a,b,c,d,e,f))
+#define socketcall_cp(nm,a,b,c,d,e,f) __syscall_ret(__socketcall_cp(nm,a,b,c,d,e,f))
+
+#define __syscall_cp0(n) (__syscall_cp)(n,0,0,0,0,0,0)
+#define __syscall_cp1(n,a) (__syscall_cp)(n,__scc(a),0,0,0,0,0)
+#define __syscall_cp2(n,a,b) (__syscall_cp)(n,__scc(a),__scc(b),0,0,0,0)
+#define __syscall_cp3(n,a,b,c) (__syscall_cp)(n,__scc(a),__scc(b),__scc(c),0,0,0)
+#define __syscall_cp4(n,a,b,c,d) (__syscall_cp)(n,__scc(a),__scc(b),__scc(c),__scc(d),0,0)
+#define __syscall_cp5(n,a,b,c,d,e) (__syscall_cp)(n,__scc(a),__scc(b),__scc(c),__scc(d),__scc(e),0)
+#define __syscall_cp6(n,a,b,c,d,e,f) (__syscall_cp)(n,__scc(a),__scc(b),__scc(c),__scc(d),__scc(e),__scc(f))
+
+#define __syscall_cp(...) __SYSCALL_DISP(__syscall_cp,__VA_ARGS__)
+#define syscall_cp(...) __syscall_ret(__syscall_cp(__VA_ARGS__))
+
+#ifndef SYSCALL_USE_SOCKETCALL
+#define __socketcall(nm,a,b,c,d,e,f) __syscall(SYS_##nm, a, b, c, d, e, f)
+#define __socketcall_cp(nm,a,b,c,d,e,f) __syscall_cp(SYS_##nm, a, b, c, d, e, f)
+#else
+#define __socketcall(nm,a,b,c,d,e,f) __syscall(SYS_socketcall, __SC_##nm, \
+    ((long [6]){ (long)a, (long)b, (long)c, (long)d, (long)e, (long)f }))
+#define __socketcall_cp(nm,a,b,c,d,e,f) __syscall_cp(SYS_socketcall, __SC_##nm, \
+    ((long [6]){ (long)a, (long)b, (long)c, (long)d, (long)e, (long)f }))
+#endif
+
+/* fixup legacy 16-bit junk */
+
+#ifdef SYS_getuid32
+#undef SYS_lchown
+#undef SYS_getuid
+#undef SYS_getgid
+#undef SYS_geteuid
+#undef SYS_getegid
+#undef SYS_setreuid
+#undef SYS_setregid
+#undef SYS_getgroups
+#undef SYS_setgroups
+#undef SYS_fchown
+#undef SYS_setresuid
+#undef SYS_getresuid
+#undef SYS_setresgid
+#undef SYS_getresgid
+#undef SYS_chown
+#undef SYS_setuid
+#undef SYS_setgid
+#undef SYS_setfsuid
+#undef SYS_setfsgid
+#define SYS_lchown SYS_lchown32
+#define SYS_getuid SYS_getuid32
+#define SYS_getgid SYS_getgid32
+#define SYS_geteuid SYS_geteuid32
+#define SYS_getegid SYS_getegid32
+#define SYS_setreuid SYS_setreuid32
+#define SYS_setregid SYS_setregid32
+#define SYS_getgroups SYS_getgroups32
+#define SYS_setgroups SYS_setgroups32
+#define SYS_fchown SYS_fchown32
+#define SYS_setresuid SYS_setresuid32
+#define SYS_getresuid SYS_getresuid32
+#define SYS_setresgid SYS_setresgid32
+#define SYS_getresgid SYS_getresgid32
+#define SYS_chown SYS_chown32
+#define SYS_setuid SYS_setuid32
+#define SYS_setgid SYS_setgid32
+#define SYS_setfsuid SYS_setfsuid32
+#define SYS_setfsgid SYS_setfsgid32
+#endif
+
+
+/* fixup legacy 32-bit-vs-lfs64 junk */
+
+#ifdef SYS_fcntl64
+#undef SYS_fcntl
+#define SYS_fcntl SYS_fcntl64
+#endif
+
+#ifdef SYS_getdents64
+#undef SYS_getdents
+#define SYS_getdents SYS_getdents64
+#endif
+
+#ifdef SYS_ftruncate64
+#undef SYS_ftruncate
+#undef SYS_truncate
+#define SYS_ftruncate SYS_ftruncate64
+#define SYS_truncate SYS_truncate64
+#endif
+
+#ifdef SYS_stat64
+#undef SYS_stat
+#define SYS_stat SYS_stat64
+#endif
+
+#ifdef SYS_fstat64
+#undef SYS_fstat
+#define SYS_fstat SYS_fstat64
+#endif
+
+#ifdef SYS_lstat64
+#undef SYS_lstat
+#define SYS_lstat SYS_lstat64
+#endif
+
+#ifdef SYS_statfs64
+#undef SYS_statfs
+#define SYS_statfs SYS_statfs64
+#endif
+
+#ifdef SYS_fstatfs64
+#undef SYS_fstatfs
+#define SYS_fstatfs SYS_fstatfs64
+#endif
+
+#if defined(SYS_newfstatat)
+#undef SYS_fstatat
+#define SYS_fstatat SYS_newfstatat
+#elif defined(SYS_fstatat64)
+#undef SYS_fstatat
+#define SYS_fstatat SYS_fstatat64
+#endif
+
+#ifdef SYS_ugetrlimit
+#undef SYS_getrlimit
+#define SYS_getrlimit SYS_ugetrlimit
+#endif
+
+#ifdef SYS__newselect
+#undef SYS_select
+#define SYS_select SYS__newselect
+#endif
+
+#ifdef SYS_pread64
+#undef SYS_pread
+#undef SYS_pwrite
+#define SYS_pread SYS_pread64
+#define SYS_pwrite SYS_pwrite64
+#endif
+
+#ifdef SYS_fadvise64_64
+#undef SYS_fadvise
+#define SYS_fadvise SYS_fadvise64_64
+#elif defined(SYS_fadvise64)
+#undef SYS_fadvise
+#define SYS_fadvise SYS_fadvise64
+#endif
+
+#ifdef SYS_sendfile64
+#undef SYS_sendfile
+#define SYS_sendfile SYS_sendfile64
+#endif
+
+#ifndef SYS_timer_settime
+#define SYS_timer_settime SYS_timer_settime32
+#endif
+
+#ifndef SYS_timer_gettime
+#define SYS_timer_gettime SYS_timer_gettime32
+#endif
+
+#ifndef SYS_timerfd_settime
+#define SYS_timerfd_settime SYS_timerfd_settime32
+#endif
+
+#ifndef SYS_timerfd_gettime
+#define SYS_timerfd_gettime SYS_timerfd_gettime32
+#endif
+
+#ifndef SYS_clock_settime
+#define SYS_clock_settime SYS_clock_settime32
+#endif
+
+#ifndef SYS_clock_gettime
+#define SYS_clock_gettime SYS_clock_gettime32
+#endif
+
+#ifndef SYS_clock_getres
+#define SYS_clock_getres SYS_clock_getres_time32
+#endif
+
+#ifndef SYS_clock_nanosleep
+#define SYS_clock_nanosleep SYS_clock_nanosleep_time32
+#endif
+
+#ifndef SYS_gettimeofday
+#define SYS_gettimeofday SYS_gettimeofday_time32
+#endif
+
+#ifndef SYS_settimeofday
+#define SYS_settimeofday SYS_settimeofday_time32
+#endif
+
+/* Ensure that the plain syscall names are defined even for "time64-only"
+ * archs. These facilitate callers passing null time arguments, and make
+ * tests for establishing which to use/fallback-to more consistent when
+ * they do need to be called with time arguments. */
+
+#ifndef SYS_clock_gettime
+#define SYS_clock_gettime SYS_clock_gettime64
+#endif
+
+#ifndef SYS_clock_settime
+#define SYS_clock_settime SYS_clock_settime64
+#endif
+
+#ifndef SYS_clock_adjtime
+#define SYS_clock_adjtime SYS_clock_adjtime64
+#endif
+
+#ifndef SYS_clock_getres
+#define SYS_clock_getres SYS_clock_getres_time64
+#endif
+
+#ifndef SYS_clock_nanosleep
+#define SYS_clock_nanosleep SYS_clock_nanosleep_time64
+#endif
+
+#ifndef SYS_timer_gettime
+#define SYS_timer_gettime SYS_timer_gettime64
+#endif
+
+#ifndef SYS_timer_settime
+#define SYS_timer_settime SYS_timer_settime64
+#endif
+
+#ifndef SYS_timerfd_gettime
+#define SYS_timerfd_gettime SYS_timerfd_gettime64
+#endif
+
+#ifndef SYS_timerfd_settime
+#define SYS_timerfd_settime SYS_timerfd_settime64
+#endif
+
+#ifndef SYS_utimensat
+#define SYS_utimensat SYS_utimensat_time64
+#endif
+
+#ifndef SYS_ppoll
+#define SYS_ppoll SYS_ppoll_time64
+#endif
+
+#ifndef SYS_recvmmsg
+#define SYS_recvmmsg SYS_recvmmsg_time64
+#endif
+
+#ifndef SYS_mq_timedsend
+#define SYS_mq_timedsend SYS_mq_timedsend_time64
+#endif
+
+#ifndef SYS_mq_timedreceive
+#define SYS_mq_timedreceive SYS_mq_timedreceive_time64
+#endif
+
+/* SYS_semtimedop omitted because SYS_ipc may provide it */
+
+#ifndef SYS_rt_sigtimedwait
+#define SYS_rt_sigtimedwait SYS_rt_sigtimedwait_time64
+#endif
+
+#ifndef SYS_futex
+#define SYS_futex SYS_futex_time64
+#endif
+
+#ifndef SYS_sched_rr_get_interval
+#define SYS_sched_rr_get_interval SYS_sched_rr_get_interval_time64
+#endif
+
+
+
+
+/* socketcall calls */
+
+#define __SC_socket      1
+#define __SC_bind        2
+#define __SC_connect     3
+#define __SC_listen      4
+#define __SC_accept      5
+#define __SC_getsockname 6
+#define __SC_getpeername 7
+#define __SC_socketpair  8
+#define __SC_send        9
+#define __SC_recv        10
+#define __SC_sendto      11
+#define __SC_recvfrom    12
+#define __SC_shutdown    13
+#define __SC_setsockopt  14
+#define __SC_getsockopt  15
+#define __SC_sendmsg     16
+#define __SC_recvmsg     17
+#define __SC_accept4     18
+#define __SC_recvmmsg    19
+#define __SC_sendmmsg    20
+
+#ifndef SO_RCVTIMEO_OLD
+#define SO_RCVTIMEO_OLD  20
+#endif
+#ifndef SO_SNDTIMEO_OLD
+#define SO_SNDTIMEO_OLD  21
+#endif
+
+#define SO_TIMESTAMP_OLD    29
+#define SO_TIMESTAMPNS_OLD  35
+#define SO_TIMESTAMPING_OLD 37
+#define SCM_TIMESTAMP_OLD    SO_TIMESTAMP_OLD
+#define SCM_TIMESTAMPNS_OLD  SO_TIMESTAMPNS_OLD
+#define SCM_TIMESTAMPING_OLD SO_TIMESTAMPING_OLD
+
+#ifndef SIOCGSTAMP_OLD
+#define SIOCGSTAMP_OLD 0x8906
+#endif
+#ifndef SIOCGSTAMPNS_OLD
+#define SIOCGSTAMPNS_OLD 0x8907
+#endif
+
+#ifdef SYS_open
+#define __sys_open2(x,pn,fl) __syscall2(SYS_open, pn, (fl)|O_LARGEFILE)
+#define __sys_open3(x,pn,fl,mo) __syscall3(SYS_open, pn, (fl)|O_LARGEFILE, mo)
+#define __sys_open_cp2(x,pn,fl) __syscall_cp2(SYS_open, pn, (fl)|O_LARGEFILE)
+#define __sys_open_cp3(x,pn,fl,mo) __syscall_cp3(SYS_open, pn, (fl)|O_LARGEFILE, mo)
+#else
+#define __sys_open2(x,pn,fl) __syscall3(SYS_openat, AT_FDCWD, pn, (fl)|O_LARGEFILE)
+#define __sys_open3(x,pn,fl,mo) __syscall4(SYS_openat, AT_FDCWD, pn, (fl)|O_LARGEFILE, mo)
+#define __sys_open_cp2(x,pn,fl) __syscall_cp3(SYS_openat, AT_FDCWD, pn, (fl)|O_LARGEFILE)
+#define __sys_open_cp3(x,pn,fl,mo) __syscall_cp4(SYS_openat, AT_FDCWD, pn, (fl)|O_LARGEFILE, mo)
+#endif
+
+#define __sys_open(...) __SYSCALL_DISP(__sys_open,,__VA_ARGS__)
+#define sys_open(...) __syscall_ret(__sys_open(__VA_ARGS__))
+
+#define __sys_open_cp(...) __SYSCALL_DISP(__sys_open_cp,,__VA_ARGS__)
+#define sys_open_cp(...) __syscall_ret(__sys_open_cp(__VA_ARGS__))
+
+hidden void __procfdname(char __buf[static 15+3*sizeof(int)], unsigned);
+
+hidden void *__vdsosym(const char *, const char *);
+
+#endif

porting/linux/user/src/legacy/ulimit.c

+#include <sys/resource.h>
+#include <ulimit.h>
+#include <stdarg.h>
+#include <limits.h>
+
+long ulimit(int cmd, ...)
+{
+	struct rlimit rl;
+	getrlimit(RLIMIT_FSIZE, &rl);
+	if (cmd == UL_SETFSIZE) {
+		long val;
+		va_list ap;
+		va_start(ap, cmd);
+		val = va_arg(ap, long);
+		va_end(ap);
+		rl.rlim_cur = 512ULL * val;
+		if (setrlimit(RLIMIT_FSIZE, &rl)) return -1;
+	}
+	return rl.rlim_cur == RLIM_INFINITY? LONG_MAX : rl.rlim_cur / 512;
+}

porting/linux/user/src/linux/gettid.c

+#define _GNU_SOURCE
+#include <unistd.h>
+#include "pthread_impl.h"
+
+pid_t gettid(void)
+{
+	return __pthread_self()->tid;
+}

porting/linux/user/src/malloc/malloc.c

+#define _GNU_SOURCE
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <stdint.h>
+#include <errno.h>
+#include <sys/mman.h>
+#include "libc.h"
+#include "atomic.h"
+#include "pthread_impl.h"
+#include "malloc_impl.h"
+
+#if defined(__GNUC__) && defined(__PIC__)
+#define inline inline __attribute__((always_inline))
+#endif
+
+static struct {
+	volatile uint64_t binmap;
+	struct bin bins[64];
+	volatile int free_lock[2];
+} mal;
+
+int __malloc_replaced;
+
+/* Synchronization tools */
+
+static inline void lock(volatile int *lk)
+{
+	if (libc.threads_minus_1)
+		while(a_swap(lk, 1)) __wait(lk, lk+1, 1, 1);
+}
+
+static inline void unlock(volatile int *lk)
+{
+	if (lk[0]) {
+		a_store(lk, 0);
+		if (lk[1]) __wake(lk, 1, 1);
+	}
+}
+
+static inline void lock_bin(int i)
+{
+	lock(mal.bins[i].lock);
+	if (!mal.bins[i].head)
+		mal.bins[i].head = mal.bins[i].tail = BIN_TO_CHUNK(i);
+}
+
+static inline void unlock_bin(int i)
+{
+	unlock(mal.bins[i].lock);
+}
+
+static int first_set(uint64_t x)
+{
+#if 1
+	return a_ctz_64(x);
+#else
+	static const char debruijn64[64] = {
+		0, 1, 2, 53, 3, 7, 54, 27, 4, 38, 41, 8, 34, 55, 48, 28,
+		62, 5, 39, 46, 44, 42, 22, 9, 24, 35, 59, 56, 49, 18, 29, 11,
+		63, 52, 6, 26, 37, 40, 33, 47, 61, 45, 43, 21, 23, 58, 17, 10,
+		51, 25, 36, 32, 60, 20, 57, 16, 50, 31, 19, 15, 30, 14, 13, 12
+	};
+	static const char debruijn32[32] = {
+		0, 1, 23, 2, 29, 24, 19, 3, 30, 27, 25, 11, 20, 8, 4, 13,
+		31, 22, 28, 18, 26, 10, 7, 12, 21, 17, 9, 6, 16, 5, 15, 14
+	};
+	if (sizeof(long) < 8) {
+		uint32_t y = x;
+		if (!y) {
+			y = x>>32;
+			return 32 + debruijn32[(y&-y)*0x076be629 >> 27];
+		}
+		return debruijn32[(y&-y)*0x076be629 >> 27];
+	}
+	return debruijn64[(x&-x)*0x022fdd63cc95386dull >> 58];
+#endif
+}
+
+static const unsigned char bin_tab[60] = {
+	            32,33,34,35,36,36,37,37,38,38,39,39,
+	40,40,40,40,41,41,41,41,42,42,42,42,43,43,43,43,
+	44,44,44,44,44,44,44,44,45,45,45,45,45,45,45,45,
+	46,46,46,46,46,46,46,46,47,47,47,47,47,47,47,47,
+};
+
+static int bin_index(size_t x)
+{
+	x = x / SIZE_ALIGN - 1;
+	if (x <= 32) return x;
+	if (x < 512) return bin_tab[x/8-4];
+	if (x > 0x1c00) return 63;
+	return bin_tab[x/128-4] + 16;
+}
+
+static int bin_index_up(size_t x)
+{
+	x = x / SIZE_ALIGN - 1;
+	if (x <= 32) return x;
+	x--;
+	if (x < 512) return bin_tab[x/8-4] + 1;
+	return bin_tab[x/128-4] + 17;
+}
+
+#if 0
+void __dump_heap(int x)
+{
+	struct chunk *c;
+	int i;
+	for (c = (void *)mal.heap; CHUNK_SIZE(c); c = NEXT_CHUNK(c))
+		fprintf(stderr, "base %p size %zu (%d) flags %d/%d\n",
+			c, CHUNK_SIZE(c), bin_index(CHUNK_SIZE(c)),
+			c->csize & 15,
+			NEXT_CHUNK(c)->psize & 15);
+	for (i=0; i<64; i++) {
+		if (mal.bins[i].head != BIN_TO_CHUNK(i) && mal.bins[i].head) {
+			fprintf(stderr, "bin %d: %p\n", i, mal.bins[i].head);
+			if (!(mal.binmap & 1ULL<<i))
+				fprintf(stderr, "missing from binmap!\n");
+		} else if (mal.binmap & 1ULL<<i)
+			fprintf(stderr, "binmap wrongly contains %d!\n", i);
+	}
+}
+#endif
+
+static struct chunk *expand_heap(size_t n)
+{
+	static int heap_lock[2];
+	static void *end;
+	void *p;
+	struct chunk *w;
+
+	/* The argument n already accounts for the caller's chunk
+	 * overhead needs, but if the heap can't be extended in-place,
+	 * we need room for an extra zero-sized sentinel chunk. */
+	n += SIZE_ALIGN;
+
+	lock(heap_lock);
+
+	p = __expand_heap(&n);
+	if (!p) {
+		unlock(heap_lock);
+		return 0;
+	}
+
+	/* If not just expanding existing space, we need to make a
+	 * new sentinel chunk below the allocated space. */
+	if (p != end) {
+		/* Valid/safe because of the prologue increment. */
+		n -= SIZE_ALIGN;
+		p = (char *)p + SIZE_ALIGN;
+		w = MEM_TO_CHUNK(p);
+		w->psize = 0 | C_INUSE;
+	}
+
+	/* Record new heap end and fill in footer. */
+	end = (char *)p + n;
+	w = MEM_TO_CHUNK(end);
+	w->psize = n | C_INUSE;
+	w->csize = 0 | C_INUSE;
+
+	/* Fill in header, which may be new or may be replacing a
+	 * zero-size sentinel header at the old end-of-heap. */
+	w = MEM_TO_CHUNK(p);
+	w->csize = n | C_INUSE;
+
+	unlock(heap_lock);
+
+	return w;
+}
+
+static int adjust_size(size_t *n)
+{
+	/* Result of pointer difference must fit in ptrdiff_t. */
+	if (*n-1 > PTRDIFF_MAX - SIZE_ALIGN - PAGE_SIZE) {
+		if (*n) {
+			errno = ENOMEM;
+			return -1;
+		} else {
+			*n = SIZE_ALIGN;
+			return 0;
+		}
+	}
+	*n = (*n + OVERHEAD + SIZE_ALIGN - 1) & SIZE_MASK;
+	return 0;
+}
+
+static void unbin(struct chunk *c, int i)
+{
+	if (c->prev == c->next)
+		a_and_64(&mal.binmap, ~(1ULL<<i));
+	c->prev->next = c->next;
+	c->next->prev = c->prev;
+	c->csize |= C_INUSE;
+	NEXT_CHUNK(c)->psize |= C_INUSE;
+}
+
+static int alloc_fwd(struct chunk *c)
+{
+	int i;
+	size_t k;
+	while (!((k=c->csize) & C_INUSE)) {
+		i = bin_index(k);
+		lock_bin(i);
+		if (c->csize == k) {
+			unbin(c, i);
+			unlock_bin(i);
+			return 1;
+		}
+		unlock_bin(i);
+	}
+	return 0;
+}
+
+static int alloc_rev(struct chunk *c)
+{
+	int i;
+	size_t k;
+	while (!((k=c->psize) & C_INUSE)) {
+		i = bin_index(k);
+		lock_bin(i);
+		if (c->psize == k) {
+			unbin(PREV_CHUNK(c), i);
+			unlock_bin(i);
+			return 1;
+		}
+		unlock_bin(i);
+	}
+	return 0;
+}
+
+
+/* pretrim - trims a chunk _prior_ to removing it from its bin.
+ * Must be called with i as the ideal bin for size n, j the bin
+ * for the _free_ chunk self, and bin j locked. */
+static int pretrim(struct chunk *self, size_t n, int i, int j)
+{
+	size_t n1;
+	struct chunk *next, *split;
+
+	/* We cannot pretrim if it would require re-binning. */
+	if (j < 40) return 0;
+	if (j < i+3) {
+		if (j != 63) return 0;
+		n1 = CHUNK_SIZE(self);
+		if (n1-n <= MMAP_THRESHOLD) return 0;
+	} else {
+		n1 = CHUNK_SIZE(self);
+	}
+	if (bin_index(n1-n) != j) return 0;
+
+	next = NEXT_CHUNK(self);
+	split = (void *)((char *)self + n);
+
+	split->prev = self->prev;
+	split->next = self->next;
+	split->prev->next = split;
+	split->next->prev = split;
+	split->psize = n | C_INUSE;
+	split->csize = n1-n;
+	next->psize = n1-n;
+	self->csize = n | C_INUSE;
+	return 1;
+}
+
+static void trim(struct chunk *self, size_t n)
+{
+	size_t n1 = CHUNK_SIZE(self);
+	struct chunk *next, *split;
+
+	if (n >= n1 - DONTCARE) return;
+
+	next = NEXT_CHUNK(self);
+	split = (void *)((char *)self + n);
+
+	split->psize = n | C_INUSE;
+	split->csize = n1-n | C_INUSE;
+	next->psize = n1-n | C_INUSE;
+	self->csize = n | C_INUSE;
+
+	__bin_chunk(split);
+}
+
+void *malloc(size_t n)
+{
+	struct chunk *c;
+	int i, j;
+
+	if (adjust_size(&n) < 0) return 0;
+
+	if (n > MMAP_THRESHOLD) {
+		size_t len = n + OVERHEAD + PAGE_SIZE - 1 & -PAGE_SIZE;
+		char *base = __mmap(0, len, PROT_READ|PROT_WRITE,
+			MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
+		if (base == (void *)-1) return 0;
+		c = (void *)(base + SIZE_ALIGN - OVERHEAD);
+		c->csize = len - (SIZE_ALIGN - OVERHEAD);
+		c->psize = SIZE_ALIGN - OVERHEAD;
+		return CHUNK_TO_MEM(c);
+	}
+
+	i = bin_index_up(n);
+	for (;;) {
+		uint64_t mask = mal.binmap & -(1ULL<<i);
+		if (!mask) {
+			c = expand_heap(n);
+			if (!c) return 0;
+			if (alloc_rev(c)) {
+				struct chunk *x = c;
+				c = PREV_CHUNK(c);
+				NEXT_CHUNK(x)->psize = c->csize =
+					x->csize + CHUNK_SIZE(c);
+			}
+			break;
+		}
+		j = first_set(mask);
+		lock_bin(j);
+		c = mal.bins[j].head;
+		if (c != BIN_TO_CHUNK(j)) {
+			if (!pretrim(c, n, i, j)) unbin(c, j);
+			unlock_bin(j);
+			break;
+		}
+		unlock_bin(j);
+	}
+
+	/* Now patch up in case we over-allocated */
+	trim(c, n);
+
+	return CHUNK_TO_MEM(c);
+}
+
+static size_t mal0_clear(char *p, size_t pagesz, size_t n)
+{
+#ifdef __GNUC__
+	typedef uint64_t __attribute__((__may_alias__)) T;
+#else
+	typedef unsigned char T;
+#endif
+	char *pp = p + n;
+	size_t i = (uintptr_t)pp & (pagesz - 1);
+	for (;;) {
+		pp = memset(pp - i, 0, i);
+		if (pp - p < pagesz) return pp - p;
+		for (i = pagesz; i; i -= 2*sizeof(T), pp -= 2*sizeof(T))
+		        if (((T *)pp)[-1] | ((T *)pp)[-2])
+				break;
+	}
+}
+
+void *calloc(size_t m, size_t n)
+{
+	if (n && m > (size_t)-1/n) {
+		errno = ENOMEM;
+		return 0;
+	}
+	n *= m;
+	void *p = malloc(n);
+	if (!p) return p;
+	if (!__malloc_replaced) {
+		if (IS_MMAPPED(MEM_TO_CHUNK(p)))
+			return p;
+		if (n >= PAGE_SIZE)
+			n = mal0_clear(p, PAGE_SIZE, n);
+	}
+	return memset(p, 0, n);
+}
+
+void *realloc(void *p, size_t n)
+{
+	struct chunk *self, *next;
+	size_t n0, n1;
+	void *new;
+
+	if (!p) return malloc(n);
+	if (!n) {
+		free(p);
+		return NULL;
+	}
+
+	if (adjust_size(&n) < 0) return 0;
+
+	self = MEM_TO_CHUNK(p);
+	n1 = n0 = CHUNK_SIZE(self);
+
+	if (IS_MMAPPED(self)) {
+		size_t extra = self->psize;
+		char *base = (char *)self - extra;
+		size_t oldlen = n0 + extra;
+		size_t newlen = n + extra;
+		/* Crash on realloc of freed chunk */
+		if (extra & 1) a_crash();
+		if (newlen < PAGE_SIZE && (new = malloc(n-OVERHEAD))) {
+			n0 = n;
+			goto copy_free_ret;
+		}
+		newlen = (newlen + PAGE_SIZE-1) & -PAGE_SIZE;
+		if (oldlen == newlen) return p;
+		base = __mremap(base, oldlen, newlen, MREMAP_MAYMOVE);
+		if (base == (void *)-1)
+			goto copy_realloc;
+		self = (void *)(base + extra);
+		self->csize = newlen - extra;
+		return CHUNK_TO_MEM(self);
+	}
+
+	next = NEXT_CHUNK(self);
+
+	/* Crash on corrupted footer (likely from buffer overflow) */
+	if (next->psize != self->csize) a_crash();
+
+	/* Merge adjacent chunks if we need more space. This is not
+	 * a waste of time even if we fail to get enough space, because our
+	 * subsequent call to free would otherwise have to do the merge. */
+	if (n > n1 && alloc_fwd(next)) {
+		n1 += CHUNK_SIZE(next);
+		next = NEXT_CHUNK(next);
+	}
+	/* FIXME: find what's wrong here and reenable it..? */
+	if (0 && n > n1 && alloc_rev(self)) {
+		self = PREV_CHUNK(self);
+		n1 += CHUNK_SIZE(self);
+	}
+	self->csize = n1 | C_INUSE;
+	next->psize = n1 | C_INUSE;
+
+	/* If we got enough space, split off the excess and return */
+	if (n <= n1) {
+		//memmove(CHUNK_TO_MEM(self), p, n0-OVERHEAD);
+		trim(self, n);
+		return CHUNK_TO_MEM(self);
+	}
+
+copy_realloc:
+	/* As a last resort, allocate a new chunk and copy to it. */
+	new = malloc(n-OVERHEAD);
+	if (!new) return 0;
+copy_free_ret:
+	memcpy(new, p, n0-OVERHEAD);
+	free(CHUNK_TO_MEM(self));
+	return new;
+}
+
+void __bin_chunk(struct chunk *self)
+{
+	struct chunk *next = NEXT_CHUNK(self);
+	size_t final_size, new_size, size;
+	int reclaim=0;
+	int i;
+
+	final_size = new_size = CHUNK_SIZE(self);
+
+	/* Crash on corrupted footer (likely from buffer overflow) */
+	if (next->psize != self->csize) a_crash();
+
+	for (;;) {
+		if (self->psize & next->csize & C_INUSE) {
+			self->csize = final_size | C_INUSE;
+			next->psize = final_size | C_INUSE;
+			i = bin_index(final_size);
+			lock_bin(i);
+			lock(mal.free_lock);
+			if (self->psize & next->csize & C_INUSE)
+				break;
+			unlock(mal.free_lock);
+			unlock_bin(i);
+		}
+
+		if (alloc_rev(self)) {
+			self = PREV_CHUNK(self);
+			size = CHUNK_SIZE(self);
+			final_size += size;
+			if (new_size+size > RECLAIM && (new_size+size^size) > size)
+				reclaim = 1;
+		}
+
+		if (alloc_fwd(next)) {
+			size = CHUNK_SIZE(next);
+			final_size += size;
+			if (new_size+size > RECLAIM && (new_size+size^size) > size)
+				reclaim = 1;
+			next = NEXT_CHUNK(next);
+		}
+	}
+
+	if (!(mal.binmap & 1ULL<<i))
+		a_or_64(&mal.binmap, 1ULL<<i);
+
+	self->csize = final_size;
+	next->psize = final_size;
+	unlock(mal.free_lock);
+
+	self->next = BIN_TO_CHUNK(i);
+	self->prev = mal.bins[i].tail;
+	self->next->prev = self;
+	self->prev->next = self;
+
+	/* Replace middle of large chunks with fresh zero pages */
+	if (reclaim) {
+		uintptr_t a = (uintptr_t)self + SIZE_ALIGN+PAGE_SIZE-1 & -PAGE_SIZE;
+		uintptr_t b = (uintptr_t)next - SIZE_ALIGN & -PAGE_SIZE;
+#if 1
+		__madvise((void *)a, b-a, MADV_DONTNEED);
+#else
+		__mmap((void *)a, b-a, PROT_READ|PROT_WRITE,
+			MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED, -1, 0);
+#endif
+	}
+
+	unlock_bin(i);
+}
+
+static void unmap_chunk(struct chunk *self)
+{
+	size_t extra = self->psize;
+	char *base = (char *)self - extra;
+	size_t len = CHUNK_SIZE(self) + extra;
+	/* Crash on double free */
+	if (extra & 1) a_crash();
+	__munmap(base, len);
+}
+
+void free(void *p)
+{
+	if (!p) return;
+
+	struct chunk *self = MEM_TO_CHUNK(p);
+
+	if (IS_MMAPPED(self))
+		unmap_chunk(self);
+	else
+		__bin_chunk(self);
+}
+
+void __malloc_donate(char *start, char *end)
+{
+	size_t align_start_up = (SIZE_ALIGN-1) & (-(uintptr_t)start - OVERHEAD);
+	size_t align_end_down = (SIZE_ALIGN-1) & (uintptr_t)end;
+
+	/* Getting past this condition ensures that the padding for alignment
+	 * and header overhead will not overflow and will leave a nonzero
+	 * multiple of SIZE_ALIGN bytes between start and end. */
+	if (end - start <= OVERHEAD + align_start_up + align_end_down)
+		return;
+	start += align_start_up + OVERHEAD;
+	end   -= align_end_down;
+
+	struct chunk *c = MEM_TO_CHUNK(start), *n = MEM_TO_CHUNK(end);
+	c->psize = n->csize = C_INUSE;
+	c->csize = n->psize = C_INUSE | (end-start);
+	__bin_chunk(c);
+}

porting/linux/user/src/passwd/getspnam_r.c

+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <ctype.h>
+#include <pthread.h>
+#include "pwf.h"
+
+/* This implementation support Openwall-style TCB passwords in place of
+ * traditional shadow, if the appropriate directories and files exist.
+ * Thus, it is careful to avoid following symlinks or blocking on fifos
+ * which a malicious user might create in place of his or her TCB shadow
+ * file. It also avoids any allocation to prevent memory-exhaustion
+ * attacks via huge TCB shadow files. */
+
+static long xatol(char **s)
+{
+	long x;
+	int sign;
+	if (**s == ':' || **s == '\n') return -1;
+
+	sign = (int)(unsigned char)**s;
+	if (sign == '-' || sign == '+') ++*s;
+
+	for (x=0; **s-'0'<10U; ++*s) x=10*x+(**s-'0');
+
+	if (sign == '-') return -x;
+	return x;
+}
+
+int __parsespent(char *s, struct spwd *sp)
+{
+	sp->sp_namp = s;
+	if (!(s = strchr(s, ':'))) return -1;
+	*s = 0;
+
+	sp->sp_pwdp = ++s;
+	if (!(s = strchr(s, ':'))) return -1;
+	*s = 0;
+
+	s++; sp->sp_lstchg = xatol(&s);
+	if (*s != ':') return -1;
+
+	s++; sp->sp_min = xatol(&s);
+	if (*s != ':') return -1;
+
+	s++; sp->sp_max = xatol(&s);
+	if (*s != ':') return -1;
+
+	s++; sp->sp_warn = xatol(&s);
+	if (*s != ':') return -1;
+
+	s++; sp->sp_inact = xatol(&s);
+	if (*s != ':') return -1;
+
+	s++; sp->sp_expire = xatol(&s);
+	if (*s != ':') return -1;
+
+	s++; sp->sp_flag = xatol(&s);
+	if (*s != '\n') return -1;
+	return 0;
+}
+
+static void cleanup(void *p)
+{
+	fclose(p);
+}
+
+int getspnam_r(const char *name, struct spwd *sp, char *buf, size_t size, struct spwd **res)
+{
+	char path[20+NAME_MAX];
+	FILE *f = 0;
+	int rv = 0;
+	int fd;
+	size_t k, l = strlen(name);
+	int skip = 0;
+	int cs;
+	int orig_errno = errno;
+
+	*res = 0;
+
+	/* Disallow potentially-malicious user names */
+	if (*name=='.' || strchr(name, '/') || !l)
+		return errno = EINVAL;
+
+	/* Buffer size must at least be able to hold name, plus some.. */
+	if (size < l+100)
+		return errno = ERANGE;
+
+	/* Protect against truncation */
+	if (snprintf(path, sizeof path, "/etc/tcb/%s/shadow", name) >= sizeof path)
+		return errno = EINVAL;
+
+	fd = open(path, O_RDONLY|O_NOFOLLOW|O_NONBLOCK|O_CLOEXEC);
+	if (fd >= 0) {
+		struct stat st = { 0 };
+		errno = EINVAL;
+		if (fstat(fd, &st) || !S_ISREG(st.st_mode) || !(f = fdopen(fd, "rb"))) {
+			pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
+			close(fd);
+			pthread_setcancelstate(cs, 0);
+			return errno;
+		}
+	} else {
+		if (errno != ENOENT && errno != ENOTDIR)
+			return errno;
+		f = fopen("/etc/shadow", "rbe");
+		if (!f) {
+			if (errno != ENOENT && errno != ENOTDIR)
+				return errno;
+			return 0;
+		}
+	}
+
+	pthread_cleanup_push(cleanup, f);
+	while (fgets(buf, size, f) && (k=strlen(buf))>0) {
+		if (skip || strncmp(name, buf, l) || buf[l]!=':') {
+			skip = buf[k-1] != '\n';
+			continue;
+		}
+		if (buf[k-1] != '\n') {
+			rv = ERANGE;
+			break;
+		}
+
+		if (__parsespent(buf, sp) < 0) continue;
+		*res = sp;
+		break;
+	}
+	pthread_cleanup_pop(1);
+	errno = rv ? rv : orig_errno;
+	return rv;
+}

porting/linux/user/tools/install.sh

+#!/bin/sh
+#
+# This is an actually-safe install command which installs the new
+# file atomically in the new location, rather than overwriting
+# existing files.
+#
+
+usage() {
+printf "usage: %s [-D] [-l] [-r] [-m mode] src dest\n" "$0" 1>&2
+exit 1
+}
+
+mkdirp=
+symlink=
+symlinkflags="-s"
+mode=755
+
+while getopts Dlrm: name ; do
+case "$name" in
+D) mkdirp=yes ;;
+l) symlink=yes ;;
+r) symlink=yes; symlinkflags="$symlinkflags -r" ;;
+m) mode=$OPTARG ;;
+?) usage ;;
+esac
+done
+shift $(($OPTIND - 1))
+
+test "$#" -eq 2 || usage
+src=$1
+dst=$2
+tmp="$dst.tmp.$$"
+
+case "$dst" in
+*/) printf "%s: %s ends in /\n", "$0" "$dst" 1>&2 ; exit 1 ;;
+esac
+
+set -C
+set -e
+
+if test "$mkdirp" ; then
+umask 022
+case "$2" in
+*/*) mkdir -p "${dst%/*}" ;;
+esac
+fi
+
+trap 'rm -f "$tmp"' EXIT INT QUIT TERM HUP
+
+umask 077
+
+if test "$symlink" ; then
+ln $symlinkflags "$1" "$tmp"
+else
+cat < "$1" > "$tmp"
+chmod "$mode" "$tmp"
+fi
+
+mv -f "$tmp" "$2"
+test -d "$2" && {
+rm -f "$2/$tmp"
+printf "%s: %s is a directory\n" "$0" "$dst" 1>&2
+exit 1
+}
+
+exit 0

scripts/create_alltypes.sh

+#!/usr/bin/env sh
+
+# not check args
+
+while getopts o: opt
+do
+    case $opt in
+        s) 
+            src=$OPTARG
+            ;;
+        o)
+            output=$OPTARG
+            ;;
+        ?)
+            #usage
+            ;;
+    esac
+done
+shift $(($OPTIND - 1))
+
+echo $0 "$@" $output 
+
+sed -f $@ > $output

scripts/create_syscall.sh

+#!/usr/bin/env sh
+
+if [ $# -ne 2 ]; then
+    echo "$0 need 2 parameters, but the actual number is $#, please check!"
+    exit 1
+fi
+
+rm -f $2
+
+cp $1 $2
+
+sed  -n -e s/__NR_/SYS_/p < $1 >> $2 

scripts/create_vesion.sh

+#!/usr/bin/env sh
+
+out_putdir=$3
+
+if [ ! -d $out_putdir ]
+then
+    mkdir -p $out_putdir
+fi
+
+cp $1 $out_putdir/VERSION
+cp $2 $out_putdir/version.sh
+
+cd $out_putdir
+
+version=$(sh version.sh)
+
+printf '#define VERSION "%s"\n' $version  > version.h
+
+rm VERSION version.sh

scripts/install.py

+#!/usr/bin/env python
+
+import os
+import sys
+import argparse
+from shutil import copy
+
+def musl_copy_file(src, dest):
+    dest_dir = os.path.dirname(dest)
+    if not os.path.exists(dest_dir):
+        os.makedirs(dest_dir)
+    copy(src, dest)
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+
+    parser.add_argument('--input',
+                        required = True,
+                        help = 'The header source path',
+                        metavar = 'FILE')
+
+    parser.add_argument('--output',
+                        required = True,
+                        help = 'The output directory',
+                        metavar = 'FILE')
+
+    args = parser.parse_args()
+
+    musl_copy_file(args.input, args.output)
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/porting.sh

+SRC_DIR=
+DST_DIR=
+PORTING=
+
+while getopts "i:o:p:h" arg
+do 
+    case "${arg}" in
+        "i")
+            SRC_DIR=${OPTARG}
+	    ;;
+        "o")
+            DST_DIR=${OPTARG}
+	    ;;
+        "p")
+	    PORTING=${OPTARG}
+	    ;;
+        "h")
+	    echo "help"
+	    ;;
+	?)
+	    echo "unkonw argument"
+	    exit 1
+	    ;;
+    esac
+done
+
+if [ ! -d ${DST_DIR} ]; then
+    mkdir -p ${DST_DIR}
+fi
+cp -rfp ${SRC_DIR}/* ${DST_DIR}
+cp -rfp ${SRC_DIR}/porting/${PORTING}/user/* ${DST_DIR}