Merge "Move all logging to use the async safe logging." (d673da4b) · Commits · e / os / android_system_core

libmemunreachable/.clang-format

0 → 120000

+1 −0

Original line number	Original line	Diff line number	Diff line
			../.clang-format-2
			No newline at end of file

libmemunreachable/Android.bp

+9 −1

Original line number	Original line	Diff line number	Diff line
	@@ -9,8 +9,16 @@ cc_defaults {
	clang: true,		clang: true,
	shared_libs: [		shared_libs: [
	"libbase",		"libbase",
	"liblog",
	],		],

			target: {
			android: {
			static_libs: ["libasync_safe"],
			},
			host: {
			shared_libs: ["liblog"],
			}
			},
	}		}

	cc_library_shared {		cc_library_shared {

libmemunreachable/HeapWalker.cpp

+5 −7

Original line number	Original line	Diff line number	Diff line
	@@ -42,10 +42,8 @@ bool HeapWalker::Allocation(uintptr_t begin, uintptr_t end) {
	} else {		} else {
	Range overlap = inserted.first->first;		Range overlap = inserted.first->first;
	if (overlap != range) {		if (overlap != range) {
	ALOGE("range %p-%p overlaps with existing range %p-%p",		MEM_ALOGE("range %p-%p overlaps with existing range %p-%p", reinterpret_cast<void*>(begin),
	reinterpret_cast<void*>(begin),		reinterpret_cast<void>(end), reinterpret_cast<void>(overlap.begin),
	reinterpret_cast<void*>(end),
	reinterpret_cast<void*>(overlap.begin),
	reinterpret_cast<void*>(overlap.end));		reinterpret_cast<void*>(overlap.end));
	}		}
	return false;		return false;
	@@ -154,7 +152,7 @@ static bool MapOverPage(void* addr) {

	void* ret = mmap(page, page_size, PROT_READ, MAP_ANONYMOUS\|MAP_PRIVATE\|MAP_FIXED, -1, 0);		void* ret = mmap(page, page_size, PROT_READ, MAP_ANONYMOUS\|MAP_PRIVATE\|MAP_FIXED, -1, 0);
	if (ret == MAP_FAILED) {		if (ret == MAP_FAILED) {
	ALOGE("failed to map page at %p: %s", page, strerror(errno));		MEM_ALOGE("failed to map page at %p: %s", page, strerror(errno));
	return false;		return false;
	}		}

	@@ -167,7 +165,7 @@ void HeapWalker::HandleSegFault(ScopedSignalHandler& handler, int signal, siginf
	handler.reset();		handler.reset();
	return;		return;
	}		}
	ALOGW("failed to read page at %p, signal %d", si->si_addr, signal);		MEM_ALOGW("failed to read page at %p, signal %d", si->si_addr, signal);
	if (!MapOverPage(si->si_addr)) {		if (!MapOverPage(si->si_addr)) {
	handler.reset();		handler.reset();
	}		}

libmemunreachable/LeakPipe.cpp

+5 −5

Original line number	Original line	Diff line number	Diff line
	@@ -44,11 +44,11 @@ bool LeakPipe::SendFd(int sock, int fd) {

	int ret = sendmsg(sock, &hdr, 0);		int ret = sendmsg(sock, &hdr, 0);
	if (ret < 0) {		if (ret < 0) {
	ALOGE("failed to send fd: %s", strerror(errno));		MEM_ALOGE("failed to send fd: %s", strerror(errno));
	return false;		return false;
	}		}
	if (ret == 0) {		if (ret == 0) {
	ALOGE("eof when sending fd");		MEM_ALOGE("eof when sending fd");
	return false;		return false;
	}		}

	@@ -71,17 +71,17 @@ int LeakPipe::ReceiveFd(int sock) {

	int ret = recvmsg(sock, &hdr, 0);		int ret = recvmsg(sock, &hdr, 0);
	if (ret < 0) {		if (ret < 0) {
	ALOGE("failed to receive fd: %s", strerror(errno));		MEM_ALOGE("failed to receive fd: %s", strerror(errno));
	return -1;		return -1;
	}		}
	if (ret == 0) {		if (ret == 0) {
	ALOGE("eof when receiving fd");		MEM_ALOGE("eof when receiving fd");
	return -1;		return -1;
	}		}

	struct cmsghdr* cmsg = CMSG_FIRSTHDR(&hdr);		struct cmsghdr* cmsg = CMSG_FIRSTHDR(&hdr);
	if (cmsg == NULL \|\| cmsg->cmsg_level != SOL_SOCKET \|\| cmsg->cmsg_type != SCM_RIGHTS) {		if (cmsg == NULL \|\| cmsg->cmsg_level != SOL_SOCKET \|\| cmsg->cmsg_type != SCM_RIGHTS) {
	ALOGE("missing fd while receiving fd");		MEM_ALOGE("missing fd while receiving fd");
	return -1;		return -1;
	}		}

libmemunreachable/LeakPipe.h

+9 −9

Original line number	Original line	Diff line number	Diff line
	@@ -36,7 +36,7 @@ class LeakPipe {
	LeakPipe() {		LeakPipe() {
	int ret = socketpair(AF_UNIX, SOCK_STREAM\|SOCK_CLOEXEC, 0, sv_);		int ret = socketpair(AF_UNIX, SOCK_STREAM\|SOCK_CLOEXEC, 0, sv_);
	if (ret < 0) {		if (ret < 0) {
	LOG_ALWAYS_FATAL("failed to create socketpair: %s", strerror(errno));		MEM_LOG_ALWAYS_FATAL("failed to create socketpair: %s", strerror(errno));
	}		}
	}		}

	@@ -105,10 +105,10 @@ class LeakPipe {
	bool Send(const T& value) {		bool Send(const T& value) {
	ssize_t ret = TEMP_FAILURE_RETRY(write(fd_, &value, sizeof(T)));		ssize_t ret = TEMP_FAILURE_RETRY(write(fd_, &value, sizeof(T)));
	if (ret < 0) {		if (ret < 0) {
	ALOGE("failed to send value: %s", strerror(errno));		MEM_ALOGE("failed to send value: %s", strerror(errno));
	return false;		return false;
	} else if (static_cast<size_t>(ret) != sizeof(T)) {		} else if (static_cast<size_t>(ret) != sizeof(T)) {
	ALOGE("eof while writing value");		MEM_ALOGE("eof while writing value");
	return false;		return false;
	}		}

	@@ -124,10 +124,10 @@ class LeakPipe {

	ssize_t ret = TEMP_FAILURE_RETRY(write(fd_, vector.data(), size));		ssize_t ret = TEMP_FAILURE_RETRY(write(fd_, vector.data(), size));
	if (ret < 0) {		if (ret < 0) {
	ALOGE("failed to send vector: %s", strerror(errno));		MEM_ALOGE("failed to send vector: %s", strerror(errno));
	return false;		return false;
	} else if (static_cast<size_t>(ret) != size) {		} else if (static_cast<size_t>(ret) != size) {
	ALOGE("eof while writing vector");		MEM_ALOGE("eof while writing vector");
	return false;		return false;
	}		}

	@@ -143,10 +143,10 @@ class LeakPipe {
	bool Receive(T* value) {		bool Receive(T* value) {
	ssize_t ret = TEMP_FAILURE_RETRY(read(fd_, reinterpret_cast<void*>(value), sizeof(T)));		ssize_t ret = TEMP_FAILURE_RETRY(read(fd_, reinterpret_cast<void*>(value), sizeof(T)));
	if (ret < 0) {		if (ret < 0) {
	ALOGE("failed to receive value: %s", strerror(errno));		MEM_ALOGE("failed to receive value: %s", strerror(errno));
	return false;		return false;
	} else if (static_cast<size_t>(ret) != sizeof(T)) {		} else if (static_cast<size_t>(ret) != sizeof(T)) {
	ALOGE("eof while receiving value");		MEM_ALOGE("eof while receiving value");
	return false;		return false;
	}		}

	@@ -166,10 +166,10 @@ class LeakPipe {
	while (size > 0) {		while (size > 0) {
	ssize_t ret = TEMP_FAILURE_RETRY(read(fd_, ptr, size));		ssize_t ret = TEMP_FAILURE_RETRY(read(fd_, ptr, size));
	if (ret < 0) {		if (ret < 0) {
	ALOGE("failed to send vector: %s", strerror(errno));		MEM_ALOGE("failed to send vector: %s", strerror(errno));
	return false;		return false;
	} else if (ret == 0) {		} else if (ret == 0) {
	ALOGE("eof while reading vector");		MEM_ALOGE("eof while reading vector");
	return false;		return false;
	}		}
	size -= ret;		size -= ret;