Merge "Add the optimized implementation of 18 math functions for x86 and x86_64 respectively"
diff --git a/libc/Android.mk b/libc/Android.mk
index cb1d8c0..293b70e 100644
--- a/libc/Android.mk
+++ b/libc/Android.mk
@@ -1324,6 +1324,10 @@
LOCAL_CFLAGS := $(libc_common_cflags)
LOCAL_CONLYFLAGS := $(libc_common_conlyflags)
LOCAL_CPPFLAGS := $(libc_common_cppflags)
+
+# TODO: This is to work around b/19059885. Remove after root cause is fixed
+LOCAL_LDFLAGS_arm := -Wl,--hash-style=both
+
LOCAL_C_INCLUDES := $(libc_common_c_includes)
LOCAL_SRC_FILES := \
$(libc_arch_dynamic_src_files) \
@@ -1474,6 +1478,10 @@
LOCAL_C_INCLUDES := $(libc_common_c_includes) bionic/libstdc++/include
LOCAL_CFLAGS := $(libc_common_cflags)
LOCAL_CPPFLAGS := $(libc_common_cppflags)
+
+# TODO: This is to work around b/19059885. Remove after root cause is fixed
+LOCAL_LDFLAGS_arm := -Wl,--hash-style=both
+
LOCAL_SRC_FILES := $(libstdcxx_common_src_files)
LOCAL_MODULE:= libstdc++
LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
diff --git a/libc/dns/resolv/res_send.c b/libc/dns/resolv/res_send.c
index 6439e31..a8da3ac 100644
--- a/libc/dns/resolv/res_send.c
+++ b/libc/dns/resolv/res_send.c
@@ -402,6 +402,10 @@
}
if (statp->nscount == 0) {
+ // We have no nameservers configured, so there's no point trying.
+ // Tell the cache the query failed, or any retries and anyone else asking the same
+ // question will block for PENDING_REQUEST_TIMEOUT seconds instead of failing fast.
+ _resolv_cache_query_failed(statp->netid, buf, buflen);
errno = ESRCH;
return (-1);
}
diff --git a/libc/include/sys/mount.h b/libc/include/sys/mount.h
index 3c35d31..fd7cf17 100644
--- a/libc/include/sys/mount.h
+++ b/libc/include/sys/mount.h
@@ -25,6 +25,7 @@
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
+
#ifndef _SYS_MOUNT_H
#define _SYS_MOUNT_H
@@ -35,9 +36,10 @@
__BEGIN_DECLS
/* umount2 flags. */
-#define MNT_FORCE 1 /* Forcibly unmount */
-#define MNT_DETACH 2 /* Detach from tree only */
-#define MNT_EXPIRE 4 /* Mark for expiry */
+#define MNT_FORCE 1
+#define MNT_DETACH 2
+#define MNT_EXPIRE 4
+#define UMOUNT_NOFOLLOW 8
extern int mount(const char*, const char*, const char*, unsigned long, const void*);
extern int umount(const char*);
diff --git a/libc/include/syslog.h b/libc/include/syslog.h
index cbceab2..8000f03 100644
--- a/libc/include/syslog.h
+++ b/libc/include/syslog.h
@@ -47,6 +47,7 @@
#define LOG_PRIMASK 7
#define LOG_PRI(x) ((x) & LOG_PRIMASK)
+#define LOG_MAKEPRI(fac, pri) ((fac) | (pri))
/* Facilities are currently ignored on Android. */
#define LOG_KERN 0000
diff --git a/libm/Android.mk b/libm/Android.mk
index 565d3fd..529dda8 100644
--- a/libm/Android.mk
+++ b/libm/Android.mk
@@ -513,6 +513,9 @@
# -----------------------------------------------------------------------------
include $(CLEAR_VARS)
+# TODO: This is to work around b/19059885. Remove after root cause is fixed
+LOCAL_LDFLAGS_arm := -Wl,--hash-style=both
+
LOCAL_MODULE := libm
LOCAL_CLANG := $(libm_clang)
LOCAL_SYSTEM_SHARED_LIBRARIES := libc
diff --git a/linker/Android.mk b/linker/Android.mk
index 54535fc..0ab0fda 100644
--- a/linker/Android.mk
+++ b/linker/Android.mk
@@ -6,7 +6,7 @@
debugger.cpp \
dlfcn.cpp \
linker.cpp \
- linker_allocator.cpp \
+ linker_block_allocator.cpp \
linker_environ.cpp \
linker_libc_support.c \
linker_phdr.cpp \
diff --git a/linker/linker.cpp b/linker/linker.cpp
index 9ba83ec..ea7d637 100644
--- a/linker/linker.cpp
+++ b/linker/linker.cpp
@@ -50,7 +50,7 @@
#include "private/UniquePtr.h"
#include "linker.h"
-#include "linker_allocator.h"
+#include "linker_block_allocator.h"
#include "linker_debug.h"
#include "linker_environ.h"
#include "linker_leb128.h"
@@ -92,8 +92,8 @@
static ElfW(Addr) get_elf_exec_load_bias(const ElfW(Ehdr)* elf);
-static LinkerAllocator<soinfo> g_soinfo_allocator;
-static LinkerAllocator<LinkedListEntry<soinfo>> g_soinfo_links_allocator;
+static LinkerTypeAllocator<soinfo> g_soinfo_allocator;
+static LinkerTypeAllocator<LinkedListEntry<soinfo>> g_soinfo_links_allocator;
static soinfo* solist;
static soinfo* sonext;
@@ -421,26 +421,41 @@
uint32_t word_num = (hash / bloom_mask_bits) & gnu_maskwords_;
ElfW(Addr) bloom_word = gnu_bloom_filter_[word_num];
+ TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p (gnu)",
+ symbol_name.get_name(), name, reinterpret_cast<void*>(base));
+
// test against bloom filter
if ((1 & (bloom_word >> (hash % bloom_mask_bits)) & (bloom_word >> (h2 % bloom_mask_bits))) == 0) {
+ TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p",
+ symbol_name.get_name(), name, reinterpret_cast<void*>(base));
+
return nullptr;
}
// bloom test says "probably yes"...
- uint32_t n = bucket_[hash % nbucket_];
+ uint32_t n = gnu_bucket_[hash % gnu_nbucket_];
if (n == 0) {
+ TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p",
+ symbol_name.get_name(), name, reinterpret_cast<void*>(base));
+
return nullptr;
}
do {
ElfW(Sym)* s = symtab_ + n;
- if (((chain_[n] ^ hash) >> 1) == 0 &&
+ if (((gnu_chain_[n] ^ hash) >> 1) == 0 &&
strcmp(get_string(s->st_name), symbol_name.get_name()) == 0 &&
is_symbol_global_and_defined(this, s)) {
+ TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd",
+ symbol_name.get_name(), name, reinterpret_cast<void*>(s->st_value),
+ static_cast<size_t>(s->st_size));
return s;
}
- } while ((chain_[n++] & 1) == 0);
+ } while ((gnu_chain_[n++] & 1) == 0);
+
+ TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p",
+ symbol_name.get_name(), name, reinterpret_cast<void*>(base));
return nullptr;
}
@@ -802,8 +817,8 @@
ElfW(Sym)* soinfo::gnu_addr_lookup(const void* addr) {
ElfW(Addr) soaddr = reinterpret_cast<ElfW(Addr)>(addr) - load_bias;
- for (size_t i = 0; i < nbucket_; ++i) {
- uint32_t n = bucket_[i];
+ for (size_t i = 0; i < gnu_nbucket_; ++i) {
+ uint32_t n = gnu_bucket_[i];
if (n == 0) {
continue;
@@ -814,7 +829,7 @@
if (symbol_matches_soaddr(sym, soaddr)) {
return sym;
}
- } while ((chain_[n++] & 1) == 0);
+ } while ((gnu_chain_[n++] & 1) == 0);
}
return nullptr;
@@ -1941,11 +1956,6 @@
break;
case DT_HASH:
- if (nbucket_ != 0) {
- // in case of --hash-style=both, we prefer gnu
- break;
- }
-
nbucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[0];
nchain_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[1];
bucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr + 8);
@@ -1953,20 +1963,15 @@
break;
case DT_GNU_HASH:
- if (nbucket_ != 0) {
- // in case of --hash-style=both, we prefer gnu
- nchain_ = 0;
- }
-
- nbucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[0];
+ gnu_nbucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[0];
// skip symndx
gnu_maskwords_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[2];
gnu_shift2_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[3];
gnu_bloom_filter_ = reinterpret_cast<ElfW(Addr)*>(load_bias + d->d_un.d_ptr + 16);
- bucket_ = reinterpret_cast<uint32_t*>(gnu_bloom_filter_ + gnu_maskwords_);
+ gnu_bucket_ = reinterpret_cast<uint32_t*>(gnu_bloom_filter_ + gnu_maskwords_);
// amend chain for symndx = header[1]
- chain_ = bucket_ + nbucket_ - reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[1];
+ gnu_chain_ = gnu_bucket_ + gnu_nbucket_ - reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[1];
if (!powerof2(gnu_maskwords_)) {
DL_ERR("invalid maskwords for gnu_hash = 0x%x, in \"%s\" expecting power to two", gnu_maskwords_, name);
@@ -2278,7 +2283,7 @@
DL_ERR("linker cannot have DT_NEEDED dependencies on other libraries");
return false;
}
- if (nbucket_ == 0) {
+ if (nbucket_ == 0 && gnu_nbucket_ == 0) {
DL_ERR("empty/missing DT_HASH/DT_GNU_HASH in \"%s\" (new hash type from the future?)", name);
return false;
}
diff --git a/linker/linker.h b/linker/linker.h
index f8640a0..e4681eb 100644
--- a/linker/linker.h
+++ b/linker/linker.h
@@ -309,6 +309,10 @@
size_t strtab_size_;
// version >= 2
+
+ size_t gnu_nbucket_;
+ uint32_t* gnu_bucket_;
+ uint32_t* gnu_chain_;
uint32_t gnu_maskwords_;
uint32_t gnu_shift2_;
ElfW(Addr)* gnu_bloom_filter_;
diff --git a/linker/linker_allocator.cpp b/linker/linker_block_allocator.cpp
similarity index 81%
rename from linker/linker_allocator.cpp
rename to linker/linker_block_allocator.cpp
index ac11b97..fc9a75b 100644
--- a/linker/linker_allocator.cpp
+++ b/linker/linker_block_allocator.cpp
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-#include "linker_allocator.h"
+#include "linker_block_allocator.h"
#include <inttypes.h>
#include <string.h>
#include <sys/mman.h>
@@ -22,9 +22,9 @@
#include "private/bionic_prctl.h"
-struct LinkerAllocatorPage {
- LinkerAllocatorPage* next;
- uint8_t bytes[PAGE_SIZE-sizeof(LinkerAllocatorPage*)];
+struct LinkerBlockAllocatorPage {
+ LinkerBlockAllocatorPage* next;
+ uint8_t bytes[PAGE_SIZE-sizeof(LinkerBlockAllocatorPage*)];
};
struct FreeBlockInfo {
@@ -64,7 +64,7 @@
return;
}
- LinkerAllocatorPage* page = find_page(block);
+ LinkerBlockAllocatorPage* page = find_page(block);
if (page == nullptr) {
abort();
@@ -87,7 +87,7 @@
}
void LinkerBlockAllocator::protect_all(int prot) {
- for (LinkerAllocatorPage* page = page_list_; page != nullptr; page = page->next) {
+ for (LinkerBlockAllocatorPage* page = page_list_; page != nullptr; page = page->next) {
if (mprotect(page, PAGE_SIZE, prot) == -1) {
abort();
}
@@ -95,8 +95,9 @@
}
void LinkerBlockAllocator::create_new_page() {
- LinkerAllocatorPage* page = reinterpret_cast<LinkerAllocatorPage*>(mmap(nullptr, PAGE_SIZE,
- PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0));
+ LinkerBlockAllocatorPage* page = reinterpret_cast<LinkerBlockAllocatorPage*>(
+ mmap(nullptr, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0));
+
if (page == MAP_FAILED) {
abort(); // oom
}
@@ -107,7 +108,7 @@
FreeBlockInfo* first_block = reinterpret_cast<FreeBlockInfo*>(page->bytes);
first_block->next_block = free_block_list_;
- first_block->num_free_blocks = (PAGE_SIZE - sizeof(LinkerAllocatorPage*))/block_size_;
+ first_block->num_free_blocks = (PAGE_SIZE - sizeof(LinkerBlockAllocatorPage*))/block_size_;
free_block_list_ = first_block;
@@ -115,12 +116,12 @@
page_list_ = page;
}
-LinkerAllocatorPage* LinkerBlockAllocator::find_page(void* block) {
+LinkerBlockAllocatorPage* LinkerBlockAllocator::find_page(void* block) {
if (block == nullptr) {
abort();
}
- LinkerAllocatorPage* page = page_list_;
+ LinkerBlockAllocatorPage* page = page_list_;
while (page != nullptr) {
const uint8_t* page_ptr = reinterpret_cast<const uint8_t*>(page);
if (block >= (page_ptr + sizeof(page->next)) && block < (page_ptr + PAGE_SIZE)) {
diff --git a/linker/linker_allocator.h b/linker/linker_block_allocator.h
similarity index 87%
rename from linker/linker_allocator.h
rename to linker/linker_block_allocator.h
index 5d3563f..1d41806 100644
--- a/linker/linker_allocator.h
+++ b/linker/linker_block_allocator.h
@@ -21,7 +21,7 @@
#include <limits.h>
#include "private/bionic_macros.h"
-struct LinkerAllocatorPage;
+struct LinkerBlockAllocatorPage;
/*
* This class is a non-template version of the LinkerAllocator
@@ -40,10 +40,10 @@
private:
void create_new_page();
- LinkerAllocatorPage* find_page(void* block);
+ LinkerBlockAllocatorPage* find_page(void* block);
size_t block_size_;
- LinkerAllocatorPage* page_list_;
+ LinkerBlockAllocatorPage* page_list_;
void* free_block_list_;
DISALLOW_COPY_AND_ASSIGN(LinkerBlockAllocator);
@@ -57,14 +57,15 @@
* anonymous mmaps.
*/
template<typename T>
-class LinkerAllocator {
+class LinkerTypeAllocator {
public:
- LinkerAllocator() : block_allocator_(sizeof(T)) {}
+ LinkerTypeAllocator() : block_allocator_(sizeof(T)) {}
T* alloc() { return reinterpret_cast<T*>(block_allocator_.alloc()); }
void free(T* t) { block_allocator_.free(t); }
void protect_all(int prot) { block_allocator_.protect_all(prot); }
private:
LinkerBlockAllocator block_allocator_;
- DISALLOW_COPY_AND_ASSIGN(LinkerAllocator);
+ DISALLOW_COPY_AND_ASSIGN(LinkerTypeAllocator);
};
+
#endif // __LINKER_ALLOCATOR_H
diff --git a/linker/tests/Android.mk b/linker/tests/Android.mk
index aa9491e..9a08bec 100644
--- a/linker/tests/Android.mk
+++ b/linker/tests/Android.mk
@@ -28,7 +28,7 @@
LOCAL_SRC_FILES := \
linked_list_test.cpp \
- linker_allocator_test.cpp \
- ../linker_allocator.cpp
+ linker_block_allocator_test.cpp \
+ ../linker_block_allocator.cpp
include $(BUILD_NATIVE_TEST)
diff --git a/linker/tests/linker_allocator_test.cpp b/linker/tests/linker_block_allocator_test.cpp
similarity index 92%
rename from linker/tests/linker_allocator_test.cpp
rename to linker/tests/linker_block_allocator_test.cpp
index 9292a05..3ef0f36 100644
--- a/linker/tests/linker_allocator_test.cpp
+++ b/linker/tests/linker_block_allocator_test.cpp
@@ -20,7 +20,7 @@
#include <gtest/gtest.h>
-#include "../linker_allocator.h"
+#include "../linker_block_allocator.h"
#include <unistd.h>
@@ -49,7 +49,7 @@
};
TEST(linker_allocator, test_nominal) {
- LinkerAllocator<test_struct_nominal> allocator;
+ LinkerTypeAllocator<test_struct_nominal> allocator;
test_struct_nominal* ptr1 = allocator.alloc();
ASSERT_TRUE(ptr1 != nullptr);
@@ -65,7 +65,7 @@
}
TEST(linker_allocator, test_small) {
- LinkerAllocator<test_struct_small> allocator;
+ LinkerTypeAllocator<test_struct_small> allocator;
char* ptr1 = reinterpret_cast<char*>(allocator.alloc());
char* ptr2 = reinterpret_cast<char*>(allocator.alloc());
@@ -76,7 +76,7 @@
}
TEST(linker_allocator, test_larger) {
- LinkerAllocator<test_struct_larger> allocator;
+ LinkerTypeAllocator<test_struct_larger> allocator;
test_struct_larger* ptr1 = allocator.alloc();
test_struct_larger* ptr2 = allocator.alloc();
@@ -99,7 +99,7 @@
}
static void protect_all() {
- LinkerAllocator<test_struct_larger> allocator;
+ LinkerTypeAllocator<test_struct_larger> allocator;
// number of allocs to reach the end of first page
size_t n = kPageSize/sizeof(test_struct_larger) - 1;
diff --git a/tests/gtest_main.cpp b/tests/gtest_main.cpp
index b1953fc..bf2b695 100644
--- a/tests/gtest_main.cpp
+++ b/tests/gtest_main.cpp
@@ -741,7 +741,8 @@
// We choose to use multi-fork and multi-wait here instead of multi-thread, because it always
// makes deadlock to use fork in multi-thread.
-static void RunTestInSeparateProc(int argc, char** argv, std::vector<TestCase>& testcase_list,
+// Returns true if all tests run successfully, otherwise return false.
+static bool RunTestInSeparateProc(int argc, char** argv, std::vector<TestCase>& testcase_list,
size_t iteration_count, size_t job_count,
const std::string& xml_output_filename) {
// Stop default result printer to avoid environment setup/teardown information for each test.
@@ -759,6 +760,8 @@
exit(1);
}
+ bool all_tests_passed = true;
+
for (size_t iteration = 1; iteration <= iteration_count; ++iteration) {
OnTestIterationStartPrint(testcase_list, iteration, iteration_count);
int64_t iteration_start_time_ns = NanoTime();
@@ -806,6 +809,9 @@
if (++finished_test_count_list[testcase_id] == testcase.TestCount()) {
++finished_testcase_count;
}
+ if (testcase.GetTestResult(test_id) != TEST_SUCCESS) {
+ all_tests_passed = false;
+ }
it = child_proc_list.erase(it);
} else {
@@ -827,6 +833,8 @@
perror("sigprocmask SIG_SETMASK");
exit(1);
}
+
+ return all_tests_passed;
}
static size_t GetProcessorCount() {
@@ -1061,15 +1069,15 @@
if (EnumerateTests(argc, arg_list.data(), testcase_list) == false) {
return 1;
}
- RunTestInSeparateProc(argc, arg_list.data(), testcase_list, options.gtest_repeat,
- options.job_count, options.gtest_output);
+ bool all_test_passed = RunTestInSeparateProc(argc, arg_list.data(), testcase_list,
+ options.gtest_repeat, options.job_count, options.gtest_output);
+ return all_test_passed ? 0 : 1;
} else {
argc = static_cast<int>(arg_list.size());
arg_list.push_back(NULL);
testing::InitGoogleTest(&argc, arg_list.data());
return RUN_ALL_TESTS();
}
- return 0;
}
//################################################################################
diff --git a/tests/sys_stat_test.cpp b/tests/sys_stat_test.cpp
index 28c7c52..7c387ba 100644
--- a/tests/sys_stat_test.cpp
+++ b/tests/sys_stat_test.cpp
@@ -138,13 +138,18 @@
#endif
}
+static void AssertFileModeEquals(mode_t expected_mode, const char* filename) {
+ struct stat sb;
+ ASSERT_EQ(0, stat(filename, &sb));
+ mode_t mask = S_IRWXU | S_IRWXG | S_IRWXO;
+ ASSERT_EQ(expected_mode & mask, static_cast<mode_t>(sb.st_mode) & mask);
+}
+
TEST(sys_stat, fchmodat_file) {
TemporaryFile tf;
- struct stat sb;
ASSERT_EQ(0, fchmodat(AT_FDCWD, tf.filename, 0751, 0));
- ASSERT_EQ(0, fstat(tf.fd, &sb));
- ASSERT_TRUE(0751 == (sb.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO)));
+ AssertFileModeEquals(0751, tf.filename);
}
TEST(sys_stat, fchmodat_AT_SYMLINK_NOFOLLOW_file) {
@@ -153,11 +158,9 @@
int result = fchmodat(AT_FDCWD, tf.filename, 0751, AT_SYMLINK_NOFOLLOW);
#if defined(__BIONIC__)
- struct stat sb;
ASSERT_EQ(0, result);
ASSERT_EQ(0, errno);
- ASSERT_EQ(0, fstat(tf.fd, &sb));
- ASSERT_TRUE(0751 == (sb.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO)));
+ AssertFileModeEquals(0751, tf.filename);
#else
// glibc 2.19 does not implement AT_SYMLINK_NOFOLLOW and always
// returns ENOTSUP
@@ -169,14 +172,12 @@
TEST(sys_stat, fchmodat_symlink) {
TemporaryFile tf;
char linkname[255];
- struct stat sb;
snprintf(linkname, sizeof(linkname), "%s.link", tf.filename);
ASSERT_EQ(0, symlink(tf.filename, linkname));
ASSERT_EQ(0, fchmodat(AT_FDCWD, linkname, 0751, 0));
- ASSERT_EQ(0, fstat(tf.fd, &sb));
- ASSERT_TRUE(0751 == (sb.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO)));
+ AssertFileModeEquals(0751, tf.filename);
unlink(linkname);
}
@@ -194,29 +195,54 @@
unlink(linkname);
}
+static void AssertSymlinkModeEquals(mode_t expected_mode, const char* linkname) {
+ struct stat sb;
+ ASSERT_EQ(0, fstatat(AT_FDCWD, linkname, &sb, AT_SYMLINK_NOFOLLOW));
+ mode_t mask = S_IRWXU | S_IRWXG | S_IRWXO;
+ ASSERT_EQ(expected_mode & mask, static_cast<mode_t>(sb.st_mode) & mask);
+}
+
TEST(sys_stat, fchmodat_AT_SYMLINK_NOFOLLOW_with_symlink) {
TemporaryFile tf;
- char linkname[255];
+ struct stat tf_sb;
+ ASSERT_EQ(0, stat(tf.filename, &tf_sb));
+ char linkname[255];
snprintf(linkname, sizeof(linkname), "%s.link", tf.filename);
ASSERT_EQ(0, symlink(tf.filename, linkname));
- ASSERT_EQ(-1, fchmodat(AT_FDCWD, linkname, 0751, AT_SYMLINK_NOFOLLOW));
- ASSERT_EQ(ENOTSUP, errno);
+ int result = fchmodat(AT_FDCWD, linkname, 0751, AT_SYMLINK_NOFOLLOW);
+ // It depends on the kernel whether chmod operation on symlink is allowed.
+ if (result == 0) {
+ AssertSymlinkModeEquals(0751, linkname);
+ } else {
+ ASSERT_EQ(-1, result);
+ ASSERT_EQ(ENOTSUP, errno);
+ }
+
+ // Target file mode shouldn't be modified.
+ AssertFileModeEquals(tf_sb.st_mode, tf.filename);
unlink(linkname);
}
TEST(sys_stat, fchmodat_AT_SYMLINK_NOFOLLOW_with_dangling_symlink) {
TemporaryFile tf;
+
char linkname[255];
char target[255];
-
snprintf(linkname, sizeof(linkname), "%s.link", tf.filename);
snprintf(target, sizeof(target), "%s.doesnotexist", tf.filename);
ASSERT_EQ(0, symlink(target, linkname));
- ASSERT_EQ(-1, fchmodat(AT_FDCWD, linkname, 0751, AT_SYMLINK_NOFOLLOW));
- ASSERT_EQ(ENOTSUP, errno);
+ int result = fchmodat(AT_FDCWD, linkname, 0751, AT_SYMLINK_NOFOLLOW);
+ // It depends on the kernel whether chmod operation on symlink is allowed.
+ if (result == 0) {
+ AssertSymlinkModeEquals(0751, linkname);
+ } else {
+ ASSERT_EQ(-1, result);
+ ASSERT_EQ(ENOTSUP, errno);
+ }
+
unlink(linkname);
}