unistd_test.cpp revision 5891abdc66aa9578395bc8b8e5740f629a2694b7 
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
33static void* get_brk() {
34  return sbrk(0);
35}
36
37static 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
42TEST(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
55TEST(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
68TEST(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
139TEST(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
149TEST(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
159TEST(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
169TEST(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
179TEST(unistd, ftruncate_negative) {
180  TemporaryFile tf;
181  errno = 0;
182  ASSERT_EQ(-1, ftruncate(tf.fd, -123));
183  ASSERT_EQ(EINVAL, errno);
184}
185
186static bool g_pause_test_flag = false;
187static void PauseTestSignalHandler(int) {
188  g_pause_test_flag = true;
189}
190
191TEST(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
200TEST(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
214TEST(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
222TEST(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
230TEST(unistd, alarm) {
231  ASSERT_EQ(0U, alarm(0));
232}
233
234TEST(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
248TEST(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
255TEST(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
262TEST(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
277TEST(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
303TEST(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
324TEST(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
354static 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
389TEST(unistd, fdatasync) {
390  TestFsyncFunction(fdatasync);
391}
392
393TEST(unistd, fsync) {
394  TestFsyncFunction(fsync);
395}
396
397static 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
405static 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
427TEST(unistd, getpid_caching_and_fork) {
428  TestGetPidCachingWithFork(fork);
429}
430
431TEST(unistd, getpid_caching_and_vfork) {
432  TestGetPidCachingWithFork(vfork);
433}
434
435static int GetPidCachingCloneStartRoutine(void*) {
436  AssertGetPidCorrect();
437  return 123;
438}
439
440TEST(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
460static void* GetPidCachingPthreadStartRoutine(void*) {
461  AssertGetPidCorrect();
462  return NULL;
463}
464
465TEST(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
478class unistd_DeathTest : public BionicDeathTest {};
479
480TEST_F(unistd_DeathTest, abort) {
481  ASSERT_EXIT(abort(), testing::KilledBySignal(SIGABRT), "");
482}
483
484TEST(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
492TEST(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
515TEST(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
536TEST(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
668static 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
675TEST(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
822TEST(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}
840