Quelle  unshare_test.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0

#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <linux/kernel.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syscall.h>
#include <unistd.h>
#include <sys/resource.h>
#include <linux/close_range.h>

#include "../kselftest_harness.h"
#include "../clone3/clone3_selftests.h"

TEST(unshare_EMFILE)
{
 pid_t pid;
 int status;
 struct __clone_args args = {
  .flags = CLONE_FILES,
  .exit_signal = SIGCHLD,
 };
 int fd;
 ssize_t n, n2;
 static char buf[512], buf2[512];
 struct rlimit rlimit;
 int nr_open;

 fd = open("/proc/sys/fs/nr_open", O_RDWR);
 ASSERT_GE(fd, 0);

 n = read(fd, buf, sizeof(buf));
 ASSERT_GT(n, 0);
 ASSERT_EQ(buf[n - 1], '\n');

 ASSERT_EQ(sscanf(buf, "%d", &nr_open), 1);

 ASSERT_EQ(0, getrlimit(RLIMIT_NOFILE, &rlimit));

 /* bump fs.nr_open */
 n2 = sprintf(buf2, "%d\n", nr_open + 1024);
 lseek(fd, 0, SEEK_SET);
 write(fd, buf2, n2);

 /* bump ulimit -n */
 rlimit.rlim_cur = nr_open + 1024;
 rlimit.rlim_max = nr_open + 1024;
 EXPECT_EQ(0, setrlimit(RLIMIT_NOFILE, &rlimit)) {
  lseek(fd, 0, SEEK_SET);
  write(fd, buf, n);
  exit(EXIT_FAILURE);
 }

 /* get a descriptor past the old fs.nr_open */
 EXPECT_GE(dup2(2, nr_open + 64), 0) {
  lseek(fd, 0, SEEK_SET);
  write(fd, buf, n);
  exit(EXIT_FAILURE);
 }

 /* get descriptor table shared */
 pid = sys_clone3(&args, sizeof(args));
 EXPECT_GE(pid, 0) {
  lseek(fd, 0, SEEK_SET);
  write(fd, buf, n);
  exit(EXIT_FAILURE);
 }

 if (pid == 0) {
  int err;

  /* restore fs.nr_open */
  lseek(fd, 0, SEEK_SET);
  write(fd, buf, n);
  /* ... and now unshare(CLONE_FILES) must fail with EMFILE */
  err = unshare(CLONE_FILES);
  EXPECT_EQ(err, -1)
   exit(EXIT_FAILURE);
  EXPECT_EQ(errno, EMFILE)
   exit(EXIT_FAILURE);
  exit(EXIT_SUCCESS);
 }

 EXPECT_EQ(waitpid(pid, &status, 0), pid);
 EXPECT_EQ(true, WIFEXITED(status));
 EXPECT_EQ(0, WEXITSTATUS(status));
}

TEST_HARNESS_MAIN