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
  19 #include "BionicDeathTest.h"
  20 #include "ScopedSignalHandler.h"
  21 #include "TemporaryFile.h"
  22 #include "utils.h"
  23
  24 #include <errno.h>
  25 #include <fcntl.h>
  26 #include <libgen.h>
  27 #include <limits.h>
  28 #include <stdint.h>
  29 #include <sys/capability.h>
  30 #include <sys/param.h>
  31 #include <sys/syscall.h>
  32 #include <sys/types.h>
  33 #include <sys/utsname.h>
  34 #include <sys/wait.h>
  35 #include <unistd.h>
  36
  37 #include <android-base/file.h>
  38 #include <android-base/strings.h>
  39
  40 #include "private/get_cpu_count_from_string.h"
  41
  42 #if defined(NOFORTIFY)
  43 #define UNISTD_TEST unistd_nofortify
  44 #define UNISTD_DEATHTEST unistd_nofortify_DeathTest
  45 #else
  46 #define UNISTD_TEST unistd
  47 #define UNISTD_DEATHTEST unistd_DeathTest
  48 #endif
  49
  50 static void* get_brk() {
  51   return sbrk(0);
  52 }
  53
  54 static void* page_align(uintptr_t addr) {
  55   uintptr_t mask = sysconf(_SC_PAGE_SIZE) - 1;
  56   return reinterpret_cast<void*>((addr + mask) & ~mask);
  57 }
  58
  59 TEST(UNISTD_TEST, brk) {
  60   void* initial_break = get_brk();
  61
  62   void* new_break = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(initial_break) + 1);
  63   int ret = brk(new_break);
  64   if (ret == -1) {
  65     ASSERT_EQ(errno, ENOMEM);
  66   } else {
  67     ASSERT_EQ(0, ret);
  68     ASSERT_GE(get_brk(), new_break);
  69   }
  70
  71   // Expand by a full page to force the mapping to expand
  72   new_break = page_align(reinterpret_cast<uintptr_t>(initial_break) + sysconf(_SC_PAGE_SIZE));
  73   ret = brk(new_break);
  74   if (ret == -1) {
  75     ASSERT_EQ(errno, ENOMEM);
  76   } else {
  77     ASSERT_EQ(0, ret);
  78     ASSERT_EQ(get_brk(), new_break);
  79   }
  80 }
  81
  82 TEST(UNISTD_TEST, brk_ENOMEM) {
  83   ASSERT_EQ(-1, brk(reinterpret_cast<void*>(-1)));
  84   ASSERT_EQ(ENOMEM, errno);
  85 }
  86
  87 #if defined(__GLIBC__)
  88 #define SBRK_MIN INTPTR_MIN
  89 #define SBRK_MAX INTPTR_MAX
  90 #else
  91 #define SBRK_MIN PTRDIFF_MIN
  92 #define SBRK_MAX PTRDIFF_MAX
  93 #endif
  94
  95 TEST(UNISTD_TEST, sbrk_ENOMEM) {
  96 #if defined(__BIONIC__) && !defined(__LP64__)
  97   // There is no way to guarantee that all overflow conditions can be tested
  98   // without manipulating the underlying values of the current break.
  99   extern void* __bionic_brk;
 100
 101   class ScopedBrk {
 102   public:
 103     ScopedBrk() : saved_brk_(__bionic_brk) {}
 104     virtual ~ScopedBrk() { __bionic_brk = saved_brk_; }
 105
 106   private:
 107     void* saved_brk_;
 108   };
 109
 110   ScopedBrk scope_brk;
 111
 112   // Set the current break to a point that will cause an overflow.
 113   __bionic_brk = reinterpret_cast<void*>(static_cast<uintptr_t>(PTRDIFF_MAX) + 2);
 114
 115   // Can't increase by so much that we'd overflow.
 116   ASSERT_EQ(reinterpret_cast<void*>(-1), sbrk(PTRDIFF_MAX));
 117   ASSERT_EQ(ENOMEM, errno);
 118
 119   // Set the current break to a point that will cause an overflow.
 120   __bionic_brk = reinterpret_cast<void*>(static_cast<uintptr_t>(PTRDIFF_MAX));
 121
 122   ASSERT_EQ(reinterpret_cast<void*>(-1), sbrk(PTRDIFF_MIN));
 123   ASSERT_EQ(ENOMEM, errno);
 124
 125   __bionic_brk = reinterpret_cast<void*>(static_cast<uintptr_t>(PTRDIFF_MAX) - 1);
 126
 127   ASSERT_EQ(reinterpret_cast<void*>(-1), sbrk(PTRDIFF_MIN + 1));
 128   ASSERT_EQ(ENOMEM, errno);
 129 #else
 130   class ScopedBrk {
 131   public:
 132     ScopedBrk() : saved_brk_(get_brk()) {}
 133     virtual ~ScopedBrk() { brk(saved_brk_); }
 134
 135   private:
 136     void* saved_brk_;
 137   };
 138
 139   ScopedBrk scope_brk;
 140
 141   uintptr_t cur_brk = reinterpret_cast<uintptr_t>(get_brk());
 142   if (cur_brk < static_cast<uintptr_t>(-(SBRK_MIN+1))) {
 143     // Do the overflow test for a max negative increment.
 144     ASSERT_EQ(reinterpret_cast<void*>(-1), sbrk(SBRK_MIN));
 145 #if defined(__BIONIC__)
 146     // GLIBC does not set errno in overflow case.
 147     ASSERT_EQ(ENOMEM, errno);
 148 #endif
 149   }
 150
 151   uintptr_t overflow_brk = static_cast<uintptr_t>(SBRK_MAX) + 2;
 152   if (cur_brk < overflow_brk) {
 153     // Try and move the value to PTRDIFF_MAX + 2.
 154     cur_brk = reinterpret_cast<uintptr_t>(sbrk(overflow_brk));
 155   }
 156   if (cur_brk >= overflow_brk) {
 157     ASSERT_EQ(reinterpret_cast<void*>(-1), sbrk(SBRK_MAX));
 158 #if defined(__BIONIC__)
 159     // GLIBC does not set errno in overflow case.
 160     ASSERT_EQ(ENOMEM, errno);
 161 #endif
 162   }
 163 #endif
 164 }
 165
 166 TEST(UNISTD_TEST, truncate) {
 167   TemporaryFile tf;
 168   ASSERT_EQ(0, close(tf.fd));
 169   ASSERT_EQ(0, truncate(tf.filename, 123));
 170
 171   struct stat sb;
 172   ASSERT_EQ(0, stat(tf.filename, &sb));
 173   ASSERT_EQ(123, sb.st_size);
 174 }
 175
 176 TEST(UNISTD_TEST, truncate64) {
 177   TemporaryFile tf;
 178   ASSERT_EQ(0, close(tf.fd));
 179   ASSERT_EQ(0, truncate64(tf.filename, 123));
 180
 181   struct stat sb;
 182   ASSERT_EQ(0, stat(tf.filename, &sb));
 183   ASSERT_EQ(123, sb.st_size);
 184 }
 185
 186 TEST(UNISTD_TEST, ftruncate) {
 187   TemporaryFile tf;
 188   ASSERT_EQ(0, ftruncate(tf.fd, 123));
 189   ASSERT_EQ(0, close(tf.fd));
 190
 191   struct stat sb;
 192   ASSERT_EQ(0, stat(tf.filename, &sb));
 193   ASSERT_EQ(123, sb.st_size);
 194 }
 195
 196 TEST(UNISTD_TEST, ftruncate64) {
 197   TemporaryFile tf;
 198   ASSERT_EQ(0, ftruncate64(tf.fd, 123));
 199   ASSERT_EQ(0, close(tf.fd));
 200
 201   struct stat sb;
 202   ASSERT_EQ(0, stat(tf.filename, &sb));
 203   ASSERT_EQ(123, sb.st_size);
 204 }
 205
 206 TEST(UNISTD_TEST, ftruncate_negative) {
 207   TemporaryFile tf;
 208   errno = 0;
 209   ASSERT_EQ(-1, ftruncate(tf.fd, -123));
 210   ASSERT_EQ(EINVAL, errno);
 211 }
 212
 213 static bool g_pause_test_flag = false;
 214 static void PauseTestSignalHandler(int) {
 215   g_pause_test_flag = true;
 216 }
 217
 218 TEST(UNISTD_TEST, pause) {
 219   ScopedSignalHandler handler(SIGALRM, PauseTestSignalHandler);
 220
 221   alarm(1);
 222   ASSERT_FALSE(g_pause_test_flag);
 223   ASSERT_EQ(-1, pause());
 224   ASSERT_TRUE(g_pause_test_flag);
 225 }
 226
 227 TEST(UNISTD_TEST, read) {
 228   int fd = open("/proc/version", O_RDONLY);
 229   ASSERT_TRUE(fd != -1);
 230
 231   char buf[5];
 232   ASSERT_EQ(5, read(fd, buf, 5));
 233   ASSERT_EQ(buf[0], 'L');
 234   ASSERT_EQ(buf[1], 'i');
 235   ASSERT_EQ(buf[2], 'n');
 236   ASSERT_EQ(buf[3], 'u');
 237   ASSERT_EQ(buf[4], 'x');
 238   close(fd);
 239 }
 240
 241 TEST(UNISTD_TEST, read_EBADF) {
 242   // read returns ssize_t which is 64-bits on LP64, so it's worth explicitly checking that
 243   // our syscall stubs correctly return a 64-bit -1.
 244   char buf[1];
 245   ASSERT_EQ(-1, read(-1, buf, sizeof(buf)));
 246   ASSERT_EQ(EBADF, errno);
 247 }
 248
 249 TEST(UNISTD_TEST, syscall_long) {
 250   // Check that syscall(3) correctly returns long results.
 251   // https://code.google.com/p/android/issues/detail?id=73952
 252   // We assume that the break is > 4GiB, but this is potentially flaky.
 253   uintptr_t p = reinterpret_cast<uintptr_t>(sbrk(0));
 254   ASSERT_EQ(p, static_cast<uintptr_t>(syscall(__NR_brk, 0)));
 255 }
 256
 257 TEST(UNISTD_TEST, alarm) {
 258   ASSERT_EQ(0U, alarm(0));
 259 }
 260
 261 TEST(UNISTD_TEST, _exit) {
 262   pid_t pid = fork();
 263   ASSERT_NE(-1, pid) << strerror(errno);
 264
 265   if (pid == 0) {
 266     _exit(99);
 267   }
 268
 269   AssertChildExited(pid, 99);
 270 }
 271
 272 TEST(UNISTD_TEST, getenv_unsetenv) {
 273   ASSERT_EQ(0, setenv("test-variable", "hello", 1));
 274   ASSERT_STREQ("hello", getenv("test-variable"));
 275   ASSERT_EQ(0, unsetenv("test-variable"));
 276   ASSERT_TRUE(getenv("test-variable") == NULL);
 277 }
 278
 279 TEST(UNISTD_TEST, unsetenv_EINVAL) {
 280   EXPECT_EQ(-1, unsetenv(""));
 281   EXPECT_EQ(EINVAL, errno);
 282   EXPECT_EQ(-1, unsetenv("a=b"));
 283   EXPECT_EQ(EINVAL, errno);
 284 }
 285
 286 TEST(UNISTD_TEST, setenv_EINVAL) {
 287   EXPECT_EQ(-1, setenv(NULL, "value", 0));
 288   EXPECT_EQ(EINVAL, errno);
 289   EXPECT_EQ(-1, setenv(NULL, "value", 1));
 290   EXPECT_EQ(EINVAL, errno);
 291   EXPECT_EQ(-1, setenv("", "value", 0));
 292   EXPECT_EQ(EINVAL, errno);
 293   EXPECT_EQ(-1, setenv("", "value", 1));
 294   EXPECT_EQ(EINVAL, errno);
 295   EXPECT_EQ(-1, setenv("a=b", "value", 0));
 296   EXPECT_EQ(EINVAL, errno);
 297   EXPECT_EQ(-1, setenv("a=b", "value", 1));
 298   EXPECT_EQ(EINVAL, errno);
 299 }
 300
 301 TEST(UNISTD_TEST, setenv) {
 302   ASSERT_EQ(0, unsetenv("test-variable"));
 303
 304   char a[] = "a";
 305   char b[] = "b";
 306   char c[] = "c";
 307
 308   // New value.
 309   EXPECT_EQ(0, setenv("test-variable", a, 0));
 310   EXPECT_STREQ(a, getenv("test-variable"));
 311
 312   // Existing value, no overwrite.
 313   EXPECT_EQ(0, setenv("test-variable", b, 0));
 314   EXPECT_STREQ(a, getenv("test-variable"));
 315
 316   // Existing value, overwrite.
 317   EXPECT_EQ(0, setenv("test-variable", c, 1));
 318   EXPECT_STREQ(c, getenv("test-variable"));
 319   // But the arrays backing the values are unchanged.
 320   EXPECT_EQ('a', a[0]);
 321   EXPECT_EQ('b', b[0]);
 322   EXPECT_EQ('c', c[0]);
 323
 324   ASSERT_EQ(0, unsetenv("test-variable"));
 325 }
 326
 327 TEST(UNISTD_TEST, putenv) {
 328   ASSERT_EQ(0, unsetenv("a"));
 329
 330   char* s1 = strdup("a=b");
 331   ASSERT_EQ(0, putenv(s1));
 332
 333   ASSERT_STREQ("b", getenv("a"));
 334   s1[2] = 'c';
 335   ASSERT_STREQ("c", getenv("a"));
 336
 337   char* s2 = strdup("a=b");
 338   ASSERT_EQ(0, putenv(s2));
 339
 340   ASSERT_STREQ("b", getenv("a"));
 341   ASSERT_EQ('c', s1[2]);
 342
 343   ASSERT_EQ(0, unsetenv("a"));
 344   free(s1);
 345   free(s2);
 346 }
 347
 348 TEST(UNISTD_TEST, clearenv) {
 349   extern char** environ;
 350
 351   // Guarantee that environ is not initially empty...
 352   ASSERT_EQ(0, setenv("test-variable", "a", 1));
 353
 354   // Stash a copy.
 355   std::vector<char*> old_environ;
 356   for (size_t i = 0; environ[i] != NULL; ++i) {
 357     old_environ.push_back(strdup(environ[i]));
 358   }
 359
 360   ASSERT_EQ(0, clearenv());
 361
 362   EXPECT_TRUE(environ == NULL || environ[0] == NULL);
 363   EXPECT_EQ(NULL, getenv("test-variable"));
 364   EXPECT_EQ(0, setenv("test-variable", "post-clear", 1));
 365   EXPECT_STREQ("post-clear", getenv("test-variable"));
 366
 367   // Put the old environment back.
 368   for (size_t i = 0; i < old_environ.size(); ++i) {
 369     EXPECT_EQ(0, putenv(old_environ[i]));
 370   }
 371
 372   // Check it wasn't overwritten.
 373   EXPECT_STREQ("a", getenv("test-variable"));
 374
 375   EXPECT_EQ(0, unsetenv("test-variable"));
 376 }
 377
 378 static void TestFsyncFunction(int (*fn)(int)) {
 379   int fd;
 380
 381   // Can't sync an invalid fd.
 382   errno = 0;
 383   EXPECT_EQ(-1, fn(-1));
 384   EXPECT_EQ(EBADF, errno);
 385
 386   // It doesn't matter whether you've opened a file for write or not.
 387   TemporaryFile tf;
 388   ASSERT_NE(-1, tf.fd);
 389
 390   EXPECT_EQ(0, fn(tf.fd));
 391
 392   ASSERT_NE(-1, fd = open(tf.filename, O_RDONLY));
 393   EXPECT_EQ(0, fn(fd));
 394   close(fd);
 395
 396   ASSERT_NE(-1, fd = open(tf.filename, O_RDWR));
 397   EXPECT_EQ(0, fn(fd));
 398   close(fd);
 399
 400   // The fd can even be a directory.
 401   ASSERT_NE(-1, fd = open("/data/local/tmp", O_RDONLY));
 402   EXPECT_EQ(0, fn(fd));
 403   close(fd);
 404
 405   // But some file systems may choose to be fussy...
 406   errno = 0;
 407   ASSERT_NE(-1, fd = open("/proc/version", O_RDONLY));
 408   EXPECT_EQ(-1, fn(fd));
 409   EXPECT_EQ(EINVAL, errno);
 410   close(fd);
 411 }
 412
 413 TEST(UNISTD_TEST, fdatasync) {
 414   TestFsyncFunction(fdatasync);
 415 }
 416
 417 TEST(UNISTD_TEST, fsync) {
 418   TestFsyncFunction(fsync);
 419 }
 420
 421 static void AssertGetPidCorrect() {
 422   // The loop is just to make manual testing/debugging with strace easier.
 423   pid_t getpid_syscall_result = syscall(__NR_getpid);
 424   for (size_t i = 0; i < 128; ++i) {
 425     ASSERT_EQ(getpid_syscall_result, getpid());
 426   }
 427 }
 428
 429 static void TestGetPidCachingWithFork(int (*fork_fn)(), void (*exit_fn)(int)) {
 430   pid_t parent_pid = getpid();
 431   ASSERT_EQ(syscall(__NR_getpid), parent_pid);
 432
 433   pid_t fork_result = fork_fn();
 434   ASSERT_NE(fork_result, -1);
 435   if (fork_result == 0) {
 436     // We're the child.
 437     ASSERT_NO_FATAL_FAILURE(AssertGetPidCorrect());
 438     ASSERT_EQ(parent_pid, getppid());
 439     exit_fn(123);
 440   } else {
 441     // We're the parent.
 442     ASSERT_EQ(parent_pid, getpid());
 443     AssertChildExited(fork_result, 123);
 444   }
 445 }
 446
 447 // gettid() is marked as __attribute_const__, which will have the compiler
 448 // optimize out multiple calls to gettid in the same function. This wrapper
 449 // defeats that optimization.
 450 static __attribute__((__noinline__)) pid_t GetTidForTest() {
 451   __asm__("");
 452   return gettid();
 453 }
 454
 455 static void AssertGetTidCorrect() {
 456   // The loop is just to make manual testing/debugging with strace easier.
 457   pid_t gettid_syscall_result = syscall(__NR_gettid);
 458   for (size_t i = 0; i < 128; ++i) {
 459     ASSERT_EQ(gettid_syscall_result, GetTidForTest());
 460   }
 461 }
 462
 463 static void TestGetTidCachingWithFork(int (*fork_fn)(), void (*exit_fn)(int)) {
 464   pid_t parent_tid = GetTidForTest();
 465   ASSERT_EQ(syscall(__NR_gettid), parent_tid);
 466
 467   pid_t fork_result = fork_fn();
 468   ASSERT_NE(fork_result, -1);
 469   if (fork_result == 0) {
 470     // We're the child.
 471     EXPECT_EQ(syscall(__NR_getpid), syscall(__NR_gettid));
 472     EXPECT_EQ(getpid(), GetTidForTest()) << "real tid is " << syscall(__NR_gettid)
 473                                          << ", pid is " << syscall(__NR_getpid);
 474     ASSERT_NO_FATAL_FAILURE(AssertGetTidCorrect());
 475     exit_fn(123);
 476   } else {
 477     // We're the parent.
 478     ASSERT_EQ(parent_tid, GetTidForTest());
 479     AssertChildExited(fork_result, 123);
 480   }
 481 }
 482
 483 TEST(UNISTD_TEST, getpid_caching_and_fork) {
 484   TestGetPidCachingWithFork(fork, exit);
 485 }
 486
 487 TEST(UNISTD_TEST, gettid_caching_and_fork) {
 488   TestGetTidCachingWithFork(fork, exit);
 489 }
 490
 491 TEST(UNISTD_TEST, getpid_caching_and_vfork) {
 492   TestGetPidCachingWithFork(vfork, _exit);
 493 }
 494
 495 static int CloneLikeFork() {
 496   return clone(nullptr, nullptr, SIGCHLD, nullptr);
 497 }
 498
 499 TEST(UNISTD_TEST, getpid_caching_and_clone_process) {
 500   TestGetPidCachingWithFork(CloneLikeFork, exit);
 501 }
 502
 503 TEST(UNISTD_TEST, gettid_caching_and_clone_process) {
 504   TestGetTidCachingWithFork(CloneLikeFork, exit);
 505 }
 506
 507 static int CloneAndSetTid() {
 508   pid_t child_tid = 0;
 509   pid_t parent_tid = GetTidForTest();
 510
 511   int rv = clone(nullptr, nullptr, CLONE_CHILD_SETTID | SIGCHLD, nullptr, nullptr, nullptr, &child_tid);
 512   EXPECT_NE(-1, rv);
 513
 514   if (rv == 0) {
 515     // Child.
 516     EXPECT_EQ(child_tid, GetTidForTest());
 517     EXPECT_NE(child_tid, parent_tid);
 518   } else {
 519     EXPECT_NE(child_tid, GetTidForTest());
 520     EXPECT_NE(child_tid, parent_tid);
 521     EXPECT_EQ(GetTidForTest(), parent_tid);
 522   }
 523
 524   return rv;
 525 }
 526
 527 TEST(UNISTD_TEST, gettid_caching_and_clone_process_settid) {
 528   TestGetTidCachingWithFork(CloneAndSetTid, exit);
 529 }
 530
 531 static int CloneStartRoutine(int (*start_routine)(void*)) {
 532   void* child_stack[1024];
 533   return clone(start_routine, &child_stack[1024], SIGCHLD, NULL);
 534 }
 535
 536 static int GetPidCachingCloneStartRoutine(void*) {
 537   AssertGetPidCorrect();
 538   return 123;
 539 }
 540
 541 TEST(UNISTD_TEST, getpid_caching_and_clone) {
 542   pid_t parent_pid = getpid();
 543   ASSERT_EQ(syscall(__NR_getpid), parent_pid);
 544
 545   int clone_result = CloneStartRoutine(GetPidCachingCloneStartRoutine);
 546   ASSERT_NE(clone_result, -1);
 547
 548   ASSERT_EQ(parent_pid, getpid());
 549
 550   AssertChildExited(clone_result, 123);
 551 }
 552
 553 static int GetTidCachingCloneStartRoutine(void*) {
 554   AssertGetTidCorrect();
 555   return 123;
 556 }
 557
 558 TEST(UNISTD_TEST, gettid_caching_and_clone) {
 559   pid_t parent_tid = GetTidForTest();
 560   ASSERT_EQ(syscall(__NR_gettid), parent_tid);
 561
 562   int clone_result = CloneStartRoutine(GetTidCachingCloneStartRoutine);
 563   ASSERT_NE(clone_result, -1);
 564
 565   ASSERT_EQ(parent_tid, GetTidForTest());
 566
 567   AssertChildExited(clone_result, 123);
 568 }
 569
 570 static int CloneChildExit(void*) {
 571   AssertGetPidCorrect();
 572   AssertGetTidCorrect();
 573   exit(33);
 574 }
 575
 576 TEST(UNISTD_TEST, clone_fn_and_exit) {
 577   int clone_result = CloneStartRoutine(CloneChildExit);
 578   ASSERT_NE(-1, clone_result);
 579
 580   AssertGetPidCorrect();
 581   AssertGetTidCorrect();
 582
 583   AssertChildExited(clone_result, 33);
 584 }
 585
 586 static void* GetPidCachingPthreadStartRoutine(void*) {
 587   AssertGetPidCorrect();
 588   return NULL;
 589 }
 590
 591 TEST(UNISTD_TEST, getpid_caching_and_pthread_create) {
 592   pid_t parent_pid = getpid();
 593
 594   pthread_t t;
 595   ASSERT_EQ(0, pthread_create(&t, NULL, GetPidCachingPthreadStartRoutine, NULL));
 596
 597   ASSERT_EQ(parent_pid, getpid());
 598
 599   void* result;
 600   ASSERT_EQ(0, pthread_join(t, &result));
 601   ASSERT_EQ(NULL, result);
 602 }
 603
 604 static void* GetTidCachingPthreadStartRoutine(void*) {
 605   AssertGetTidCorrect();
 606   uint64_t tid = GetTidForTest();
 607   return reinterpret_cast<void*>(tid);
 608 }
 609
 610 TEST(UNISTD_TEST, gettid_caching_and_pthread_create) {
 611   pid_t parent_tid = GetTidForTest();
 612
 613   pthread_t t;
 614   ASSERT_EQ(0, pthread_create(&t, NULL, GetTidCachingPthreadStartRoutine, &parent_tid));
 615
 616   ASSERT_EQ(parent_tid, GetTidForTest());
 617
 618   void* result;
 619   ASSERT_EQ(0, pthread_join(t, &result));
 620   ASSERT_NE(static_cast<uint64_t>(parent_tid), reinterpret_cast<uint64_t>(result));
 621 }
 622
 623 class UNISTD_DEATHTEST : public BionicDeathTest {};
 624
 625 TEST_F(UNISTD_DEATHTEST, abort) {
 626   ASSERT_EXIT(abort(), testing::KilledBySignal(SIGABRT), "");
 627 }
 628
 629 TEST(UNISTD_TEST, sethostname) {
 630   // The permissions check happens before the argument check, so this will
 631   // fail for a different reason if you're running as root than if you're
 632   // not, but it'll fail either way. Checking that we have the symbol is about
 633   // all we can do for sethostname(2).
 634   ASSERT_EQ(-1, sethostname("", -1));
 635 }
 636
 637 TEST(UNISTD_TEST, gethostname) {
 638   char hostname[HOST_NAME_MAX + 1];
 639   memset(hostname, 0, sizeof(hostname));
 640
 641   // Can we get the hostname with a big buffer?
 642   ASSERT_EQ(0, gethostname(hostname, HOST_NAME_MAX));
 643
 644   // Can we get the hostname with a right-sized buffer?
 645   errno = 0;
 646   ASSERT_EQ(0, gethostname(hostname, strlen(hostname) + 1));
 647
 648   // Does uname(2) agree?
 649   utsname buf;
 650   ASSERT_EQ(0, uname(&buf));
 651   ASSERT_EQ(0, strncmp(hostname, buf.nodename, SYS_NMLN));
 652   ASSERT_GT(strlen(hostname), 0U);
 653
 654   // Do we correctly detect truncation?
 655   errno = 0;
 656   ASSERT_EQ(-1, gethostname(hostname, strlen(hostname)));
 657   ASSERT_EQ(ENAMETOOLONG, errno);
 658 }
 659
 660 TEST(UNISTD_TEST, pathconf_fpathconf) {
 661   TemporaryFile tf;
 662   long rc = 0L;
 663   // As a file system's block size is always power of 2, the configure values
 664   // for ALLOC and XFER should be power of 2 as well.
 665   rc = pathconf(tf.filename, _PC_ALLOC_SIZE_MIN);
 666   ASSERT_TRUE(rc > 0 && powerof2(rc));
 667   rc = pathconf(tf.filename, _PC_REC_MIN_XFER_SIZE);
 668   ASSERT_TRUE(rc > 0 && powerof2(rc));
 669   rc = pathconf(tf.filename, _PC_REC_XFER_ALIGN);
 670   ASSERT_TRUE(rc > 0 && powerof2(rc));
 671
 672   rc = fpathconf(tf.fd, _PC_ALLOC_SIZE_MIN);
 673   ASSERT_TRUE(rc > 0 && powerof2(rc));
 674   rc = fpathconf(tf.fd, _PC_REC_MIN_XFER_SIZE);
 675   ASSERT_TRUE(rc > 0 && powerof2(rc));
 676   rc = fpathconf(tf.fd, _PC_REC_XFER_ALIGN);
 677   ASSERT_TRUE(rc > 0 && powerof2(rc));
 678 }
 679
 680
 681 TEST(UNISTD_TEST, _POSIX_macros_smoke) {
 682   // Make a tight verification of _POSIX_* / _POSIX2_* / _XOPEN_* macros, to prevent change by mistake.
 683   // Verify according to POSIX.1-2008.
 684   EXPECT_EQ(200809L, _POSIX_VERSION);
 685
 686   EXPECT_EQ(_POSIX_VERSION, _POSIX_ADVISORY_INFO);
 687   EXPECT_GT(_POSIX_AIO_LISTIO_MAX, 0);
 688   EXPECT_GT(_POSIX_AIO_MAX, 0);
 689   EXPECT_GT(_POSIX_ARG_MAX, 0);
 690   EXPECT_GT(_POSIX_BARRIERS, 0);
 691   EXPECT_GT(_POSIX_SPIN_LOCKS, 0);
 692   EXPECT_GT(_POSIX_CHILD_MAX, 0);
 693   EXPECT_NE(_POSIX_CHOWN_RESTRICTED, -1);
 694   EXPECT_EQ(_POSIX_VERSION, _POSIX_CLOCK_SELECTION);
 695   EXPECT_EQ(0, _POSIX_CPUTIME);             // Use sysconf to detect support at runtime.
 696   EXPECT_GT(_POSIX_DELAYTIMER_MAX, 0);
 697   EXPECT_EQ(_POSIX_VERSION, _POSIX_FSYNC);
 698   EXPECT_GT(_POSIX_HOST_NAME_MAX, 0);
 699   EXPECT_EQ(_POSIX_VERSION, _POSIX_IPV6);
 700   EXPECT_GT(_POSIX_JOB_CONTROL, 0);
 701   EXPECT_GT(_POSIX_LINK_MAX, 0);
 702   EXPECT_GT(_POSIX_LOGIN_NAME_MAX, 0);
 703   EXPECT_EQ(_POSIX_VERSION, _POSIX_MAPPED_FILES);
 704   EXPECT_GT(_POSIX_MAX_CANON, 0);
 705   EXPECT_GT(_POSIX_MAX_INPUT, 0);
 706   EXPECT_EQ(_POSIX_VERSION, _POSIX_MEMLOCK);
 707   EXPECT_EQ(_POSIX_VERSION, _POSIX_MEMLOCK_RANGE);
 708   EXPECT_EQ(_POSIX_VERSION, _POSIX_MEMORY_PROTECTION);
 709   EXPECT_EQ(0, _POSIX_MONOTONIC_CLOCK);
 710   EXPECT_GT(_POSIX_MQ_OPEN_MAX, 0);
 711   EXPECT_GT(_POSIX_MQ_PRIO_MAX, 0);
 712   EXPECT_GT(_POSIX_NAME_MAX, 0);
 713   EXPECT_GT(_POSIX_NGROUPS_MAX, 0);
 714   EXPECT_GT(_POSIX_NO_TRUNC, 0);
 715   EXPECT_GT(_POSIX_OPEN_MAX, 0);
 716   EXPECT_GT(_POSIX_PATH_MAX, 0);
 717   EXPECT_GT(_POSIX_PIPE_BUF, 0);
 718   EXPECT_EQ(_POSIX_VERSION, _POSIX_PRIORITY_SCHEDULING);
 719   EXPECT_EQ(_POSIX_VERSION, _POSIX_RAW_SOCKETS);
 720   EXPECT_EQ(_POSIX_VERSION, _POSIX_READER_WRITER_LOCKS);
 721   EXPECT_EQ(_POSIX_VERSION, _POSIX_REALTIME_SIGNALS);
 722   EXPECT_GT(_POSIX_REGEXP, 0);
 723   EXPECT_GT(_POSIX_RE_DUP_MAX, 0);
 724   EXPECT_GT(_POSIX_SAVED_IDS, 0);
 725   EXPECT_EQ(_POSIX_VERSION, _POSIX_SEMAPHORES);
 726   EXPECT_GT(_POSIX_SEM_NSEMS_MAX, 0);
 727   EXPECT_GT(_POSIX_SEM_VALUE_MAX, 0);
 728   EXPECT_GT(_POSIX_SHELL, 0);
 729   EXPECT_GT(_POSIX_SIGQUEUE_MAX, 0);
 730   EXPECT_EQ(-1, _POSIX_SPORADIC_SERVER);
 731   EXPECT_GT(_POSIX_SSIZE_MAX, 0);
 732   EXPECT_GT(_POSIX_STREAM_MAX, 0);
 733   EXPECT_GT(_POSIX_SYMLINK_MAX, 0);
 734   EXPECT_GT(_POSIX_SYMLOOP_MAX, 0);
 735   EXPECT_EQ(_POSIX_VERSION, _POSIX_SYNCHRONIZED_IO);
 736   EXPECT_EQ(_POSIX_VERSION, _POSIX_THREADS);
 737   EXPECT_EQ(_POSIX_VERSION, _POSIX_THREAD_ATTR_STACKADDR);
 738   EXPECT_EQ(_POSIX_VERSION, _POSIX_THREAD_ATTR_STACKSIZE);
 739   EXPECT_EQ(0, _POSIX_THREAD_CPUTIME);       // Use sysconf to detect support at runtime.
 740   EXPECT_GT(_POSIX_THREAD_DESTRUCTOR_ITERATIONS, 0);
 741   EXPECT_EQ(_POSIX_THREAD_KEYS_MAX, 128);
 742   EXPECT_EQ(_POSIX_VERSION, _POSIX_THREAD_PRIORITY_SCHEDULING);
 743   EXPECT_EQ(-1, _POSIX_THREAD_PRIO_INHERIT);
 744   EXPECT_EQ(-1, _POSIX_THREAD_PRIO_PROTECT);
 745   EXPECT_EQ(-1, _POSIX_THREAD_ROBUST_PRIO_PROTECT);
 746   EXPECT_EQ(_POSIX_VERSION, _POSIX_THREAD_SAFE_FUNCTIONS);
 747   EXPECT_EQ(-1, _POSIX_THREAD_SPORADIC_SERVER);
 748   EXPECT_GT(_POSIX_THREAD_THREADS_MAX, 0);
 749   EXPECT_EQ(_POSIX_VERSION, _POSIX_TIMEOUTS);
 750   EXPECT_EQ(_POSIX_VERSION, _POSIX_TIMERS);
 751   EXPECT_GT(_POSIX_TIMER_MAX, 0);
 752   EXPECT_EQ(-1, _POSIX_TRACE);
 753   EXPECT_EQ(-1, _POSIX_TRACE_EVENT_FILTER);
 754   EXPECT_EQ(-1, _POSIX_TRACE_INHERIT);
 755   EXPECT_EQ(-1, _POSIX_TRACE_LOG);
 756   EXPECT_GT(_POSIX_TTY_NAME_MAX, 0);
 757   EXPECT_EQ(-1, _POSIX_TYPED_MEMORY_OBJECTS);
 758   EXPECT_GT(_POSIX_TZNAME_MAX, 0);
 759   EXPECT_NE(-1, _POSIX_VDISABLE);
 760
 761   EXPECT_GT(_POSIX2_BC_BASE_MAX, 0);
 762   EXPECT_GT(_POSIX2_BC_DIM_MAX, 0);
 763   EXPECT_GT(_POSIX2_BC_SCALE_MAX, 0);
 764   EXPECT_GT(_POSIX2_BC_STRING_MAX, 0);
 765   EXPECT_GT(_POSIX2_CHARCLASS_NAME_MAX, 0);
 766   EXPECT_GT(_POSIX2_COLL_WEIGHTS_MAX, 0);
 767   EXPECT_EQ(_POSIX_VERSION, _POSIX2_C_BIND);
 768   EXPECT_GT(_POSIX2_EXPR_NEST_MAX, 0);
 769   EXPECT_GT(_POSIX2_LINE_MAX, 0);
 770   EXPECT_GT(_POSIX2_RE_DUP_MAX, 0);
 771
 772   EXPECT_EQ(700, _XOPEN_VERSION);
 773   EXPECT_GT(_XOPEN_IOV_MAX, 0);
 774   EXPECT_GT(_XOPEN_UNIX, 0);
 775
 776 #if defined(__BIONIC__)
 777   // These tests only pass on bionic, as bionic and glibc has different support on these macros.
 778   // Macros like _POSIX_ASYNCHRONOUS_IO are not supported on bionic yet.
 779   EXPECT_EQ(-1, _POSIX_ASYNCHRONOUS_IO);
 780   EXPECT_EQ(-1, _POSIX_MESSAGE_PASSING);
 781   EXPECT_EQ(-1, _POSIX_PRIORITIZED_IO);
 782   EXPECT_EQ(-1, _POSIX_SHARED_MEMORY_OBJECTS);
 783   EXPECT_EQ(-1, _POSIX_SPAWN);
 784   EXPECT_EQ(-1, _POSIX_THREAD_PROCESS_SHARED);
 785   EXPECT_EQ(-1, _POSIX_THREAD_ROBUST_PRIO_INHERIT);
 786
 787   EXPECT_EQ(-1, _POSIX2_VERSION);
 788   EXPECT_EQ(-1, _POSIX2_CHAR_TERM);
 789   EXPECT_EQ(-1, _POSIX2_C_DEV);
 790   EXPECT_EQ(-1, _POSIX2_LOCALEDEF);
 791   EXPECT_EQ(-1, _POSIX2_SW_DEV);
 792   EXPECT_EQ(-1, _POSIX2_UPE);
 793
 794   EXPECT_EQ(-1, _XOPEN_ENH_I18N);
 795   EXPECT_EQ(-1, _XOPEN_CRYPT);
 796   EXPECT_EQ(-1, _XOPEN_LEGACY);
 797   EXPECT_EQ(-1, _XOPEN_REALTIME);
 798   EXPECT_EQ(-1, _XOPEN_REALTIME_THREADS);
 799   EXPECT_EQ(-1, _XOPEN_SHM);
 800
 801 #endif // defined(__BIONIC__)
 802 }
 803
 804 #define VERIFY_SYSCONF_UNSUPPORTED(name) VerifySysconf(name, #name, [](long v){return v == -1;})
 805
 806 // sysconf() means unlimited when it returns -1 with errno unchanged.
 807 #define VERIFY_SYSCONF_POSITIVE(name) \
 808   VerifySysconf(name, #name, [](long v){return (v > 0 || v == -1);})
 809
 810 #define VERIFY_SYSCONF_POSIX_VERSION(name) \
 811   VerifySysconf(name, #name, [](long v){return v == _POSIX_VERSION;})
 812
 813 static void VerifySysconf(int option, const char *option_name, bool (*verify)(long)) {
 814   errno = 0;
 815   long ret = sysconf(option);
 816   EXPECT_TRUE(0 == errno && verify(ret)) << "name = " << option_name << ", ret = "
 817       << ret <<", Error Message: " << strerror(errno);
 818 }
 819
 820 TEST(UNISTD_TEST, sysconf) {
 821   VERIFY_SYSCONF_POSIX_VERSION(_SC_ADVISORY_INFO);
 822   VERIFY_SYSCONF_POSITIVE(_SC_ARG_MAX);
 823   VERIFY_SYSCONF_POSIX_VERSION(_SC_BARRIERS);
 824   VERIFY_SYSCONF_POSITIVE(_SC_BC_BASE_MAX);
 825   VERIFY_SYSCONF_POSITIVE(_SC_BC_DIM_MAX);
 826   VERIFY_SYSCONF_POSITIVE(_SC_BC_SCALE_MAX);
 827   VERIFY_SYSCONF_POSITIVE(_SC_CHILD_MAX);
 828   VERIFY_SYSCONF_POSITIVE(_SC_CLK_TCK);
 829   VERIFY_SYSCONF_POSITIVE(_SC_COLL_WEIGHTS_MAX);
 830   VERIFY_SYSCONF_POSIX_VERSION(_SC_CPUTIME);
 831   VERIFY_SYSCONF_POSITIVE(_SC_EXPR_NEST_MAX);
 832   VERIFY_SYSCONF_POSITIVE(_SC_LINE_MAX);
 833   VERIFY_SYSCONF_POSITIVE(_SC_NGROUPS_MAX);
 834   VERIFY_SYSCONF_POSITIVE(_SC_OPEN_MAX);
 835   VERIFY_SYSCONF_POSITIVE(_SC_PASS_MAX);
 836   VERIFY_SYSCONF_POSIX_VERSION(_SC_2_C_BIND);
 837   VERIFY_SYSCONF_UNSUPPORTED(_SC_2_FORT_DEV);
 838   VERIFY_SYSCONF_UNSUPPORTED(_SC_2_FORT_RUN);
 839   VERIFY_SYSCONF_UNSUPPORTED(_SC_2_UPE);
 840   VERIFY_SYSCONF_POSITIVE(_SC_JOB_CONTROL);
 841   VERIFY_SYSCONF_POSITIVE(_SC_SAVED_IDS);
 842   VERIFY_SYSCONF_POSIX_VERSION(_SC_VERSION);
 843   VERIFY_SYSCONF_POSITIVE(_SC_RE_DUP_MAX);
 844   VERIFY_SYSCONF_POSITIVE(_SC_STREAM_MAX);
 845   VERIFY_SYSCONF_POSITIVE(_SC_TZNAME_MAX);
 846   VerifySysconf(_SC_XOPEN_VERSION, "_SC_XOPEN_VERSION", [](long v){return v == _XOPEN_VERSION;});
 847   VERIFY_SYSCONF_POSITIVE(_SC_ATEXIT_MAX);
 848   VERIFY_SYSCONF_POSITIVE(_SC_IOV_MAX);
 849   VERIFY_SYSCONF_POSITIVE(_SC_PAGESIZE);
 850   VERIFY_SYSCONF_POSITIVE(_SC_PAGE_SIZE);
 851   VerifySysconf(_SC_PAGE_SIZE, "_SC_PAGE_SIZE",
 852                 [](long v){return v == sysconf(_SC_PAGESIZE) && v == getpagesize();});
 853   VERIFY_SYSCONF_POSITIVE(_SC_XOPEN_UNIX);
 854   VERIFY_SYSCONF_POSITIVE(_SC_AIO_LISTIO_MAX);
 855   VERIFY_SYSCONF_POSITIVE(_SC_AIO_MAX);
 856   VerifySysconf(_SC_AIO_PRIO_DELTA_MAX, "_SC_AIO_PRIO_DELTA_MAX", [](long v){return v >= 0;});
 857   VERIFY_SYSCONF_POSITIVE(_SC_DELAYTIMER_MAX);
 858   VERIFY_SYSCONF_POSITIVE(_SC_MQ_OPEN_MAX);
 859   VERIFY_SYSCONF_POSITIVE(_SC_MQ_PRIO_MAX);
 860   VERIFY_SYSCONF_POSITIVE(_SC_RTSIG_MAX);
 861   VERIFY_SYSCONF_POSITIVE(_SC_SEM_NSEMS_MAX);
 862   VERIFY_SYSCONF_POSITIVE(_SC_SEM_VALUE_MAX);
 863   VERIFY_SYSCONF_POSIX_VERSION(_SC_SPIN_LOCKS);
 864   VERIFY_SYSCONF_POSITIVE(_SC_TIMER_MAX);
 865   VERIFY_SYSCONF_POSIX_VERSION(_SC_FSYNC);
 866   VERIFY_SYSCONF_POSIX_VERSION(_SC_MAPPED_FILES);
 867   VERIFY_SYSCONF_POSIX_VERSION(_SC_MEMLOCK);
 868   VERIFY_SYSCONF_POSIX_VERSION(_SC_MEMLOCK_RANGE);
 869   VERIFY_SYSCONF_POSIX_VERSION(_SC_MEMORY_PROTECTION);
 870   VERIFY_SYSCONF_POSIX_VERSION(_SC_PRIORITY_SCHEDULING);
 871   VERIFY_SYSCONF_POSIX_VERSION(_SC_REALTIME_SIGNALS);
 872   VERIFY_SYSCONF_POSIX_VERSION(_SC_SEMAPHORES);
 873   VERIFY_SYSCONF_POSIX_VERSION(_SC_SYNCHRONIZED_IO);
 874   VERIFY_SYSCONF_POSIX_VERSION(_SC_TIMERS);
 875   VERIFY_SYSCONF_POSITIVE(_SC_GETGR_R_SIZE_MAX);
 876   VERIFY_SYSCONF_POSITIVE(_SC_GETPW_R_SIZE_MAX);
 877   VERIFY_SYSCONF_POSITIVE(_SC_LOGIN_NAME_MAX);
 878   VERIFY_SYSCONF_POSITIVE(_SC_THREAD_DESTRUCTOR_ITERATIONS);
 879   VERIFY_SYSCONF_POSITIVE(_SC_THREAD_KEYS_MAX);
 880   VERIFY_SYSCONF_POSITIVE(_SC_THREAD_STACK_MIN);
 881   VERIFY_SYSCONF_POSITIVE(_SC_THREAD_THREADS_MAX);
 882   VERIFY_SYSCONF_POSITIVE(_SC_TTY_NAME_MAX);
 883   VERIFY_SYSCONF_POSIX_VERSION(_SC_THREADS);
 884   VERIFY_SYSCONF_POSIX_VERSION(_SC_THREAD_ATTR_STACKADDR);
 885   VERIFY_SYSCONF_POSIX_VERSION(_SC_THREAD_ATTR_STACKSIZE);
 886   VERIFY_SYSCONF_POSIX_VERSION(_SC_THREAD_PRIORITY_SCHEDULING);
 887   VERIFY_SYSCONF_UNSUPPORTED(_SC_THREAD_PRIO_INHERIT);
 888   VERIFY_SYSCONF_UNSUPPORTED(_SC_THREAD_PRIO_PROTECT);
 889   VERIFY_SYSCONF_POSIX_VERSION(_SC_THREAD_SAFE_FUNCTIONS);
 890   VERIFY_SYSCONF_POSITIVE(_SC_NPROCESSORS_CONF);
 891   VERIFY_SYSCONF_POSITIVE(_SC_NPROCESSORS_ONLN);
 892   VERIFY_SYSCONF_POSITIVE(_SC_PHYS_PAGES);
 893   VERIFY_SYSCONF_POSITIVE(_SC_AVPHYS_PAGES);
 894   VERIFY_SYSCONF_POSIX_VERSION(_SC_MONOTONIC_CLOCK);
 895   VERIFY_SYSCONF_UNSUPPORTED(_SC_2_PBS);
 896   VERIFY_SYSCONF_UNSUPPORTED(_SC_2_PBS_ACCOUNTING);
 897   VERIFY_SYSCONF_UNSUPPORTED(_SC_2_PBS_CHECKPOINT);
 898   VERIFY_SYSCONF_UNSUPPORTED(_SC_2_PBS_LOCATE);
 899   VERIFY_SYSCONF_UNSUPPORTED(_SC_2_PBS_MESSAGE);
 900   VERIFY_SYSCONF_UNSUPPORTED(_SC_2_PBS_TRACK);
 901   VERIFY_SYSCONF_POSIX_VERSION(_SC_CLOCK_SELECTION);
 902   VERIFY_SYSCONF_POSITIVE(_SC_HOST_NAME_MAX);
 903   VERIFY_SYSCONF_POSIX_VERSION(_SC_IPV6);
 904   VERIFY_SYSCONF_POSIX_VERSION(_SC_RAW_SOCKETS);
 905   VERIFY_SYSCONF_POSIX_VERSION(_SC_READER_WRITER_LOCKS);
 906   VERIFY_SYSCONF_POSITIVE(_SC_REGEXP);
 907   VERIFY_SYSCONF_POSITIVE(_SC_SHELL);
 908   VERIFY_SYSCONF_UNSUPPORTED(_SC_SPORADIC_SERVER);
 909   VERIFY_SYSCONF_POSITIVE(_SC_SYMLOOP_MAX);
 910   VERIFY_SYSCONF_POSIX_VERSION(_SC_THREAD_CPUTIME);
 911   VERIFY_SYSCONF_UNSUPPORTED(_SC_THREAD_SPORADIC_SERVER);
 912   VERIFY_SYSCONF_POSIX_VERSION(_SC_TIMEOUTS);
 913   VERIFY_SYSCONF_UNSUPPORTED(_SC_TRACE);
 914   VERIFY_SYSCONF_UNSUPPORTED(_SC_TRACE_EVENT_FILTER);
 915   VERIFY_SYSCONF_UNSUPPORTED(_SC_TRACE_EVENT_NAME_MAX);
 916   VERIFY_SYSCONF_UNSUPPORTED(_SC_TRACE_INHERIT);
 917   VERIFY_SYSCONF_UNSUPPORTED(_SC_TRACE_LOG);
 918   VERIFY_SYSCONF_UNSUPPORTED(_SC_TRACE_NAME_MAX);
 919   VERIFY_SYSCONF_UNSUPPORTED(_SC_TRACE_SYS_MAX);
 920   VERIFY_SYSCONF_UNSUPPORTED(_SC_TRACE_USER_EVENT_MAX);
 921   VERIFY_SYSCONF_UNSUPPORTED(_SC_TYPED_MEMORY_OBJECTS);
 922   VERIFY_SYSCONF_UNSUPPORTED(_SC_XOPEN_STREAMS);
 923
 924 #if defined(__LP64__)
 925   VERIFY_SYSCONF_UNSUPPORTED(_SC_V7_ILP32_OFF32);
 926   VERIFY_SYSCONF_UNSUPPORTED(_SC_V7_ILP32_OFFBIG);
 927   VERIFY_SYSCONF_POSITIVE(_SC_V7_LP64_OFF64);
 928   VERIFY_SYSCONF_POSITIVE(_SC_V7_LPBIG_OFFBIG);
 929 #else
 930   VERIFY_SYSCONF_POSITIVE(_SC_V7_ILP32_OFF32);
 931 #if defined(__BIONIC__)
 932   // bionic does not support 64 bits off_t type on 32bit machine.
 933   VERIFY_SYSCONF_UNSUPPORTED(_SC_V7_ILP32_OFFBIG);
 934 #endif
 935   VERIFY_SYSCONF_UNSUPPORTED(_SC_V7_LP64_OFF64);
 936   VERIFY_SYSCONF_UNSUPPORTED(_SC_V7_LPBIG_OFFBIG);
 937 #endif
 938
 939 #if defined(__BIONIC__)
 940   // Tests can only run on bionic, as bionic and glibc have different support for these options.
 941   // Below options are not supported on bionic yet.
 942   VERIFY_SYSCONF_UNSUPPORTED(_SC_ASYNCHRONOUS_IO);
 943   VERIFY_SYSCONF_UNSUPPORTED(_SC_MESSAGE_PASSING);
 944   VERIFY_SYSCONF_UNSUPPORTED(_SC_PRIORITIZED_IO);
 945   VERIFY_SYSCONF_UNSUPPORTED(_SC_SHARED_MEMORY_OBJECTS);
 946   VERIFY_SYSCONF_UNSUPPORTED(_SC_SPAWN);
 947   VERIFY_SYSCONF_UNSUPPORTED(_SC_THREAD_PROCESS_SHARED);
 948   VERIFY_SYSCONF_UNSUPPORTED(_SC_THREAD_ROBUST_PRIO_INHERIT);
 949   VERIFY_SYSCONF_UNSUPPORTED(_SC_THREAD_ROBUST_PRIO_PROTECT);
 950
 951   VERIFY_SYSCONF_UNSUPPORTED(_SC_2_C_DEV);
 952   VERIFY_SYSCONF_UNSUPPORTED(_SC_2_CHAR_TERM);
 953   VERIFY_SYSCONF_UNSUPPORTED(_SC_2_LOCALEDEF);
 954   VERIFY_SYSCONF_UNSUPPORTED(_SC_2_SW_DEV);
 955   VERIFY_SYSCONF_UNSUPPORTED(_SC_2_VERSION);
 956
 957   VERIFY_SYSCONF_UNSUPPORTED(_SC_XOPEN_CRYPT);
 958   VERIFY_SYSCONF_UNSUPPORTED(_SC_XOPEN_ENH_I18N);
 959   VERIFY_SYSCONF_UNSUPPORTED(_SC_XOPEN_LEGACY);
 960   VERIFY_SYSCONF_UNSUPPORTED(_SC_XOPEN_REALTIME);
 961   VERIFY_SYSCONF_UNSUPPORTED(_SC_XOPEN_REALTIME_THREADS);
 962   VERIFY_SYSCONF_UNSUPPORTED(_SC_XOPEN_SHM);
 963   VERIFY_SYSCONF_UNSUPPORTED(_SC_XOPEN_UUCP);
 964 #endif // defined(__BIONIC__)
 965 }
 966
 967 TEST(UNISTD_TEST, get_cpu_count_from_string) {
 968   ASSERT_EQ(0, GetCpuCountFromString(" "));
 969   ASSERT_EQ(1, GetCpuCountFromString("0"));
 970   ASSERT_EQ(40, GetCpuCountFromString("0-39"));
 971   ASSERT_EQ(4, GetCpuCountFromString("0, 1-2, 4\n"));
 972 }
 973
 974 TEST(UNISTD_TEST, sysconf_SC_NPROCESSORS_ONLN) {
 975   std::string line;
 976   ASSERT_TRUE(android::base::ReadFileToString("/sys/devices/system/cpu/online", &line));
 977   long online_cpus = 0;
 978   for (const std::string& s : android::base::Split(line, ",")) {
 979     std::vector<std::string> numbers = android::base::Split(s, "-");
 980     if (numbers.size() == 1u) {
 981       online_cpus++;
 982     } else {
 983       online_cpus += atoi(numbers[1].c_str()) - atoi(numbers[0].c_str()) + 1;
 984     }
 985   }
 986   ASSERT_EQ(online_cpus, sysconf(_SC_NPROCESSORS_ONLN));
 987 }
 988
 989 TEST(UNISTD_TEST, sysconf_SC_ARG_MAX) {
 990   // Since Linux 2.6.23, ARG_MAX isn't a constant and depends on RLIMIT_STACK.
 991
 992   // Get our current limit, and set things up so we restore the limit.
 993   rlimit rl;
 994   ASSERT_EQ(0, getrlimit(RLIMIT_STACK, &rl));
 995   uint64_t original_rlim_cur = rl.rlim_cur;
 996   if (rl.rlim_cur == RLIM_INFINITY) {
 997     rl.rlim_cur = 8 * 1024 * 1024; // Bionic reports unlimited stacks as 8MiB.
 998   }
 999   auto guard = make_scope_guard([&rl, original_rlim_cur]() {
1000     rl.rlim_cur = original_rlim_cur;
1001     ASSERT_EQ(0, setrlimit(RLIMIT_STACK, &rl));
1002   });
1003
1004   // _SC_ARG_MAX should be 1/4 the stack size.
1005   EXPECT_EQ(static_cast<long>(rl.rlim_cur / 4), sysconf(_SC_ARG_MAX));
1006
1007   // If you have a really small stack, the kernel still guarantees "32 pages" (fs/exec.c).
1008   rl.rlim_cur = 1024;
1009   rl.rlim_max = RLIM_INFINITY;
1010   ASSERT_EQ(0, setrlimit(RLIMIT_STACK, &rl));
1011
1012   EXPECT_EQ(static_cast<long>(32 * sysconf(_SC_PAGE_SIZE)), sysconf(_SC_ARG_MAX));
1013
1014   // With a 128-page stack limit, we know exactly what _SC_ARG_MAX should be...
1015   rl.rlim_cur = 128 * sysconf(_SC_PAGE_SIZE);
1016   rl.rlim_max = RLIM_INFINITY;
1017   ASSERT_EQ(0, setrlimit(RLIMIT_STACK, &rl));
1018
1019   EXPECT_EQ(static_cast<long>((128 * sysconf(_SC_PAGE_SIZE)) / 4), sysconf(_SC_ARG_MAX));
1020 }
1021
1022 TEST(UNISTD_TEST, dup2_same) {
1023   // POSIX says of dup2:
1024   // If fildes2 is already a valid open file descriptor ...
1025   // [and] fildes is equal to fildes2 ... dup2() shall return
1026   // fildes2 without closing it.
1027   // This isn't true of dup3(2), so we need to manually implement that.
1028
1029   // Equal and valid.
1030   int fd = open("/proc/version", O_RDONLY);
1031   ASSERT_TRUE(fd != -1);
1032   ASSERT_EQ(fd, dup2(fd, fd));
1033   ASSERT_EQ(0, close(fd)); // Check that dup2 didn't close fd.
1034
1035   // Equal, but invalid.
1036   errno = 0;
1037   ASSERT_EQ(-1, dup2(fd, fd));
1038   ASSERT_EQ(EBADF, errno);
1039 }
1040
1041 TEST(UNISTD_TEST, lockf_smoke) {
1042   constexpr off64_t file_size = 32*1024LL;
1043
1044   TemporaryFile tf;
1045   ASSERT_EQ(0, ftruncate(tf.fd, file_size));
1046
1047   // Lock everything.
1048   ASSERT_EQ(0, lseek64(tf.fd, 0, SEEK_SET));
1049   ASSERT_EQ(0, lockf64(tf.fd, F_LOCK, file_size));
1050
1051   // Try-lock everything, this should succeed too.
1052   ASSERT_EQ(0, lseek64(tf.fd, 0, SEEK_SET));
1053   ASSERT_EQ(0, lockf64(tf.fd, F_TLOCK, file_size));
1054
1055   // Check status.
1056   ASSERT_EQ(0, lseek64(tf.fd, 0, SEEK_SET));
1057   ASSERT_EQ(0, lockf64(tf.fd, F_TEST, file_size));
1058
1059   // Unlock file.
1060   ASSERT_EQ(0, lseek64(tf.fd, 0, SEEK_SET));
1061   ASSERT_EQ(0, lockf64(tf.fd, F_ULOCK, file_size));
1062 }
1063
1064 TEST(UNISTD_TEST, lockf_zero) {
1065   constexpr off64_t file_size = 32*1024LL;
1066
1067   TemporaryFile tf;
1068   ASSERT_EQ(0, ftruncate(tf.fd, file_size));
1069
1070   // Lock everything by specifying a size of 0 (meaning "to the end, even if it changes").
1071   ASSERT_EQ(0, lseek64(tf.fd, 0, SEEK_SET));
1072   ASSERT_EQ(0, lockf64(tf.fd, F_LOCK, 0));
1073
1074   // Check that it's locked.
1075   ASSERT_EQ(0, lseek64(tf.fd, 0, SEEK_SET));
1076   ASSERT_EQ(0, lockf64(tf.fd, F_TEST, file_size));
1077
1078   // Move the end.
1079   ASSERT_EQ(0, ftruncate(tf.fd, 2*file_size));
1080
1081   // Check that the new section is locked too.
1082   ASSERT_EQ(file_size, lseek64(tf.fd, file_size, SEEK_SET));
1083   ASSERT_EQ(0, lockf64(tf.fd, F_TEST, 2*file_size));
1084 }
1085
1086 TEST(UNISTD_TEST, lockf_negative) {
1087   constexpr off64_t file_size = 32*1024LL;
1088
1089   TemporaryFile tf;
1090   ASSERT_EQ(0, ftruncate(tf.fd, file_size));
1091
1092   // Lock everything, but specifying the range in reverse.
1093   ASSERT_EQ(file_size, lseek64(tf.fd, file_size, SEEK_SET));
1094   ASSERT_EQ(0, lockf64(tf.fd, F_LOCK, -file_size));
1095
1096   // Check that it's locked.
1097   ASSERT_EQ(0, lseek64(tf.fd, 0, SEEK_SET));
1098   ASSERT_EQ(0, lockf64(tf.fd, F_TEST, file_size));
1099 }
1100
1101 TEST(UNISTD_TEST, lockf_with_child) {
1102   constexpr off64_t file_size = 32*1024LL;
1103
1104   TemporaryFile tf;
1105   ASSERT_EQ(0, ftruncate(tf.fd, file_size));
1106
1107   // Lock everything.
1108   ASSERT_EQ(0, lseek64(tf.fd, 0, SEEK_SET));
1109   ASSERT_EQ(0, lockf64(tf.fd, F_LOCK, file_size));
1110
1111   // Fork a child process
1112   pid_t pid = fork();
1113   ASSERT_NE(-1, pid);
1114   if (pid == 0) {
1115     // Check that the child cannot lock the file.
1116     ASSERT_EQ(0, lseek64(tf.fd, 0, SEEK_SET));
1117     ASSERT_EQ(-1, lockf64(tf.fd, F_TLOCK, file_size));
1118     ASSERT_EQ(EAGAIN, errno);
1119     // Check also that it reports itself as locked.
1120     ASSERT_EQ(0, lseek64(tf.fd, 0, SEEK_SET));
1121     ASSERT_EQ(-1, lockf64(tf.fd, F_TEST, file_size));
1122     ASSERT_EQ(EACCES, errno);
1123     _exit(0);
1124   }
1125   AssertChildExited(pid, 0);
1126 }
1127
1128 TEST(UNISTD_TEST, lockf_partial_with_child) {
1129   constexpr off64_t file_size = 32*1024LL;
1130
1131   TemporaryFile tf;
1132   ASSERT_EQ(0, ftruncate(tf.fd, file_size));
1133
1134   // Lock the first half of the file.
1135   ASSERT_EQ(0, lseek64(tf.fd, 0, SEEK_SET));
1136   ASSERT_EQ(0, lockf64(tf.fd, F_LOCK, file_size/2));
1137
1138   // Fork a child process.
1139   pid_t pid = fork();
1140   ASSERT_NE(-1, pid);
1141   if (pid == 0) {
1142     // Check that the child can lock the other half.
1143     ASSERT_EQ(file_size/2, lseek64(tf.fd, file_size/2, SEEK_SET));
1144     ASSERT_EQ(0, lockf64(tf.fd, F_TLOCK, file_size/2));
1145     // Check that the child cannot lock the first half.
1146     ASSERT_EQ(0, lseek64(tf.fd, 0, SEEK_SET));
1147     ASSERT_EQ(-1, lockf64(tf.fd, F_TEST, file_size/2));
1148     ASSERT_EQ(EACCES, errno);
1149     // Check also that it reports itself as locked.
1150     ASSERT_EQ(0, lseek64(tf.fd, 0, SEEK_SET));
1151     ASSERT_EQ(-1, lockf64(tf.fd, F_TEST, file_size/2));
1152     ASSERT_EQ(EACCES, errno);
1153     _exit(0);
1154   }
1155   AssertChildExited(pid, 0);
1156
1157   // The second half was locked by the child, but the lock disappeared
1158   // when the process exited, so check it can be locked now.
1159   ASSERT_EQ(file_size/2, lseek64(tf.fd, file_size/2, SEEK_SET));
1160   ASSERT_EQ(0, lockf64(tf.fd, F_TLOCK, file_size/2));
1161 }
1162
1163 TEST(UNISTD_TEST, getdomainname) {
1164   struct utsname u;
1165   ASSERT_EQ(0, uname(&u));
1166
1167   char buf[sizeof(u.domainname)];
1168   ASSERT_EQ(0, getdomainname(buf, sizeof(buf)));
1169   EXPECT_STREQ(u.domainname, buf);
1170
1171 #if defined(__BIONIC__)
1172   // bionic and glibc have different behaviors when len is too small
1173   ASSERT_EQ(-1, getdomainname(buf, strlen(u.domainname)));
1174   EXPECT_EQ(EINVAL, errno);
1175 #endif
1176 }
1177
1178 TEST(UNISTD_TEST, setdomainname) {
1179   __user_cap_header_struct header;
1180   memset(&header, 0, sizeof(header));
1181   header.version = _LINUX_CAPABILITY_VERSION_3;
1182
1183   __user_cap_data_struct old_caps[_LINUX_CAPABILITY_U32S_3];
1184   ASSERT_EQ(0, capget(&header, &old_caps[0]));
1185
1186   auto admin_idx = CAP_TO_INDEX(CAP_SYS_ADMIN);
1187   auto admin_mask = CAP_TO_MASK(CAP_SYS_ADMIN);
1188   bool has_admin = old_caps[admin_idx].effective & admin_mask;
1189   if (has_admin) {
1190     __user_cap_data_struct new_caps[_LINUX_CAPABILITY_U32S_3];
1191     memcpy(new_caps, old_caps, sizeof(new_caps));
1192     new_caps[admin_idx].effective &= ~admin_mask;
1193
1194     ASSERT_EQ(0, capset(&header, &new_caps[0])) << "failed to drop admin privileges";
1195   }
1196
1197   const char* name = "newdomainname";
1198   ASSERT_EQ(-1, setdomainname(name, strlen(name)));
1199   ASSERT_EQ(EPERM, errno);
1200
1201   if (has_admin) {
1202     ASSERT_EQ(0, capset(&header, &old_caps[0])) << "failed to restore admin privileges";
1203   }
1204 }
1205
1206 #if defined(__GLIBC__)
1207 #define BIN_DIR "/bin/"
1208 #else
1209 #define BIN_DIR "/system/bin/"
1210 #endif
1211
1212 TEST(UNISTD_TEST, execve_failure) {
1213   ExecTestHelper eth;
1214   errno = 0;
1215   ASSERT_EQ(-1, execve("/", eth.GetArgs(), eth.GetEnv()));
1216   ASSERT_EQ(EACCES, errno);
1217 }
1218
1219 TEST(UNISTD_TEST, execve_args) {
1220   // int execve(const char* path, char* argv[], char* envp[]);
1221
1222   // Test basic argument passing.
1223   ExecTestHelper eth;
1224   eth.SetArgs({"echo", "hello", "world", nullptr});
1225   eth.Run([&]() { execve(BIN_DIR "echo", eth.GetArgs(), eth.GetEnv()); }, 0, "hello world\n");
1226
1227   // Test environment variable setting too.
1228   eth.SetArgs({"printenv", nullptr});
1229   eth.SetEnv({"A=B", nullptr});
1230   eth.Run([&]() { execve(BIN_DIR "printenv", eth.GetArgs(), eth.GetEnv()); }, 0, "A=B\n");
1231 }
1232
1233 TEST(UNISTD_TEST, execl_failure) {
1234   errno = 0;
1235   ASSERT_EQ(-1, execl("/", "/", nullptr));
1236   ASSERT_EQ(EACCES, errno);
1237 }
1238
1239 TEST(UNISTD_TEST, execl) {
1240   ExecTestHelper eth;
1241   // int execl(const char* path, const char* arg, ...);
1242   eth.Run([&]() { execl(BIN_DIR "echo", "echo", "hello", "world", nullptr); }, 0, "hello world\n");
1243 }
1244
1245 TEST(UNISTD_TEST, execle_failure) {
1246   ExecTestHelper eth;
1247   errno = 0;
1248   ASSERT_EQ(-1, execle("/", "/", nullptr, eth.GetEnv()));
1249   ASSERT_EQ(EACCES, errno);
1250 }
1251
1252 TEST(UNISTD_TEST, execle) {
1253   ExecTestHelper eth;
1254   eth.SetEnv({"A=B", nullptr});
1255   // int execle(const char* path, const char* arg, ..., char* envp[]);
1256   eth.Run([&]() { execle(BIN_DIR "printenv", "printenv", nullptr, eth.GetEnv()); }, 0, "A=B\n");
1257 }
1258
1259 TEST(UNISTD_TEST, execv_failure) {
1260   ExecTestHelper eth;
1261   errno = 0;
1262   ASSERT_EQ(-1, execv("/", eth.GetArgs()));
1263   ASSERT_EQ(EACCES, errno);
1264 }
1265
1266 TEST(UNISTD_TEST, execv) {
1267   ExecTestHelper eth;
1268   eth.SetArgs({"echo", "hello", "world", nullptr});
1269   // int execv(const char* path, char* argv[]);
1270   eth.Run([&]() { execv(BIN_DIR "echo", eth.GetArgs()); }, 0, "hello world\n");
1271 }
1272
1273 TEST(UNISTD_TEST, execlp_failure) {
1274   errno = 0;
1275   ASSERT_EQ(-1, execlp("/", "/", nullptr));
1276   ASSERT_EQ(EACCES, errno);
1277 }
1278
1279 TEST(UNISTD_TEST, execlp) {
1280   ExecTestHelper eth;
1281   // int execlp(const char* file, const char* arg, ...);
1282   eth.Run([&]() { execlp("echo", "echo", "hello", "world", nullptr); }, 0, "hello world\n");
1283 }
1284
1285 TEST(UNISTD_TEST, execvp_failure) {
1286   ExecTestHelper eth;
1287   eth.SetArgs({nullptr});
1288   errno = 0;
1289   ASSERT_EQ(-1, execvp("/", eth.GetArgs()));
1290   ASSERT_EQ(EACCES, errno);
1291 }
1292
1293 TEST(UNISTD_TEST, execvp) {
1294   ExecTestHelper eth;
1295   eth.SetArgs({"echo", "hello", "world", nullptr});
1296   // int execvp(const char* file, char* argv[]);
1297   eth.Run([&]() { execvp("echo", eth.GetArgs()); }, 0, "hello world\n");
1298 }
1299
1300 TEST(UNISTD_TEST, execvpe_failure) {
1301   ExecTestHelper eth;
1302   errno = 0;
1303   ASSERT_EQ(-1, execvpe("this-does-not-exist", eth.GetArgs(), eth.GetEnv()));
1304   // Running in CTS we might not even be able to search all directories in $PATH.
1305   ASSERT_TRUE(errno == ENOENT || errno == EACCES);
1306 }
1307
1308 TEST(UNISTD_TEST, execvpe) {
1309   // int execvpe(const char* file, char* argv[], char* envp[]);
1310
1311   // Test basic argument passing.
1312   ExecTestHelper eth;
1313   eth.SetArgs({"echo", "hello", "world", nullptr});
1314   eth.Run([&]() { execvpe("echo", eth.GetArgs(), eth.GetEnv()); }, 0, "hello world\n");
1315
1316   // Test environment variable setting too.
1317   eth.SetArgs({"printenv", nullptr});
1318   eth.SetEnv({"A=B", nullptr});
1319   eth.Run([&]() { execvpe("printenv", eth.GetArgs(), eth.GetEnv()); }, 0, "A=B\n");
1320 }
1321
1322 TEST(UNISTD_TEST, execvpe_ENOEXEC) {
1323   // Create a shell script with #!.
1324   TemporaryFile tf;
1325   ASSERT_TRUE(android::base::WriteStringToFile("#!" BIN_DIR "sh\necho script\n", tf.filename));
1326
1327   // Set $PATH so we can find it.
1328   setenv("PATH", dirname(tf.filename), 1);
1329
1330   ExecTestHelper eth;
1331   eth.SetArgs({basename(tf.filename), nullptr});
1332
1333   // It's not inherently executable.
1334   errno = 0;
1335   ASSERT_EQ(-1, execvpe(basename(tf.filename), eth.GetArgs(), eth.GetEnv()));
1336   ASSERT_EQ(EACCES, errno);
1337
1338   // Make it executable (and keep it writable because we're going to rewrite it below).
1339   ASSERT_EQ(0, chmod(tf.filename, 0777));
1340
1341   // TemporaryFile will have a writable fd, so we can test ETXTBSY while we're here...
1342   errno = 0;
1343   ASSERT_EQ(-1, execvpe(basename(tf.filename), eth.GetArgs(), eth.GetEnv()));
1344   ASSERT_EQ(ETXTBSY, errno);
1345
1346   // 1. The simplest test: the kernel should handle this.
1347   ASSERT_EQ(0, close(tf.fd));
1348   eth.Run([&]() { execvpe(basename(tf.filename), eth.GetArgs(), eth.GetEnv()); }, 0, "script\n");
1349
1350   // 2. Try again without a #!. We should have to handle this ourselves.
1351   ASSERT_TRUE(android::base::WriteStringToFile("echo script\n", tf.filename));
1352   eth.Run([&]() { execvpe(basename(tf.filename), eth.GetArgs(), eth.GetEnv()); }, 0, "script\n");
1353
1354   // 3. Again without a #!, but also with a leading '/', since that's a special case in the
1355   // implementation.
1356   eth.Run([&]() { execvpe(tf.filename, eth.GetArgs(), eth.GetEnv()); }, 0, "script\n");
1357 }
1358
1359 TEST(UNISTD_TEST, execvp_libcore_test_55017) {
1360   ExecTestHelper eth;
1361   eth.SetArgs({"/system/bin/does-not-exist", nullptr});
1362
1363   errno = 0;
1364   ASSERT_EQ(-1, execvp("/system/bin/does-not-exist", eth.GetArgs()));
1365   ASSERT_EQ(ENOENT, errno);
1366 }
1367
1368 TEST(UNISTD_TEST, exec_argv0_null) {
1369   // http://b/33276926
1370   char* args[] = {nullptr};
1371   char* envs[] = {nullptr};
1372   ASSERT_EXIT(execve("/system/bin/run-as", args, envs), testing::ExitedWithCode(1),
1373               "<unknown>: usage: run-as");
1374 }