This patch backports the support/ directory as of the upstream commit

below.  (It does not include the required Makefile changes to enable

test-in-container builds.)

commit 00c86a37d1b63044e3169d1f2ebec23447c73f79

Author: Adhemerval Zanella <adhemerval.zanella@linaro.org>

Date:   Wed Nov 7 11:09:02 2018 -0200

    support: Fix printf format for TEST_COMPARE_STRING

    Fix the following on 32 bits targets:

    support_test_compare_string.c: In function ‘support_test_compare_string’:

    support_test_compare_string.c:80:37: error: format ‘%lu’ expects argument of

    type ‘long unsigned int’, but argument 2 has type ‘size_t’ {aka ‘unsigned int’}

    [-Werror=format=]

             printf ("  string length: %lu bytes\n", left_length);

                                       ~~^           ~~~~~~~~~~~

                                       %u

    Checked on arm-linux-gnueabihf.

            * support/support_test_compare_string.c

            (support_test_compare_string): Fix printf format.

diff --git a/support/Makefile b/support/Makefile

index 652d2cdf6945b2eb..2b663fbbfa334ea2 100644

--- a/support/Makefile

+++ b/support/Makefile

@@ -25,6 +25,7 @@ extra-libs-others = $(extra-libs)

 extra-libs-noinstall := $(extra-libs)

 libsupport-routines = \

+  blob_repeat \

   check \

   check_addrinfo \

   check_dns_packet \

@@ -43,6 +44,8 @@ libsupport-routines = \

   support_capture_subprocess \

   support_capture_subprocess_check \

   support_chroot \

+  support_copy_file_range \

+  support_descriptor_supports_holes \

   support_enter_mount_namespace \

   support_enter_network_namespace \

   support_format_address_family \

@@ -53,12 +56,14 @@ libsupport-routines = \

   support_format_netent \

   support_isolate_in_subprocess \

   support_openpty \

+  support_paths \

   support_quote_blob \

   support_record_failure \

   support_run_diff \

   support_shared_allocate \

   support_test_compare_blob \

   support_test_compare_failure \

+  support_test_compare_string \

   support_write_file_string \

   support_test_main \

   support_test_verify_impl \

@@ -72,6 +77,7 @@ libsupport-routines = \

   xchroot \

   xclose \

   xconnect \

+  xcopy_file_range \

   xdlfcn \

   xdup2 \

   xfclose \

@@ -84,6 +90,7 @@ libsupport-routines = \

   xmalloc \

   xmemstream \

   xmkdir \

+  xmkdirp \

   xmmap \

   xmprotect \

   xmunmap \

@@ -139,6 +146,7 @@ libsupport-routines = \

   xsocket \

   xstrdup \

   xstrndup \

+  xsymlink \

   xsysconf \

   xunlink \

   xwaitpid \

@@ -151,15 +159,47 @@ ifeq ($(build-shared),yes)

 libsupport-inhibit-o += .o

 endif

+CFLAGS-support_paths.c = \

+		-DSRCDIR_PATH=\"`cd .. ; pwd`\" \

+		-DOBJDIR_PATH=\"`cd $(objpfx)/..; pwd`\" \

+		-DOBJDIR_ELF_LDSO_PATH=\"`cd $(objpfx)/..; pwd`/elf/$(rtld-installed-name)\" \

+		-DINSTDIR_PATH=\"$(prefix)\" \

+		-DLIBDIR_PATH=\"$(libdir)\"

+

+ifeq (,$(CXX))

+LINKS_DSO_PROGRAM = links-dso-program-c

+else

+LINKS_DSO_PROGRAM = links-dso-program

+LDLIBS-links-dso-program = -lstdc++ -lgcc -lgcc_s $(libunwind)

+endif

+

+LDLIBS-test-container = $(libsupport)

+

+others += test-container

+others-noinstall += test-container

+

+others += shell-container echo-container true-container

+others-noinstall += shell-container echo-container true-container

+

+others += $(LINKS_DSO_PROGRAM)

+others-noinstall += $(LINKS_DSO_PROGRAM)

+

