tests/unistd_test.cpp

   1 /*
   2  * Copyright (C) 2012 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <gtest/gtest.h>
  18 #include "BionicDeathTest.h"
  19 #include "ScopedSignalHandler.h"
  20 #include "TemporaryFile.h"
  21
  22 #include <errno.h>
  23 #include <fcntl.h>
  24 #include <limits.h>
  25 #include <stdint.h>
  26 #include <sys/param.h>
  27 #include <sys/syscall.h>
  28 #include <sys/types.h>
  29 #include <sys/utsname.h>
  30 #include <sys/wait.h>
  31 #include <unistd.h>
  32
  33 static void* get_brk() {
  34   return sbrk(0);
  35 }
  36
  37 static void* page_align(uintptr_t addr) {
  38   uintptr_t mask = sysconf(_SC_PAGE_SIZE) - 1;
  39   return reinterpret_cast<void*>((addr + mask) & ~mask);
  40 }
  41
  42 TEST(unistd, brk) {
  43   void* initial_break = get_brk();
  44
  45   // The kernel aligns the break to a page.
  46   void* new_break = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(initial_break) + 1);
  47   ASSERT_EQ(0, brk(new_break));
  48   ASSERT_GE(get_brk(), new_break);
  49
  50   new_break = page_align(reinterpret_cast<uintptr_t>(initial_break) + sysconf(_SC_PAGE_SIZE));
  51   ASSERT_EQ(0, brk(new_break));
  52   ASSERT_EQ(get_brk(), new_break);
  53 }
  54
  55 TEST(unistd, brk_ENOMEM) {
  56   ASSERT_EQ(-1, brk(reinterpret_cast<void*>(-1)));
  57   ASSERT_EQ(ENOMEM, errno);
  58 }
  59
  60 #if defined(__GLIBC__)
  61 #define SBRK_MIN INTPTR_MIN
  62 #define SBRK_MAX INTPTR_MAX
  63 #else
  64 #define SBRK_MIN PTRDIFF_MIN
  65 #define SBRK_MAX PTRDIFF_MAX
  66 #endif
  67
  68 TEST(unistd, sbrk_ENOMEM) {
  69 #if defined(__BIONIC__) && !defined(__LP64__)
  70   // There is no way to guarantee that all overflow conditions can be tested
  71   // without manipulating the underlying values of the current break.
  72   extern void* __bionic_brk;
  73
  74   class ScopedBrk {
  75   public:
  76     ScopedBrk() : saved_brk_(__bionic_brk) {}
  77     virtual ~ScopedBrk() { __bionic_brk = saved_brk_; }
  78
  79   private:
  80     void* saved_brk_;
  81   };
  82
  83   ScopedBrk scope_brk;
  84
  85   // Set the current break to a point that will cause an overflow.
  86   __bionic_brk = reinterpret_cast<void*>(static_cast<uintptr_t>(PTRDIFF_MAX) + 2);
  87
  88   // Can't increase by so much that we'd overflow.
  89   ASSERT_EQ(reinterpret_cast<void*>(-1), sbrk(PTRDIFF_MAX));
  90   ASSERT_EQ(ENOMEM, errno);
  91
  92   // Set the current break to a point that will cause an overflow.
  93   __bionic_brk = reinterpret_cast<void*>(static_cast<uintptr_t>(PTRDIFF_MAX));
  94
  95   ASSERT_EQ(reinterpret_cast<void*>(-1), sbrk(PTRDIFF_MIN));
  96   ASSERT_EQ(ENOMEM, errno);
  97
  98   __bionic_brk = reinterpret_cast<void*>(static_cast<uintptr_t>(PTRDIFF_MAX) - 1);
  99
 100   ASSERT_EQ(reinterpret_cast<void*>(-1), sbrk(PTRDIFF_MIN + 1));
 101   ASSERT_EQ(ENOMEM, errno);
 102 #else
 103   class ScopedBrk {
 104   public:
 105     ScopedBrk() : saved_brk_(get_brk()) {}
 106     virtual ~ScopedBrk() { brk(saved_brk_); }
 107
 108   private:
 109     void* saved_brk_;
 110   };
 111
 112   ScopedBrk scope_brk;
 113
 114   uintptr_t cur_brk = reinterpret_cast<uintptr_t>(get_brk());
 115   if (cur_brk < static_cast<uintptr_t>(-(SBRK_MIN+1))) {
 116     // Do the overflow test for a max negative increment.
 117     ASSERT_EQ(reinterpret_cast<void*>(-1), sbrk(SBRK_MIN));
 118 #if defined(__BIONIC__)
 119     // GLIBC does not set errno in overflow case.
 120     ASSERT_EQ(ENOMEM, errno);
 121 #endif
 122   }
 123
 124   uintptr_t overflow_brk = static_cast<uintptr_t>(SBRK_MAX) + 2;
 125   if (cur_brk < overflow_brk) {
 126     // Try and move the value to PTRDIFF_MAX + 2.
 127     cur_brk = reinterpret_cast<uintptr_t>(sbrk(overflow_brk));
 128   }
 129   if (cur_brk >= overflow_brk) {
 130     ASSERT_EQ(reinterpret_cast<void*>(-1), sbrk(SBRK_MAX));
 131 #if defined(__BIONIC__)
 132     // GLIBC does not set errno in overflow case.
 133     ASSERT_EQ(ENOMEM, errno);
 134 #endif
 135   }
 136 #endif
 137 }
 138
 139 TEST(unistd, truncate) {
 140   TemporaryFile tf;
 141   ASSERT_EQ(0, close(tf.fd));
 142   ASSERT_EQ(0, truncate(tf.filename, 123));
 143
 144   struct stat sb;
 145   ASSERT_EQ(0, stat(tf.filename, &sb));
 146   ASSERT_EQ(123, sb.st_size);
 147 }
 148
 149 TEST(unistd, truncate64) {
 150   TemporaryFile tf;
 151   ASSERT_EQ(0, close(tf.fd));
 152   ASSERT_EQ(0, truncate64(tf.filename, 123));
 153
 154   struct stat sb;
 155   ASSERT_EQ(0, stat(tf.filename, &sb));
 156   ASSERT_EQ(123, sb.st_size);
 157 }
 158
 159 TEST(unistd, ftruncate) {
 160   TemporaryFile tf;
 161   ASSERT_EQ(0, ftruncate(tf.fd, 123));
 162   ASSERT_EQ(0, close(tf.fd));
 163
 164   struct stat sb;
 165   ASSERT_EQ(0, stat(tf.filename, &sb));
 166   ASSERT_EQ(123, sb.st_size);
 167 }
 168
 169 TEST(unistd, ftruncate64) {
 170   TemporaryFile tf;
 171   ASSERT_EQ(0, ftruncate64(tf.fd, 123));
 172   ASSERT_EQ(0, close(tf.fd));
 173
 174   struct stat sb;
 175   ASSERT_EQ(0, stat(tf.filename, &sb));
 176   ASSERT_EQ(123, sb.st_size);
 177 }
 178
 179 TEST(unistd, ftruncate_negative) {
 180   TemporaryFile tf;
 181   errno = 0;
 182   ASSERT_EQ(-1, ftruncate(tf.fd, -123));
 183   ASSERT_EQ(EINVAL, errno);
 184 }
 185
 186 static bool g_pause_test_flag = false;
 187 static void PauseTestSignalHandler(int) {
 188   g_pause_test_flag = true;
 189 }
 190
 191 TEST(unistd, pause) {
 192   ScopedSignalHandler handler(SIGALRM, PauseTestSignalHandler);
 193
 194   alarm(1);
 195   ASSERT_FALSE(g_pause_test_flag);
 196   ASSERT_EQ(-1, pause());
 197   ASSERT_TRUE(g_pause_test_flag);
 198 }
 199
 200 TEST(unistd, read) {
 201   int fd = open("/proc/version", O_RDONLY);
 202   ASSERT_TRUE(fd != -1);
 203
 204   char buf[5];
 205   ASSERT_EQ(5, read(fd, buf, 5));
 206   ASSERT_EQ(buf[0], 'L');
 207   ASSERT_EQ(buf[1], 'i');
 208   ASSERT_EQ(buf[2], 'n');
 209   ASSERT_EQ(buf[3], 'u');
 210   ASSERT_EQ(buf[4], 'x');
 211   close(fd);
 212 }
 213
 214 TEST(unistd, read_EBADF) {
 215   // read returns ssize_t which is 64-bits on LP64, so it's worth explicitly checking that
 216   // our syscall stubs correctly return a 64-bit -1.
 217   char buf[1];
 218   ASSERT_EQ(-1, read(-1, buf, sizeof(buf)));
 219   ASSERT_EQ(EBADF, errno);
 220 }
 221
 222 TEST(unistd, syscall_long) {
 223   // Check that syscall(3) correctly returns long results.
 224   // https://code.google.com/p/android/issues/detail?id=73952
 225   // We assume that the break is > 4GiB, but this is potentially flaky.
 226   uintptr_t p = reinterpret_cast<uintptr_t>(sbrk(0));
 227   ASSERT_EQ(p, static_cast<uintptr_t>(syscall(__NR_brk, 0)));
 228 }
 229
 230 TEST(unistd, alarm) {
 231   ASSERT_EQ(0U, alarm(0));
 232 }
 233
 234 TEST(unistd, _exit) {
 235   int pid = fork();
 236   ASSERT_NE(-1, pid) << strerror(errno);
 237
 238   if (pid == 0) {
 239     _exit(99);
 240   }
 241
 242   int status;
 243   ASSERT_EQ(pid, waitpid(pid, &status, 0));
 244   ASSERT_TRUE(WIFEXITED(status));
 245   ASSERT_EQ(99, WEXITSTATUS(status));
 246 }
 247
 248 TEST(unistd, getenv_unsetenv) {
 249   ASSERT_EQ(0, setenv("test-variable", "hello", 1));
 250   ASSERT_STREQ("hello", getenv("test-variable"));
 251   ASSERT_EQ(0, unsetenv("test-variable"));
 252   ASSERT_TRUE(getenv("test-variable") == NULL);
 253 }
 254
 255 TEST(unistd, unsetenv_EINVAL) {
 256   EXPECT_EQ(-1, unsetenv(""));
 257   EXPECT_EQ(EINVAL, errno);
 258   EXPECT_EQ(-1, unsetenv("a=b"));
 259   EXPECT_EQ(EINVAL, errno);
 260 }
 261
 262 TEST(unistd, setenv_EINVAL) {
 263   EXPECT_EQ(-1, setenv(NULL, "value", 0));
 264   EXPECT_EQ(EINVAL, errno);
 265   EXPECT_EQ(-1, setenv(NULL, "value", 1));
 266   EXPECT_EQ(EINVAL, errno);
 267   EXPECT_EQ(-1, setenv("", "value", 0));
 268   EXPECT_EQ(EINVAL, errno);
 269   EXPECT_EQ(-1, setenv("", "value", 1));
 270   EXPECT_EQ(EINVAL, errno);
 271   EXPECT_EQ(-1, setenv("a=b", "value", 0));
 272   EXPECT_EQ(EINVAL, errno);
 273   EXPECT_EQ(-1, setenv("a=b", "value", 1));
 274   EXPECT_EQ(EINVAL, errno);
 275 }
 276
 277 TEST(unistd, setenv) {
 278   ASSERT_EQ(0, unsetenv("test-variable"));
 279
 280   char a[] = "a";
 281   char b[] = "b";
 282   char c[] = "c";
 283
 284   // New value.
 285   EXPECT_EQ(0, setenv("test-variable", a, 0));
 286   EXPECT_STREQ(a, getenv("test-variable"));
 287
 288   // Existing value, no overwrite.
 289   EXPECT_EQ(0, setenv("test-variable", b, 0));
 290   EXPECT_STREQ(a, getenv("test-variable"));
 291
 292   // Existing value, overwrite.
 293   EXPECT_EQ(0, setenv("test-variable", c, 1));
 294   EXPECT_STREQ(c, getenv("test-variable"));
 295   // But the arrays backing the values are unchanged.
 296   EXPECT_EQ('a', a[0]);
 297   EXPECT_EQ('b', b[0]);
 298   EXPECT_EQ('c', c[0]);
 299
 300   ASSERT_EQ(0, unsetenv("test-variable"));
 301 }
 302
 303 TEST(unistd, putenv) {
 304   ASSERT_EQ(0, unsetenv("a"));
 305
 306   char* s1 = strdup("a=b");
 307   ASSERT_EQ(0, putenv(s1));
 308
 309   ASSERT_STREQ("b", getenv("a"));
 310   s1[2] = 'c';
 311   ASSERT_STREQ("c", getenv("a"));
 312
 313   char* s2 = strdup("a=b");
 314   ASSERT_EQ(0, putenv(s2));
 315
 316   ASSERT_STREQ("b", getenv("a"));
 317   ASSERT_EQ('c', s1[2]);
 318
 319   ASSERT_EQ(0, unsetenv("a"));
 320   free(s1);
 321   free(s2);
 322 }
 323
 324 TEST(unistd, clearenv) {
 325   extern char** environ;
 326
 327   // Guarantee that environ is not initially empty...
 328   ASSERT_EQ(0, setenv("test-variable", "a", 1));
 329
 330   // Stash a copy.
 331   std::vector<char*> old_environ;
 332   for (size_t i = 0; environ[i] != NULL; ++i) {
 333     old_environ.push_back(strdup(environ[i]));
 334   }
 335
 336   ASSERT_EQ(0, clearenv());
 337
 338   EXPECT_TRUE(environ == NULL || environ[0] == NULL);
 339   EXPECT_EQ(NULL, getenv("test-variable"));
 340   EXPECT_EQ(0, setenv("test-variable", "post-clear", 1));
 341   EXPECT_STREQ("post-clear", getenv("test-variable"));
 342
 343   // Put the old environment back.
 344   for (size_t i = 0; i < old_environ.size(); ++i) {
 345     EXPECT_EQ(0, putenv(old_environ[i]));
 346   }
 347
 348   // Check it wasn't overwritten.
 349   EXPECT_STREQ("a", getenv("test-variable"));
 350
 351   EXPECT_EQ(0, unsetenv("test-variable"));
 352 }
 353
 354 static void TestFsyncFunction(int (*fn)(int)) {
 355   int fd;
 356
 357   // Can't sync an invalid fd.
 358   errno = 0;
 359   EXPECT_EQ(-1, fn(-1));
 360   EXPECT_EQ(EBADF, errno);
 361
 362   // It doesn't matter whether you've opened a file for write or not.
 363   TemporaryFile tf;
 364   ASSERT_NE(-1, tf.fd);
 365
 366   EXPECT_EQ(0, fn(tf.fd));
 367
 368   ASSERT_NE(-1, fd = open(tf.filename, O_RDONLY));
 369   EXPECT_EQ(0, fn(fd));
 370   close(fd);
 371
 372   ASSERT_NE(-1, fd = open(tf.filename, O_RDWR));
 373   EXPECT_EQ(0, fn(fd));
 374   close(fd);
 375
 376   // The fd can even be a directory.
 377   ASSERT_NE(-1, fd = open("/", O_RDONLY));
 378   EXPECT_EQ(0, fn(fd));
 379   close(fd);
 380
 381   // But some file systems may choose to be fussy...
 382   errno = 0;
 383   ASSERT_NE(-1, fd = open("/proc/version", O_RDONLY));
 384   EXPECT_EQ(-1, fn(fd));
 385   EXPECT_EQ(EINVAL, errno);
 386   close(fd);
 387 }
 388
 389 TEST(unistd, fdatasync) {
 390   TestFsyncFunction(fdatasync);
 391 }
 392
 393 TEST(unistd, fsync) {
 394   TestFsyncFunction(fsync);
 395 }
 396
 397 static void AssertGetPidCorrect() {
 398   // The loop is just to make manual testing/debugging with strace easier.
 399   pid_t getpid_syscall_result = syscall(__NR_getpid);
 400   for (size_t i = 0; i < 128; ++i) {
 401     ASSERT_EQ(getpid_syscall_result, getpid());
 402   }
 403 }
 404
 405 static void TestGetPidCachingWithFork(int (*fork_fn)()) {
 406   pid_t parent_pid = getpid();
 407   ASSERT_EQ(syscall(__NR_getpid), parent_pid);
 408
 409   pid_t fork_result = fork_fn();
 410   ASSERT_NE(fork_result, -1);
 411   if (fork_result == 0) {
 412     // We're the child.
 413     AssertGetPidCorrect();
 414     ASSERT_EQ(parent_pid, getppid());
 415     _exit(123);
 416   } else {
 417     // We're the parent.
 418     ASSERT_EQ(parent_pid, getpid());
 419
 420     int status;
 421     ASSERT_EQ(fork_result, waitpid(fork_result, &status, 0));
 422     ASSERT_TRUE(WIFEXITED(status));
 423     ASSERT_EQ(123, WEXITSTATUS(status));
 424   }
 425 }
 426
 427 TEST(unistd, getpid_caching_and_fork) {
 428   TestGetPidCachingWithFork(fork);
 429 }
 430
 431 TEST(unistd, getpid_caching_and_vfork) {
 432   TestGetPidCachingWithFork(vfork);
 433 }
 434
 435 static int GetPidCachingCloneStartRoutine(void*) {
 436   AssertGetPidCorrect();
 437   return 123;
 438 }
 439
 440 TEST(unistd, getpid_caching_and_clone) {
 441   pid_t parent_pid = getpid();
 442   ASSERT_EQ(syscall(__NR_getpid), parent_pid);
 443
 444   void* child_stack[1024];
 445   int clone_result = clone(GetPidCachingCloneStartRoutine, &child_stack[1024], CLONE_NEWNS | SIGCHLD, NULL);
 446   if (clone_result == -1 && errno == EPERM && getuid() != 0) {
 447     GTEST_LOG_(INFO) << "This test only works if you have permission to CLONE_NEWNS; try running as root.\n";
 448     return;
 449   }
 450   ASSERT_NE(clone_result, -1);
 451
 452   ASSERT_EQ(parent_pid, getpid());
 453
 454   int status;
 455   ASSERT_EQ(clone_result, waitpid(clone_result, &status, 0));
 456   ASSERT_TRUE(WIFEXITED(status));
 457   ASSERT_EQ(123, WEXITSTATUS(status));
 458 }
 459
 460 static void* GetPidCachingPthreadStartRoutine(void*) {
 461   AssertGetPidCorrect();
 462   return NULL;
 463 }
 464
 465 TEST(unistd, getpid_caching_and_pthread_create) {
 466   pid_t parent_pid = getpid();
 467
 468   pthread_t t;
 469   ASSERT_EQ(0, pthread_create(&t, NULL, GetPidCachingPthreadStartRoutine, NULL));
 470
 471   ASSERT_EQ(parent_pid, getpid());
 472
 473   void* result;
 474   ASSERT_EQ(0, pthread_join(t, &result));
 475   ASSERT_EQ(NULL, result);
 476 }
 477
 478 class unistd_DeathTest : public BionicDeathTest {};
 479
 480 TEST_F(unistd_DeathTest, abort) {
 481   ASSERT_EXIT(abort(), testing::KilledBySignal(SIGABRT), "");
 482 }
 483
 484 TEST(unistd, sethostname) {
 485   // The permissions check happens before the argument check, so this will
 486   // fail for a different reason if you're running as root than if you're
 487   // not, but it'll fail either way. Checking that we have the symbol is about
 488   // all we can do for sethostname(2).
 489   ASSERT_EQ(-1, sethostname("", -1));
 490 }
 491
 492 TEST(unistd, gethostname) {
 493   char hostname[HOST_NAME_MAX + 1];
 494   memset(hostname, 0, sizeof(hostname));
 495
 496   // Can we get the hostname with a big buffer?
 497   ASSERT_EQ(0, gethostname(hostname, HOST_NAME_MAX));
 498
 499   // Can we get the hostname with a right-sized buffer?
 500   errno = 0;
 501   ASSERT_EQ(0, gethostname(hostname, strlen(hostname) + 1));
 502
 503   // Does uname(2) agree?
 504   utsname buf;
 505   ASSERT_EQ(0, uname(&buf));
 506   ASSERT_EQ(0, strncmp(hostname, buf.nodename, SYS_NMLN));
 507   ASSERT_GT(strlen(hostname), 0U);
 508
 509   // Do we correctly detect truncation?
 510   errno = 0;
 511   ASSERT_EQ(-1, gethostname(hostname, strlen(hostname)));
 512   ASSERT_EQ(ENAMETOOLONG, errno);
 513 }
 514
 515 TEST(unistd, pathconf_fpathconf) {
 516   TemporaryFile tf;
 517   long rc = 0L;
 518   // As a file system's block size is always power of 2, the configure values
 519   // for ALLOC and XFER should be power of 2 as well.
 520   rc = pathconf(tf.filename, _PC_ALLOC_SIZE_MIN);
 521   ASSERT_TRUE(rc > 0 && powerof2(rc));
 522   rc = pathconf(tf.filename, _PC_REC_MIN_XFER_SIZE);
 523   ASSERT_TRUE(rc > 0 && powerof2(rc));
 524   rc = pathconf(tf.filename, _PC_REC_XFER_ALIGN);
 525   ASSERT_TRUE(rc > 0 && powerof2(rc));
 526
 527   rc = fpathconf(tf.fd, _PC_ALLOC_SIZE_MIN);
 528   ASSERT_TRUE(rc > 0 && powerof2(rc));
 529   rc = fpathconf(tf.fd, _PC_REC_MIN_XFER_SIZE);
 530   ASSERT_TRUE(rc > 0 && powerof2(rc));
 531   rc = fpathconf(tf.fd, _PC_REC_XFER_ALIGN);
 532   ASSERT_TRUE(rc > 0 && powerof2(rc));
 533 }
 534
 535
 536 TEST(unistd, _POSIX_macros_smoke) {
 537   // Make a tight verification of _POSIX_* / _POSIX2_* / _XOPEN_* macros, to prevent change by mistake.
 538   // Verify according to POSIX.1-2008.
 539   EXPECT_EQ(200809L, _POSIX_VERSION);
 540
 541   EXPECT_EQ(_POSIX_VERSION, _POSIX_ADVISORY_INFO);
 542   EXPECT_GT(_POSIX_AIO_LISTIO_MAX, 0);
 543   EXPECT_GT(_POSIX_AIO_MAX, 0);
 544   EXPECT_GT(_POSIX_ARG_MAX, 0);
 545   EXPECT_GT(_POSIX_CHILD_MAX, 0);
 546   EXPECT_NE(_POSIX_CHOWN_RESTRICTED, -1);
 547   EXPECT_EQ(_POSIX_VERSION, _POSIX_CLOCK_SELECTION);
 548   EXPECT_EQ(0, _POSIX_CPUTIME);             // Use sysconf to detect support at runtime.
 549   EXPECT_GT(_POSIX_DELAYTIMER_MAX, 0);
 550   EXPECT_EQ(_POSIX_VERSION, _POSIX_FSYNC);
 551   EXPECT_GT(_POSIX_HOST_NAME_MAX, 0);
 552   EXPECT_EQ(_POSIX_VERSION, _POSIX_IPV6);
 553   EXPECT_GT(_POSIX_JOB_CONTROL, 0);
 554   EXPECT_GT(_POSIX_LINK_MAX, 0);
 555   EXPECT_GT(_POSIX_LOGIN_NAME_MAX, 0);
 556   EXPECT_EQ(_POSIX_VERSION, _POSIX_MAPPED_FILES);
 557   EXPECT_GT(_POSIX_MAX_CANON, 0);
 558   EXPECT_GT(_POSIX_MAX_INPUT, 0);
 559   EXPECT_EQ(_POSIX_VERSION, _POSIX_MEMLOCK);
 560   EXPECT_EQ(_POSIX_VERSION, _POSIX_MEMLOCK_RANGE);
 561   EXPECT_EQ(_POSIX_VERSION, _POSIX_MEMORY_PROTECTION);
 562   EXPECT_EQ(0, _POSIX_MONOTONIC_CLOCK);
 563   EXPECT_GT(_POSIX_MQ_OPEN_MAX, 0);
 564   EXPECT_GT(_POSIX_MQ_PRIO_MAX, 0);
 565   EXPECT_GT(_POSIX_NAME_MAX, 0);
 566   EXPECT_GT(_POSIX_NGROUPS_MAX, 0);
 567   EXPECT_GT(_POSIX_NO_TRUNC, 0);
 568   EXPECT_GT(_POSIX_OPEN_MAX, 0);
 569   EXPECT_GT(_POSIX_PATH_MAX, 0);
 570   EXPECT_GT(_POSIX_PIPE_BUF, 0);
 571   EXPECT_EQ(_POSIX_VERSION, _POSIX_PRIORITY_SCHEDULING);
 572   EXPECT_EQ(_POSIX_VERSION, _POSIX_RAW_SOCKETS);
 573   EXPECT_EQ(_POSIX_VERSION, _POSIX_READER_WRITER_LOCKS);
 574   EXPECT_EQ(_POSIX_VERSION, _POSIX_REALTIME_SIGNALS);
 575   EXPECT_GT(_POSIX_REGEXP, 0);
 576   EXPECT_GT(_POSIX_RE_DUP_MAX, 0);
 577   EXPECT_GT(_POSIX_SAVED_IDS, 0);
 578   EXPECT_EQ(_POSIX_VERSION, _POSIX_SEMAPHORES);
 579   EXPECT_GT(_POSIX_SEM_NSEMS_MAX, 0);
 580   EXPECT_GT(_POSIX_SEM_VALUE_MAX, 0);
 581   EXPECT_GT(_POSIX_SHELL, 0);
 582   EXPECT_GT(_POSIX_SIGQUEUE_MAX, 0);
 583   EXPECT_EQ(-1, _POSIX_SPORADIC_SERVER);
 584   EXPECT_GT(_POSIX_SSIZE_MAX, 0);
 585   EXPECT_GT(_POSIX_STREAM_MAX, 0);
 586   EXPECT_GT(_POSIX_SYMLINK_MAX, 0);
 587   EXPECT_GT(_POSIX_SYMLOOP_MAX, 0);
 588   EXPECT_EQ(_POSIX_VERSION, _POSIX_SYNCHRONIZED_IO);
 589   EXPECT_EQ(_POSIX_VERSION, _POSIX_THREADS);
 590   EXPECT_EQ(_POSIX_VERSION, _POSIX_THREAD_ATTR_STACKADDR);
 591   EXPECT_EQ(_POSIX_VERSION, _POSIX_THREAD_ATTR_STACKSIZE);
 592   EXPECT_EQ(0, _POSIX_THREAD_CPUTIME);       // Use sysconf to detect support at runtime.
 593   EXPECT_GT(_POSIX_THREAD_DESTRUCTOR_ITERATIONS, 0);
 594   EXPECT_EQ(_POSIX_THREAD_KEYS_MAX, 128);
 595   EXPECT_EQ(_POSIX_VERSION, _POSIX_THREAD_PRIORITY_SCHEDULING);
 596   EXPECT_EQ(_POSIX_VERSION, _POSIX_THREAD_PRIO_INHERIT);
 597   EXPECT_EQ(_POSIX_VERSION, _POSIX_THREAD_PRIO_PROTECT);
 598   EXPECT_EQ(-1, _POSIX_THREAD_ROBUST_PRIO_PROTECT);
 599   EXPECT_EQ(_POSIX_VERSION, _POSIX_THREAD_SAFE_FUNCTIONS);
 600   EXPECT_EQ(-1, _POSIX_THREAD_SPORADIC_SERVER);
 601   EXPECT_GT(_POSIX_THREAD_THREADS_MAX, 0);
 602   EXPECT_EQ(_POSIX_VERSION, _POSIX_TIMEOUTS);
 603   EXPECT_EQ(_POSIX_VERSION, _POSIX_TIMERS);
 604   EXPECT_GT(_POSIX_TIMER_MAX, 0);
 605   EXPECT_EQ(-1, _POSIX_TRACE);
 606   EXPECT_EQ(-1, _POSIX_TRACE_EVENT_FILTER);
 607   EXPECT_EQ(-1, _POSIX_TRACE_INHERIT);
 608   EXPECT_EQ(-1, _POSIX_TRACE_LOG);
 609   EXPECT_GT(_POSIX_TTY_NAME_MAX, 0);
 610   EXPECT_EQ(-1, _POSIX_TYPED_MEMORY_OBJECTS);
 611   EXPECT_GT(_POSIX_TZNAME_MAX, 0);
 612   EXPECT_NE(-1, _POSIX_VDISABLE);
 613
 614   EXPECT_GT(_POSIX2_BC_BASE_MAX, 0);
 615   EXPECT_GT(_POSIX2_BC_DIM_MAX, 0);
 616   EXPECT_GT(_POSIX2_BC_SCALE_MAX, 0);
 617   EXPECT_GT(_POSIX2_BC_STRING_MAX, 0);
 618   EXPECT_GT(_POSIX2_CHARCLASS_NAME_MAX, 0);
 619   EXPECT_GT(_POSIX2_COLL_WEIGHTS_MAX, 0);
 620   EXPECT_EQ(_POSIX_VERSION, _POSIX2_C_BIND);
 621   EXPECT_GT(_POSIX2_EXPR_NEST_MAX, 0);
 622   EXPECT_GT(_POSIX2_LINE_MAX, 0);
 623   EXPECT_GT(_POSIX2_RE_DUP_MAX, 0);
 624
 625   EXPECT_EQ(700, _XOPEN_VERSION);
 626   EXPECT_GT(_XOPEN_IOV_MAX, 0);
 627   EXPECT_GT(_XOPEN_UNIX, 0);
 628
 629 #if defined(__BIONIC__)
 630   // These tests only pass on bionic, as bionic and glibc has different support on these macros.
 631   // Macros like _POSIX_ASYNCHRONOUS_IO are not supported on bionic yet.
 632   EXPECT_EQ(-1, _POSIX_ASYNCHRONOUS_IO);
 633   EXPECT_EQ(-1, _POSIX_BARRIERS);
 634   EXPECT_EQ(-1, _POSIX_MESSAGE_PASSING);
 635   EXPECT_EQ(-1, _POSIX_PRIORITIZED_IO);
 636   EXPECT_EQ(-1, _POSIX_SHARED_MEMORY_OBJECTS);
 637   EXPECT_EQ(-1, _POSIX_SPAWN);
 638   EXPECT_EQ(-1, _POSIX_SPIN_LOCKS);
 639   EXPECT_EQ(-1, _POSIX_THREAD_PROCESS_SHARED);
 640   EXPECT_EQ(-1, _POSIX_THREAD_ROBUST_PRIO_INHERIT);
 641
 642   EXPECT_EQ(-1, _POSIX2_VERSION);
 643   EXPECT_EQ(-1, _POSIX2_CHAR_TERM);
 644   EXPECT_EQ(-1, _POSIX2_C_DEV);
 645   EXPECT_EQ(-1, _POSIX2_LOCALEDEF);
 646   EXPECT_EQ(-1, _POSIX2_SW_DEV);
 647   EXPECT_EQ(-1, _POSIX2_UPE);
 648
 649   EXPECT_EQ(-1, _XOPEN_ENH_I18N);
 650   EXPECT_EQ(-1, _XOPEN_CRYPT);
 651   EXPECT_EQ(-1, _XOPEN_LEGACY);
 652   EXPECT_EQ(-1, _XOPEN_REALTIME);
 653   EXPECT_EQ(-1, _XOPEN_REALTIME_THREADS);
 654   EXPECT_EQ(-1, _XOPEN_SHM);
 655
 656 #endif // defined(__BIONIC__)
 657 }
 658
 659 #define VERIFY_SYSCONF_NOT_SUPPORT(name) VerifySysconf(name, #name, [](long v){return v == -1;})
 660
 661 // sysconf() means unlimited when it returns -1 with errno unchanged.
 662 #define VERIFY_SYSCONF_POSITIVE(name) \
 663   VerifySysconf(name, #name, [](long v){return (v > 0 || v == -1);})
 664
 665 #define VERIFY_SYSCONF_POSIX_VERSION(name) \
 666   VerifySysconf(name, #name, [](long v){return v == _POSIX_VERSION;})
 667
 668 static void VerifySysconf(int option, const char *option_name, bool (*verify)(long)) {
 669   errno = 0;
 670   long ret = sysconf(option);
 671   EXPECT_TRUE(0 == errno && verify(ret)) << "name = " << option_name << ", ret = "
 672       << ret <<", Error Message: " << strerror(errno);
 673 }
 674
 675 TEST(unistd, sysconf) {
 676   VERIFY_SYSCONF_POSIX_VERSION(_SC_ADVISORY_INFO);
 677   VERIFY_SYSCONF_POSITIVE(_SC_ARG_MAX);
 678   VERIFY_SYSCONF_POSITIVE(_SC_BC_BASE_MAX);
 679   VERIFY_SYSCONF_POSITIVE(_SC_BC_DIM_MAX);
 680   VERIFY_SYSCONF_POSITIVE(_SC_BC_SCALE_MAX);
 681   VERIFY_SYSCONF_POSITIVE(_SC_CHILD_MAX);
 682   VERIFY_SYSCONF_POSITIVE(_SC_CLK_TCK);
 683   VERIFY_SYSCONF_POSITIVE(_SC_COLL_WEIGHTS_MAX);
 684   VERIFY_SYSCONF_POSIX_VERSION(_SC_CPUTIME);
 685   VERIFY_SYSCONF_POSITIVE(_SC_EXPR_NEST_MAX);
 686   VERIFY_SYSCONF_POSITIVE(_SC_LINE_MAX);
 687   VERIFY_SYSCONF_POSITIVE(_SC_NGROUPS_MAX);
 688   VERIFY_SYSCONF_POSITIVE(_SC_OPEN_MAX);
 689   VERIFY_SYSCONF_POSITIVE(_SC_PASS_MAX);
 690   VERIFY_SYSCONF_POSIX_VERSION(_SC_2_C_BIND);
 691   VERIFY_SYSCONF_NOT_SUPPORT(_SC_2_FORT_DEV);
 692   VERIFY_SYSCONF_NOT_SUPPORT(_SC_2_FORT_RUN);
 693   VERIFY_SYSCONF_NOT_SUPPORT(_SC_2_UPE);
 694   VERIFY_SYSCONF_POSITIVE(_SC_JOB_CONTROL);
 695   VERIFY_SYSCONF_POSITIVE(_SC_SAVED_IDS);
 696   VERIFY_SYSCONF_POSIX_VERSION(_SC_VERSION);
 697   VERIFY_SYSCONF_POSITIVE(_SC_RE_DUP_MAX);
 698   VERIFY_SYSCONF_POSITIVE(_SC_STREAM_MAX);
 699   VERIFY_SYSCONF_POSITIVE(_SC_TZNAME_MAX);
 700   VerifySysconf(_SC_XOPEN_VERSION, "_SC_XOPEN_VERSION", [](long v){return v == _XOPEN_VERSION;});
 701   VERIFY_SYSCONF_POSITIVE(_SC_ATEXIT_MAX);
 702   VERIFY_SYSCONF_POSITIVE(_SC_IOV_MAX);
 703   VERIFY_SYSCONF_POSITIVE(_SC_PAGESIZE);
 704   VERIFY_SYSCONF_POSITIVE(_SC_PAGE_SIZE);
 705   VerifySysconf(_SC_PAGE_SIZE, "_SC_PAGE_SIZE",
 706                 [](long v){return v == sysconf(_SC_PAGESIZE) && v == getpagesize();});
 707   VERIFY_SYSCONF_POSITIVE(_SC_XOPEN_UNIX);
 708   VERIFY_SYSCONF_POSITIVE(_SC_AIO_LISTIO_MAX);
 709   VERIFY_SYSCONF_POSITIVE(_SC_AIO_MAX);
 710   VerifySysconf(_SC_AIO_PRIO_DELTA_MAX, "_SC_AIO_PRIO_DELTA_MAX", [](long v){return v >= 0;});
 711   VERIFY_SYSCONF_POSITIVE(_SC_DELAYTIMER_MAX);
 712   VERIFY_SYSCONF_POSITIVE(_SC_MQ_OPEN_MAX);
 713   VERIFY_SYSCONF_POSITIVE(_SC_MQ_PRIO_MAX);
 714   VERIFY_SYSCONF_POSITIVE(_SC_RTSIG_MAX);
 715   VERIFY_SYSCONF_POSITIVE(_SC_SEM_NSEMS_MAX);
 716   VERIFY_SYSCONF_POSITIVE(_SC_SEM_VALUE_MAX);
 717   VERIFY_SYSCONF_POSITIVE(_SC_TIMER_MAX);
 718   VERIFY_SYSCONF_POSIX_VERSION(_SC_FSYNC);
 719   VERIFY_SYSCONF_POSIX_VERSION(_SC_MAPPED_FILES);
 720   VERIFY_SYSCONF_POSIX_VERSION(_SC_MEMLOCK);
 721   VERIFY_SYSCONF_POSIX_VERSION(_SC_MEMLOCK_RANGE);
 722   VERIFY_SYSCONF_POSIX_VERSION(_SC_MEMORY_PROTECTION);
 723   VERIFY_SYSCONF_POSIX_VERSION(_SC_PRIORITY_SCHEDULING);
 724   VERIFY_SYSCONF_POSIX_VERSION(_SC_REALTIME_SIGNALS);
 725   VERIFY_SYSCONF_POSIX_VERSION(_SC_SEMAPHORES);
 726   VERIFY_SYSCONF_POSIX_VERSION(_SC_SYNCHRONIZED_IO);
 727   VERIFY_SYSCONF_POSIX_VERSION(_SC_TIMERS);
 728   VERIFY_SYSCONF_POSITIVE(_SC_GETGR_R_SIZE_MAX);
 729   VERIFY_SYSCONF_POSITIVE(_SC_GETPW_R_SIZE_MAX);
 730   VERIFY_SYSCONF_POSITIVE(_SC_LOGIN_NAME_MAX);
 731   VERIFY_SYSCONF_POSITIVE(_SC_THREAD_DESTRUCTOR_ITERATIONS);
 732   VERIFY_SYSCONF_POSITIVE(_SC_THREAD_KEYS_MAX);
 733   VERIFY_SYSCONF_POSITIVE(_SC_THREAD_STACK_MIN);
 734   VERIFY_SYSCONF_POSITIVE(_SC_THREAD_THREADS_MAX);
 735   VERIFY_SYSCONF_POSITIVE(_SC_TTY_NAME_MAX);
 736   VERIFY_SYSCONF_POSIX_VERSION(_SC_THREADS);
 737   VERIFY_SYSCONF_POSIX_VERSION(_SC_THREAD_ATTR_STACKADDR);
 738   VERIFY_SYSCONF_POSIX_VERSION(_SC_THREAD_ATTR_STACKSIZE);
 739   VERIFY_SYSCONF_POSIX_VERSION(_SC_THREAD_PRIORITY_SCHEDULING);
 740   VERIFY_SYSCONF_POSIX_VERSION(_SC_THREAD_PRIO_INHERIT);
 741   VERIFY_SYSCONF_POSIX_VERSION(_SC_THREAD_PRIO_PROTECT);
 742   VERIFY_SYSCONF_POSIX_VERSION(_SC_THREAD_SAFE_FUNCTIONS);
 743   VERIFY_SYSCONF_POSITIVE(_SC_NPROCESSORS_CONF);
 744   VERIFY_SYSCONF_POSITIVE(_SC_NPROCESSORS_ONLN);
 745   VERIFY_SYSCONF_POSITIVE(_SC_PHYS_PAGES);
 746   VERIFY_SYSCONF_POSITIVE(_SC_AVPHYS_PAGES);
 747   VERIFY_SYSCONF_POSIX_VERSION(_SC_MONOTONIC_CLOCK);
 748   VERIFY_SYSCONF_NOT_SUPPORT(_SC_2_PBS);
 749   VERIFY_SYSCONF_NOT_SUPPORT(_SC_2_PBS_ACCOUNTING);
 750   VERIFY_SYSCONF_NOT_SUPPORT(_SC_2_PBS_CHECKPOINT);
 751   VERIFY_SYSCONF_NOT_SUPPORT(_SC_2_PBS_LOCATE);
 752   VERIFY_SYSCONF_NOT_SUPPORT(_SC_2_PBS_MESSAGE);
 753   VERIFY_SYSCONF_NOT_SUPPORT(_SC_2_PBS_TRACK);
 754   VERIFY_SYSCONF_POSIX_VERSION(_SC_CLOCK_SELECTION);
 755   VERIFY_SYSCONF_POSITIVE(_SC_HOST_NAME_MAX);
 756   VERIFY_SYSCONF_POSIX_VERSION(_SC_IPV6);
 757   VERIFY_SYSCONF_POSIX_VERSION(_SC_RAW_SOCKETS);
 758   VERIFY_SYSCONF_POSIX_VERSION(_SC_READER_WRITER_LOCKS);
 759   VERIFY_SYSCONF_POSITIVE(_SC_REGEXP);
 760   VERIFY_SYSCONF_POSITIVE(_SC_SHELL);
 761   VERIFY_SYSCONF_NOT_SUPPORT(_SC_SPORADIC_SERVER);
 762   VERIFY_SYSCONF_POSITIVE(_SC_SYMLOOP_MAX);
 763   VERIFY_SYSCONF_POSIX_VERSION(_SC_THREAD_CPUTIME);
 764   VERIFY_SYSCONF_NOT_SUPPORT(_SC_THREAD_SPORADIC_SERVER);
 765   VERIFY_SYSCONF_POSIX_VERSION(_SC_TIMEOUTS);
 766   VERIFY_SYSCONF_NOT_SUPPORT(_SC_TRACE);
 767   VERIFY_SYSCONF_NOT_SUPPORT(_SC_TRACE_EVENT_FILTER);
 768   VERIFY_SYSCONF_NOT_SUPPORT(_SC_TRACE_EVENT_NAME_MAX);
 769   VERIFY_SYSCONF_NOT_SUPPORT(_SC_TRACE_INHERIT);
 770   VERIFY_SYSCONF_NOT_SUPPORT(_SC_TRACE_LOG);
 771   VERIFY_SYSCONF_NOT_SUPPORT(_SC_TRACE_NAME_MAX);
 772   VERIFY_SYSCONF_NOT_SUPPORT(_SC_TRACE_SYS_MAX);
 773   VERIFY_SYSCONF_NOT_SUPPORT(_SC_TRACE_USER_EVENT_MAX);
 774   VERIFY_SYSCONF_NOT_SUPPORT(_SC_TYPED_MEMORY_OBJECTS);
 775   VERIFY_SYSCONF_NOT_SUPPORT(_SC_XOPEN_STREAMS);
 776
 777 #if defined(__LP64__)
 778   VERIFY_SYSCONF_NOT_SUPPORT(_SC_V7_ILP32_OFF32);
 779   VERIFY_SYSCONF_NOT_SUPPORT(_SC_V7_ILP32_OFFBIG);
 780   VERIFY_SYSCONF_POSITIVE(_SC_V7_LP64_OFF64);
 781   VERIFY_SYSCONF_POSITIVE(_SC_V7_LPBIG_OFFBIG);
 782 #else
 783   VERIFY_SYSCONF_POSITIVE(_SC_V7_ILP32_OFF32);
 784 #if defined(__BIONIC__)
 785   // bionic does not support 64 bits off_t type on 32bit machine.
 786   VERIFY_SYSCONF_NOT_SUPPORT(_SC_V7_ILP32_OFFBIG);
 787 #endif
 788   VERIFY_SYSCONF_NOT_SUPPORT(_SC_V7_LP64_OFF64);
 789   VERIFY_SYSCONF_NOT_SUPPORT(_SC_V7_LPBIG_OFFBIG);
 790 #endif
 791
 792 #if defined(__BIONIC__)
 793   // Tests can only run on bionic, as bionic and glibc have different support for these options.
 794   // Below options are not supported on bionic yet.
 795   VERIFY_SYSCONF_NOT_SUPPORT(_SC_ASYNCHRONOUS_IO);
 796   VERIFY_SYSCONF_NOT_SUPPORT(_SC_BARRIERS);
 797   VERIFY_SYSCONF_NOT_SUPPORT(_SC_MESSAGE_PASSING);
 798   VERIFY_SYSCONF_NOT_SUPPORT(_SC_PRIORITIZED_IO);
 799   VERIFY_SYSCONF_NOT_SUPPORT(_SC_SHARED_MEMORY_OBJECTS);
 800   VERIFY_SYSCONF_NOT_SUPPORT(_SC_SPAWN);
 801   VERIFY_SYSCONF_NOT_SUPPORT(_SC_SPIN_LOCKS);
 802   VERIFY_SYSCONF_NOT_SUPPORT(_SC_THREAD_PROCESS_SHARED);
 803   VERIFY_SYSCONF_NOT_SUPPORT(_SC_THREAD_ROBUST_PRIO_INHERIT);
 804   VERIFY_SYSCONF_NOT_SUPPORT(_SC_THREAD_ROBUST_PRIO_PROTECT);
 805
 806   VERIFY_SYSCONF_NOT_SUPPORT(_SC_2_C_DEV);
 807   VERIFY_SYSCONF_NOT_SUPPORT(_SC_2_CHAR_TERM);
 808   VERIFY_SYSCONF_NOT_SUPPORT(_SC_2_LOCALEDEF);
 809   VERIFY_SYSCONF_NOT_SUPPORT(_SC_2_SW_DEV);
 810   VERIFY_SYSCONF_NOT_SUPPORT(_SC_2_VERSION);
 811
 812   VERIFY_SYSCONF_NOT_SUPPORT(_SC_XOPEN_CRYPT);
 813   VERIFY_SYSCONF_NOT_SUPPORT(_SC_XOPEN_ENH_I18N);
 814   VERIFY_SYSCONF_NOT_SUPPORT(_SC_XOPEN_LEGACY);
 815   VERIFY_SYSCONF_NOT_SUPPORT(_SC_XOPEN_REALTIME);
 816   VERIFY_SYSCONF_NOT_SUPPORT(_SC_XOPEN_REALTIME_THREADS);
 817   VERIFY_SYSCONF_NOT_SUPPORT(_SC_XOPEN_SHM);
 818   VERIFY_SYSCONF_NOT_SUPPORT(_SC_XOPEN_UUCP);
 819 #endif // defined(__BIONIC__)
 820 }
 821
 822 TEST(unistd, dup2_same) {
 823   // POSIX says of dup2:
 824   // If fildes2 is already a valid open file descriptor ...
 825   // [and] fildes is equal to fildes2 ... dup2() shall return
 826   // fildes2 without closing it.
 827   // This isn't true of dup3(2), so we need to manually implement that.
 828
 829   // Equal and valid.
 830   int fd = open("/proc/version", O_RDONLY);
 831   ASSERT_TRUE(fd != -1);
 832   ASSERT_EQ(fd, dup2(fd, fd));
 833   ASSERT_EQ(0, close(fd)); // Check that dup2 didn't close fd.
 834
 835   // Equal, but invalid.
 836   errno = 0;
 837   ASSERT_EQ(-1, dup2(fd, fd));
 838   ASSERT_EQ(EBADF, errno);
 839 }