Add renameat2 function [BZ #17662]

The implementation falls back to renameat if renameat2 is not available
in the kernel (or in the kernel headers) and the flags argument is zero.
Without kernel support, a non-zero argument returns EINVAL, not ENOSYS.
This mirrors what the kernel does for invalid renameat2 flags.

5 files changed, 242 insertions, 3 deletions

diff --git a/stdio-common/Makefile b/stdio-common/Makefile
index 96bd7c3..a10f12a 100644
--- a/stdio-common/Makefile
+++ b/stdio-common/Makefile
@@ -35,7 +35,7 @@ routines	:=							      \
 	perror psignal							      \
 	tmpfile tmpfile64 tmpnam tmpnam_r tempnam tempname		      \
 	getline getw putw						      \
-	remove rename renameat						      \
+	remove rename renameat renameat2				      \
 	flockfile ftrylockfile funlockfile				      \
 	isoc99_scanf isoc99_vscanf isoc99_fscanf isoc99_vfscanf isoc99_sscanf \
 	isoc99_vsscanf							      \
@@ -62,6 +62,7 @@ tests := tstscanf test_rdwr test-popen tstgetln test-fseek \
 	 tst-vfprintf-user-type \
 	 tst-vfprintf-mbs-prec \
 	 tst-scanf-round \
+	 tst-renameat2 \
 
 test-srcs = tst-unbputc tst-printf tst-printfsz-islongdouble
 
diff --git a/stdio-common/Versions b/stdio-common/Versions
index 5016f69..b821757 100644
--- a/stdio-common/Versions
+++ b/stdio-common/Versions
@@ -57,6 +57,9 @@ libc {
     psiginfo;
     register_printf_modifier; register_printf_type; register_printf_specifier;
   }
+  GLIBC_2.28 {
+    renameat2;
+  }
   GLIBC_PRIVATE {
     # global variables
     _itoa_lower_digits;
diff --git a/stdio-common/renameat.c b/stdio-common/renameat.c
index 2180b87..98c8f1d 100644
--- a/stdio-common/renameat.c
+++ b/stdio-common/renameat.c
@@ -22,7 +22,7 @@
 
 /* Rename the file OLD relative to OLDFD to NEW relative to NEWFD.  */
 int
-renameat (int oldfd, const char *old, int newfd, const char *new)
+__renameat (int oldfd, const char *old, int newfd, const char *new)
 {
   if ((oldfd < 0 && oldfd != AT_FDCWD) || (newfd < 0 && newfd != AT_FDCWD))
     {
@@ -40,5 +40,6 @@ renameat (int oldfd, const char *old, int newfd, const char *new)
   return -1;
 }
 
-
+libc_hidden_def (__renameat)
+weak_alias (__renameat, renameat)
 stub_warning (renameat)
diff --git a/stdio-common/renameat2.c b/stdio-common/renameat2.c
new file mode 100644
index 0000000..c2cedcd
--- /dev/null
+++ b/stdio-common/renameat2.c
@@ -0,0 +1,30 @@
+/* Generic implementation of the renameat function.
+   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 <stdio.h>
+
+int
+renameat2 (int oldfd, const char *old, int newfd, const char *new,
+           unsigned int flags)
+{
+  if (flags == 0)
+    return __renameat (oldfd, old, newfd, new);
+  __set_errno (EINVAL);
+  return -1;
+}
diff --git a/stdio-common/tst-renameat2.c b/stdio-common/tst-renameat2.c
new file mode 100644
index 0000000..958b091
--- /dev/null
+++ b/stdio-common/tst-renameat2.c
@@ -0,0 +1,204 @@
+/* Linux implementation for renameat2 function.
+   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 <array_length.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <support/check.h>
+#include <support/support.h>
+#include <support/temp_file.h>
+#include <support/xunistd.h>
+#include <unistd.h>
+
+/* Directory with the temporary files.  */
+static char *directory;
+static int directory_fd;
+
+/* Paths within that directory.  */
+static char *old_path;          /* File is called "old".  */
+static char *new_path;          /* File is called "new".  */
+
+/* Subdirectory within the directory above.  */
+static char *subdirectory;
+int subdirectory_fd;
+
+/* And a pathname in that directory (called "file").  */
+static char *subdir_path;
+
+static void
+prepare (int argc, char **argv)
+{
+  directory = support_create_temp_directory ("tst-renameat2-");
+  directory_fd = xopen (directory, O_RDONLY | O_DIRECTORY, 0);
+  old_path = xasprintf ("%s/old", directory);
+  add_temp_file (old_path);
+  new_path = xasprintf ("%s/new", directory);
+  add_temp_file (new_path);
+  subdirectory = xasprintf ("%s/subdir", directory);
+  xmkdir (subdirectory, 0777);
+  add_temp_file (subdirectory);
+  subdirectory_fd = xopen (subdirectory, O_RDONLY | O_DIRECTORY, 0);
+  subdir_path = xasprintf ("%s/file", subdirectory);
+  add_temp_file (subdir_path);
+}
+
+/* Delete all files, preparing a clean slate for the next test.  */
+static void
+delete_all_files (void)
+{
+  char *files[] = { old_path, new_path, subdir_path };
+  for (size_t i = 0; i < array_length (files); ++i)
+    if (unlink (files[i]) != 0 && errno != ENOENT)
+      FAIL_EXIT1 ("unlink (\"%s\"): %m", files[i]);
+}
+
+/* Return true if PATH exists in the file system.  */
+static bool
+file_exists (const char *path)
+{
+  return access (path, F_OK) == 0;
+}
+
+/* Check that PATH exists and has size EXPECTED_SIZE.  */
+static void
+check_size (const char *path, off64_t expected_size)
+{
+  struct stat64 st;
+  xstat (path, &st);
+  if (st.st_size != expected_size)
+    FAIL_EXIT1 ("file \"%s\": expected size %lld, actual size %lld",
+                path, (unsigned long long int) expected_size,
+                (unsigned long long int) st.st_size);
+}
+
+/* Rename tests where the target does not exist.  */
+static void
+rename_without_existing_target (unsigned int flags)
+{
+  delete_all_files ();
+  support_write_file_string (old_path, "");
+  TEST_COMPARE (renameat2 (AT_FDCWD, old_path, AT_FDCWD, new_path, flags), 0);
+  TEST_VERIFY (!file_exists (old_path));
+  TEST_VERIFY (file_exists (new_path));
+
+  delete_all_files ();
+  support_write_file_string (old_path, "");
+  TEST_COMPARE (renameat2 (directory_fd, "old", AT_FDCWD, new_path, flags), 0);
+  TEST_VERIFY (!file_exists (old_path));
+  TEST_VERIFY (file_exists (new_path));
+
+  delete_all_files ();
+  support_write_file_string (old_path, "");
+  TEST_COMPARE (renameat2 (directory_fd, "old", subdirectory_fd, "file", 0),
+                0);
+  TEST_VERIFY (!file_exists (old_path));
+  TEST_VERIFY (file_exists (subdir_path));
+}
+
+static int
+do_test (void)
+{
+  /* Tests with zero flags argument.  These are expected to succeed
+     because this renameat2 variant can be implemented with
+     renameat.  */
+  rename_without_existing_target (0);
+
+  /* renameat2 without flags replaces an existing destination.  */
+  delete_all_files ();
+  support_write_file_string (old_path, "123");
+  support_write_file_string (new_path, "1234");
+  TEST_COMPARE (renameat2 (AT_FDCWD, old_path, AT_FDCWD, new_path, 0), 0);
+  TEST_VERIFY (!file_exists (old_path));
+  check_size (new_path, 3);
+
+  /* Now we need to check for kernel support of renameat2 with
+     flags.  */
+  delete_all_files ();
+  support_write_file_string (old_path, "");
+  if (renameat2 (AT_FDCWD, old_path, AT_FDCWD, new_path, RENAME_NOREPLACE)
+      != 0)
+    {
+      if (errno == EINVAL)
+        puts ("warning: no support for renameat2 with flags");
+      else
+        FAIL_EXIT1 ("renameat2 probe failed: %m");
+    }
+  else
+    {
+      /* We have full renameat2 support.  */
+      rename_without_existing_target (RENAME_NOREPLACE);
+
+      /* Now test RENAME_NOREPLACE with an existing target.  */
+      delete_all_files ();
+      support_write_file_string (old_path, "123");
+      support_write_file_string (new_path, "1234");
+      TEST_COMPARE (renameat2 (AT_FDCWD, old_path, AT_FDCWD, new_path,
+                               RENAME_NOREPLACE), -1);
+      TEST_COMPARE (errno, EEXIST);
+      check_size (old_path, 3);
+      check_size (new_path, 4);
+
+      delete_all_files ();
+      support_write_file_string (old_path, "123");
+      support_write_file_string (new_path, "1234");
+      TEST_COMPARE (renameat2 (directory_fd, "old", AT_FDCWD, new_path,
+                               RENAME_NOREPLACE), -1);
+      TEST_COMPARE (errno, EEXIST);
+      check_size (old_path, 3);
+      check_size (new_path, 4);
+
+      delete_all_files ();
+      support_write_file_string (old_path, "123");
+      support_write_file_string (subdir_path, "1234");
+      TEST_COMPARE (renameat2 (directory_fd, "old", subdirectory_fd, "file",
+                               RENAME_NOREPLACE), -1);
+      TEST_COMPARE (errno, EEXIST);
+      check_size (old_path, 3);
+      check_size (subdir_path, 4);
+
+      /* The flag combination of RENAME_NOREPLACE and RENAME_EXCHANGE
+         is invalid.  */
+      TEST_COMPARE (renameat2 (directory_fd, "ignored",
+                               subdirectory_fd, "ignored",
+                               RENAME_NOREPLACE | RENAME_EXCHANGE), -1);
+      TEST_COMPARE (errno, EINVAL);
+    }
+
+  /* Create all the pathnames to avoid warnings from the test
+     harness.  */
+  support_write_file_string (old_path, "");
+  support_write_file_string (new_path, "");
+  support_write_file_string (subdir_path, "");
+
+  free (directory);
+  free (subdirectory);
+  free (old_path);
+  free (new_path);
+  free (subdir_path);
+
+  xclose (directory_fd);
+  xclose (subdirectory_fd);
+
+  return 0;
+}
+
+#define PREPARE prepare
+#include <support/test-driver.c>