+$(objpfx)test-container : $(libsupport)

+$(objpfx)shell-container : $(libsupport)

+$(objpfx)echo-container : $(libsupport)

+$(objpfx)true-container : $(libsupport)

+

 tests = \

   README-testing \

   tst-support-namespace \

+  tst-support_blob_repeat \

   tst-support_capture_subprocess \

   tst-support_format_dns_packet \

   tst-support_quote_blob \

   tst-support_record_failure \

   tst-test_compare \

   tst-test_compare_blob \

+  tst-test_compare_string \

   tst-xreadlink \

 ifeq ($(run-built-tests),yes)

diff --git a/support/blob_repeat.c b/support/blob_repeat.c

new file mode 100644

index 0000000000000000..16c1e448b990e386

--- /dev/null

+++ b/support/blob_repeat.c

@@ -0,0 +1,282 @@

+/* Repeating a memory blob, with alias mapping optimization.

+   Copyright (C) 2018 Free Software Foundation, Inc.

+   This file is part of the GNU C Library.

+

+   The GNU C Library is free software; you can redistribute it and/or

+   modify it under the terms of the GNU Lesser General Public

+   License as published by the Free Software Foundation; either

+   version 2.1 of the License, or (at your option) any later version.

+

+   The GNU C Library is distributed in the hope that it will be useful,

+   but WITHOUT ANY WARRANTY; without even the implied warranty of

+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+   Lesser General Public License for more details.

+

+   You should have received a copy of the GNU Lesser General Public

+   License along with the GNU C Library; if not, see

+   <http://www.gnu.org/licenses/>.  */

+

+#include <errno.h>

+#include <fcntl.h>

+#include <stdbool.h>

+#include <stdlib.h>

+#include <string.h>

+#include <support/blob_repeat.h>

+#include <support/check.h>

+#include <support/test-driver.h>

+#include <support/support.h>

+#include <support/xunistd.h>

+#include <sys/mman.h>

+#include <unistd.h>

+#include <wchar.h>

+

+/* Small allocations should use malloc directly instead of the mmap

+   optimization because mappings carry a lot of overhead.  */

+static const size_t maximum_small_size = 4 * 1024 * 1024;

+

+/* Internal helper for fill.  */

+static void

+fill0 (char *target, const char *element, size_t element_size,

+       size_t count)

+{

+  while (count > 0)

+    {

+      memcpy (target, element, element_size);

+      target += element_size;

+      --count;

+    }

+}

+

+/* Fill the buffer at TARGET with COUNT copies of the ELEMENT_SIZE

+   bytes starting at ELEMENT.  */

+static void

+fill (char *target, const char *element, size_t element_size,

+      size_t count)

+{

+  if (element_size == 0 || count == 0)

+    return;

+  else if (element_size == 1)

+    memset (target, element[0], count);

+  else if (element_size == sizeof (wchar_t))

+    {

+      wchar_t wc;

+      memcpy (&wc, element, sizeof (wc));

+      wmemset ((wchar_t *) target, wc, count);

+    }

+  else if (element_size < 1024 && count > 4096)

+    {

+      /* Use larger copies for really small element sizes.  */

+      char buffer[8192];

+      size_t buffer_count = sizeof (buffer) / element_size;

+      fill0 (buffer, element, element_size, buffer_count);

+      while (count > 0)

+        {

+          size_t copy_count = buffer_count;

+          if (copy_count > count)

+            copy_count = count;

+          size_t copy_bytes = copy_count * element_size;

+          memcpy (target, buffer, copy_bytes);

+          target += copy_bytes;

+          count -= copy_count;

+        }

+    }

+  else

+    fill0 (target, element, element_size, count);

+}

+

+/* Use malloc instead of mmap for small allocations and unusual size

+   combinations.  */

+static struct support_blob_repeat

+allocate_malloc (size_t total_size, const void *element, size_t element_size,

+                 size_t count)

+{

+  void *buffer = malloc (total_size);

+  if (buffer == NULL)

+    return (struct support_blob_repeat) { 0 };

+  fill (buffer, element, element_size, count);

+  return (struct support_blob_repeat)

+    {

+      .start = buffer,

+      .size = total_size,

+      .use_malloc = true

+    };

+}

+

+/* Return the least common multiple of PAGE_SIZE and ELEMENT_SIZE,

+   avoiding overflow.  This assumes that PAGE_SIZE is a power of

+   two.  */

+static size_t

+minimum_stride_size (size_t page_size, size_t element_size)

+{

+  TEST_VERIFY_EXIT (page_size > 0);

+  TEST_VERIFY_EXIT (element_size > 0);

+

+  /* Compute the number of trailing zeros common to both sizes.  */

+  unsigned int common_zeros = __builtin_ctzll (page_size | element_size);

+

+  /* In the product, this power of two appears twice, but in the least

+     common multiple, it appears only once.  Therefore, shift one

+     factor.  */

+  size_t multiple;

+  if (__builtin_mul_overflow (page_size >> common_zeros, element_size,

+                              &multiple))

+    return 0;

+  return multiple;

+}

+

+/* Allocations larger than maximum_small_size potentially use mmap

+   with alias mappings.  */

+static struct support_blob_repeat

+allocate_big (size_t total_size, const void *element, size_t element_size,

+              size_t count)

+{

+  unsigned long page_size = xsysconf (_SC_PAGESIZE);

+  size_t stride_size = minimum_stride_size (page_size, element_size);

+  if (stride_size == 0)

+    {

+      errno = EOVERFLOW;

+      return (struct support_blob_repeat) { 0 };

+    }

+

+  /* Ensure that the stride size is at least maximum_small_size.  This

+     is necessary to reduce the number of distinct mappings.  */

+  if (stride_size < maximum_small_size)

+    stride_size

+      = ((maximum_small_size + stride_size - 1) / stride_size) * stride_size;

+

+  if (stride_size > total_size)

+    /* The mmap optimization would not save anything.  */

+    return allocate_malloc (total_size, element, element_size, count);

+

+  /* Reserve the memory region.  If we cannot create the mapping,

+     there is no reason to set up the backing file.  */

+  void *target = mmap (NULL, total_size, PROT_NONE,

+                       MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);

+  if (target == MAP_FAILED)

+    return (struct support_blob_repeat) { 0 };

+

+  /* Create the backing file for the repeated mapping.  Call mkstemp

+     directly to remove the resources backing the temporary file

+     immediately, once support_blob_repeat_free is called.  Using

+     create_temp_file would result in a warning during post-test

+     cleanup.  */

+  int fd;

+  {

+    char *temppath = xasprintf ("%s/support_blob_repeat-XXXXXX", test_dir);

+    fd = mkstemp (temppath);

+    if (fd < 0)

+      FAIL_EXIT1 ("mkstemp (\"%s\"): %m", temppath);

+    xunlink (temppath);

+    free (temppath);

+  }

+

+  /* Make sure that there is backing storage, so that the fill

+     operation will not fault.  */

+  if (posix_fallocate (fd, 0, stride_size) != 0)

+    FAIL_EXIT1 ("posix_fallocate (%zu): %m", stride_size);

+

+  /* The stride size must still be a multiple of the page size and

+     element size.  */

+  TEST_VERIFY_EXIT ((stride_size % page_size) == 0);

+  TEST_VERIFY_EXIT ((stride_size % element_size) == 0);

+

+  /* Fill the backing store.  */

+  {

+    void *ptr = mmap (target, stride_size, PROT_READ | PROT_WRITE,

+                      MAP_FIXED | MAP_FILE | MAP_SHARED, fd, 0);

+    if (ptr == MAP_FAILED)

+      {

+        int saved_errno = errno;

+        xmunmap (target, total_size);

+        xclose (fd);

+        errno = saved_errno;

+        return (struct support_blob_repeat) { 0 };

+      }

+    if (ptr != target)

+      FAIL_EXIT1 ("mapping of %zu bytes moved from %p to %p",

+                  stride_size, target, ptr);

+

+    /* Write the repeating data.  */

+    fill (target, element, element_size, stride_size / element_size);

+

+    /* Return to a PROT_NONE mapping, just to be on the safe side.  */

+    ptr = mmap (target, stride_size, PROT_NONE,

+                MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);

+    if (ptr == MAP_FAILED)

+      FAIL_EXIT1 ("Failed to reinstate PROT_NONE mapping: %m");

+    if (ptr != target)

+      FAIL_EXIT1 ("PROT_NONE mapping of %zu bytes moved from %p to %p",

+                  stride_size, target, ptr);

+  }

+

+  /* Create the alias mappings.  */

+  {

+    size_t remaining_size = total_size;

+    char *current = target;

+    int flags = MAP_FIXED | MAP_FILE | MAP_PRIVATE;

+#ifdef MAP_NORESERVE

+    flags |= MAP_NORESERVE;

+#endif

+    while (remaining_size > 0)

+      {

+        size_t to_map = stride_size;

+        if (to_map > remaining_size)

+          to_map = remaining_size;

+        void *ptr = mmap (current, to_map, PROT_READ | PROT_WRITE,

+                          flags, fd, 0);

+        if (ptr == MAP_FAILED)

+          {

+            int saved_errno = errno;

+            xmunmap (target, total_size);

+            xclose (fd);

+            errno = saved_errno;

+            return (struct support_blob_repeat) { 0 };

+          }

+        if (ptr != current)

+          FAIL_EXIT1 ("MAP_PRIVATE mapping of %zu bytes moved from %p to %p",

+                      to_map, target, ptr);

+        remaining_size -= to_map;

+        current += to_map;

+      }

+  }

+

+  xclose (fd);

+

+  return (struct support_blob_repeat)

+    {

+      .start = target,

+      .size = total_size,

+      .use_malloc = false

+    };

+}

+

+struct support_blob_repeat

+support_blob_repeat_allocate (const void *element, size_t element_size,

+                              size_t count)

+{

+  size_t total_size;

+  if (__builtin_mul_overflow (element_size, count, &total_size))

+    {

+      errno = EOVERFLOW;

+      return (struct support_blob_repeat) { 0 };

+    }

+  if (total_size <= maximum_small_size)

+    return allocate_malloc (total_size, element, element_size, count);

+  else

+    return allocate_big (total_size, element, element_size, count);

+}

+

+void

+support_blob_repeat_free (struct support_blob_repeat *blob)

+{

+  if (blob->size > 0)

+    {

+      int saved_errno = errno;

+      if (blob->use_malloc)

+        free (blob->start);

+      else

+        xmunmap (blob->start, blob->size);

+      errno = saved_errno;

+    }

+  *blob = (struct support_blob_repeat) { 0 };

+}

diff --git a/support/blob_repeat.h b/support/blob_repeat.h

new file mode 100644

index 0000000000000000..8e9d7ff5f1e01f66

--- /dev/null

+++ b/support/blob_repeat.h

@@ -0,0 +1,44 @@

+/* Repeating a memory blob, with alias mapping optimization.

+   Copyright (C) 2018 Free Software Foundation, Inc.

+   This file is part of the GNU C Library.

+

+   The GNU C Library is free software; you can redistribute it and/or

+   modify it under the terms of the GNU Lesser General Public

+   License as published by the Free Software Foundation; either

+   version 2.1 of the License, or (at your option) any later version.

+

+   The GNU C Library is distributed in the hope that it will be useful,

+   but WITHOUT ANY WARRANTY; without even the implied warranty of

+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+   Lesser General Public License for more details.

+

+   You should have received a copy of the GNU Lesser General Public

+   License along with the GNU C Library; if not, see

+   <http://www.gnu.org/licenses/>.  */

+

+#ifndef SUPPORT_BLOB_REPEAT_H

+#define SUPPORT_BLOB_REPEAT_H

+

+#include <stdbool.h>

+#include <stddef.h>

+

+struct support_blob_repeat

+{

+  void *start;

+  size_t size;

+  bool use_malloc;

+};

+

+/* Return an allocation of COUNT elements, each of ELEMENT_SIZE bytes,

+   initialized with the bytes starting at ELEMENT.  The memory is

+   writable (and thus counts towards the commit charge).  In case of

+   on error, all members of the return struct are zero-initialized,

+   and errno is set accordingly.  */

+struct support_blob_repeat support_blob_repeat_allocate (const void *element,

+                                                         size_t element_size,

+                                                         size_t count);

+

+/* Deallocate the blob created by support_blob_repeat_allocate.  */

+void support_blob_repeat_free (struct support_blob_repeat *);

+

+#endif /* SUPPORT_BLOB_REPEAT_H */

diff --git a/support/check.h b/support/check.h

index b3a4645e9255e90d..e6765289f2492501 100644

--- a/support/check.h

+++ b/support/check.h

@@ -163,6 +163,19 @@ void support_test_compare_blob (const void *left,

                                 const char *right_exp,

                                 const char *right_len_exp);

+/* Compare the strings LEFT and RIGHT and report a test failure if

+   they are different.  Also report failure if one of the arguments is

+   a null pointer and the other is not.  The strings should be

+   reasonably short because on mismatch, both are printed.  */

+#define TEST_COMPARE_STRING(left, right)                         \

+  (support_test_compare_string (left, right, __FILE__, __LINE__, \

+                                #left, #right))

+

+void support_test_compare_string (const char *left, const char *right,

+                                  const char *file, int line,

+                                  const char *left_expr,

+                                  const char *right_expr);

+

 /* Internal function called by the test driver.  */

 int support_report_failure (int status)

   __attribute__ ((weak, warn_unused_result));

diff --git a/support/echo-container.c b/support/echo-container.c

new file mode 100644

index 0000000000000000..e4d48df95722af2e

--- /dev/null

+++ b/support/echo-container.c

@@ -0,0 +1,34 @@

+/* Minimal /bin/echo for in-container use.

+   Copyright (C) 2018 Free Software Foundation, Inc.

+   This file is part of the GNU C Library.

+

+   The GNU C Library is free software; you can redistribute it and/or

+   modify it under the terms of the GNU Lesser General Public

+   License as published by the Free Software Foundation; either

+   version 2.1 of the License, or (at your option) any later version.

+

+   The GNU C Library is distributed in the hope that it will be useful,

+   but WITHOUT ANY WARRANTY; without even the implied warranty of

+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+   Lesser General Public License for more details.

+

+   You should have received a copy of the GNU Lesser General Public

+   License along with the GNU C Library; if not, see

+   <http://www.gnu.org/licenses/>.  */

+

+#include <stdio.h>

+

+int

+main (int argc, const char **argv)

+{

+  int i;

+

+  for (i = 1; i < argc; i++)

+    {

+      if (i > 1)

+	putchar (' ');

+      fputs (argv[i], stdout);

+    }

+  putchar ('\n');

+  return 0;

+}

diff --git a/support/links-dso-program-c.c b/support/links-dso-program-c.c

new file mode 100644

index 0000000000000000..d28a28a0d09c743c

--- /dev/null

+++ b/support/links-dso-program-c.c

@@ -0,0 +1,9 @@

+#include <stdio.h>

+

+int

+main (int argc, char **argv)

+{

+  /* Complexity to keep gcc from optimizing this away.  */

+  printf ("This is a test %s.\n", argc > 1 ? argv[1] : "null");

+  return 0;

+}

diff --git a/support/links-dso-program.cc b/support/links-dso-program.cc

new file mode 100644

index 0000000000000000..dba6976c0609a332

--- /dev/null

+++ b/support/links-dso-program.cc

@@ -0,0 +1,11 @@

+#include <iostream>

+

+using namespace std;

+

+int

+main (int argc, char **argv)

+{

+  /* Complexity to keep gcc from optimizing this away.  */

+  cout << (argc > 1 ? argv[1] : "null");

+  return 0;

+}

diff --git a/support/shell-container.c b/support/shell-container.c

new file mode 100644

index 0000000000000000..9bd90d3f60529079

--- /dev/null

+++ b/support/shell-container.c

@@ -0,0 +1,395 @@

+/* Minimal /bin/sh for in-container use.

+   Copyright (C) 2018 Free Software Foundation, Inc.

+   This file is part of the GNU C Library.

+

+   The GNU C Library is free software; you can redistribute it and/or

+   modify it under the terms of the GNU Lesser General Public

+   License as published by the Free Software Foundation; either

+   version 2.1 of the License, or (at your option) any later version.

+

+   The GNU C Library is distributed in the hope that it will be useful,

+   but WITHOUT ANY WARRANTY; without even the implied warranty of

+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+   Lesser General Public License for more details.

+

+   You should have received a copy of the GNU Lesser General Public

+   License along with the GNU C Library; if not, see

+   <http://www.gnu.org/licenses/>.  */

+

+#define _FILE_OFFSET_BITS 64

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <sched.h>

+#include <sys/syscall.h>

+#include <unistd.h>

+#include <sys/types.h>

+#include <dirent.h>

+#include <string.h>

+#include <sys/stat.h>

+#include <sys/fcntl.h>

+#include <sys/file.h>

+#include <sys/wait.h>

+#include <stdarg.h>

+#include <sys/sysmacros.h>

+#include <ctype.h>

+#include <utime.h>

+#include <errno.h>

+#include <error.h>

+

+#include <support/support.h>

+

+/* Design considerations

+

+ General rule: optimize for developer time, not run time.

+

+ Specifically:

+

+ * Don't worry about slow algorithms

+ * Don't worry about free'ing memory

+ * Don't implement anything the testsuite doesn't need.

+ * Line and argument counts are limited, see below.

+

+*/

+

+#define MAX_ARG_COUNT 100

+#define MAX_LINE_LENGTH 1000

+

+/* Debugging is enabled via --debug, which must be the first argument.  */

+static int debug_mode = 0;

+#define dprintf if (debug_mode) fprintf

+

+/* Emulate the "/bin/true" command.  Arguments are ignored.  */

+static int

+true_func (char **argv)

+{

+  return 0;

+}

+

+/* Emulate the "/bin/echo" command.  Options are ignored, arguments

+   are printed to stdout.  */

+static int

+echo_func (char **argv)

+{

+  int i;

+

+  for (i = 0; argv[i]; i++)

+    {

+      if (i > 0)

+	putchar (' ');

+      fputs (argv[i], stdout);

+    }

+  putchar ('\n');

+

+  return 0;

+}

+

+/* Emulate the "/bin/cp" command.  Options are ignored.  Only copies

+   one source file to one destination file.  Directory destinations

+   are not supported.  */

+static int

+copy_func (char **argv)

+{

+  char *sname = argv[0];

+  char *dname = argv[1];

+  int sfd, dfd;

+  struct stat st;

+

+  sfd = open (sname, O_RDONLY);

+  if (sfd < 0)

+    {

+      fprintf (stderr, "cp: unable to open %s for reading: %s\n",

+	       sname, strerror (errno));

+      return 1;

+    }

+

+  if (fstat (sfd, &st) < 0)

+    {

+      fprintf (stderr, "cp: unable to fstat %s: %s\n",

+	       sname, strerror (errno));

+      return 1;

+    }

+

+  dfd = open (dname, O_WRONLY | O_TRUNC | O_CREAT, 0600);

+  if (dfd < 0)

+    {

+      fprintf (stderr, "cp: unable to open %s for writing: %s\n",

+	       dname, strerror (errno));

+      return 1;

+    }

+

+  if (support_copy_file_range (sfd, 0, dfd, 0, st.st_size, 0) != st.st_size)

+    {

+      fprintf (stderr, "cp: cannot copy file %s to %s: %s\n",

+	       sname, dname, strerror (errno));

+      return 1;

+    }

+

+  close (sfd);

+  close (dfd);

+

+  chmod (dname, st.st_mode & 0777);

+

+  return 0;

+

+}

+

+/* This is a list of all the built-in commands we understand.  */

+static struct {

+  const char *name;

+  int (*func) (char **argv);

+} builtin_funcs[] = {

+  { "true", true_func },

+  { "echo", echo_func },

+  { "cp", copy_func },

+  { NULL, NULL }

+};