Merge changes If7fa11e7,I345c9a5d (a5a6c0a0) · Commits · e / os / android_system_core

liblog/Android.bp

+0 −1

Original line number	Diff line number	Diff line
		@@ -17,7 +17,6 @@
		liblog_sources = [
		"log_event_list.cpp",
		"log_event_write.cpp",
		"logger_lock.cpp",
		"logger_name.cpp",
		"logger_read.cpp",
		"logger_write.cpp",

liblog/fake_log_device.cpp

+12 −25

Original line number	Diff line number	Diff line
		@@ -48,21 +48,16 @@
		#define TRACE(...) ((void)0)
		#endif

		static int FakeAvailable(log_id_t);
		static int FakeOpen();
		static void FakeClose();
		static int FakeWrite(log_id_t log_id, struct timespec* ts, struct iovec* vec, size_t nr);

		struct android_log_transport_write fakeLoggerWrite = {
		.name = "fake",
		.logMask = 0,
		.available = FakeAvailable,
		.open = FakeOpen,
		.close = FakeClose,
		.write = FakeWrite,
		};

		typedef struct LogState {
		bool initialized = false;
		/* global minimum priority */
		int global_min_priority;

		@@ -76,19 +71,8 @@ typedef struct LogState {
		} tagSet[kTagSetSize];
		} LogState;

		/*
		* Locking. Since we're emulating a device, we need to be prepared
		* to have multiple callers at the same time. This lock is used
		* to both protect the fd list and to prevent LogStates from being
		* freed out from under a user.
		*/
		std::mutex mutex;

		static LogState log_state;

		static int FakeAvailable(log_id_t) {
		return 0;
		}
		static std::mutex fake_log_mutex;

		/*
		* Configure logging based on ANDROID_LOG_TAGS environment variable. We
		@@ -103,8 +87,8 @@ static int FakeAvailable(log_id_t) {
		* We also want to check ANDROID_PRINTF_LOG to determine how the output
		* will look.
		*/
		int FakeOpen() {
		std::lock_guard guard{mutex};
		void InitializeLogStateLocked() {
		log_state.initialized = true;

		/* global min priority defaults to "info" level */
		log_state.global_min_priority = ANDROID_LOG_INFO;
		@@ -129,7 +113,7 @@ int FakeOpen() {
		}
		if (i == kMaxTagLen) {
		TRACE("ERROR: env tag too long (%d chars max)\n", kMaxTagLen - 1);
		return 0;
		return;
		}
		tagName[i] = '\0';

		@@ -180,7 +164,7 @@ int FakeOpen() {
		if (tags != '\0' && !isspace(tags)) {
		TRACE("ERROR: garbage in tag env; expected whitespace\n");
		TRACE(" env='%s'\n", tags);
		return 0;
		return;
		}
		}

		@@ -224,7 +208,6 @@ int FakeOpen() {
		}

		log_state.output_format = format;
		return 0;
		}

		/*
		@@ -474,7 +457,11 @@ static int FakeWrite(log_id_t log_id, struct timespec, struct iovec vector, si
		* Also guarantees that only one thread is in showLog() at a given
		* time (if it matters).
		*/
		std::lock_guard guard{mutex};
		auto lock = std::lock_guard{fake_log_mutex};

		if (!log_state.initialized) {
		InitializeLogStateLocked();
		}

		if (log_id == LOG_ID_EVENTS \|\| log_id == LOG_ID_STATS \|\| log_id == LOG_ID_SECURITY) {
		TRACE("%s: ignoring binary log\n", android_log_id_to_name(log_id));
		@@ -532,7 +519,7 @@ static int FakeWrite(log_id_t log_id, struct timespec, struct iovec vector, si
		* help debug HOST tools ...
		*/
		static void FakeClose() {
		std::lock_guard guard{mutex};
		auto lock = std::lock_guard{fake_log_mutex};

		memset(&log_state, 0, sizeof(log_state));
		}

liblog/logd_writer.cpp

+98 −143

Original line number	Diff line number	Diff line
		@@ -30,97 +30,76 @@
		#include <time.h>
		#include <unistd.h>

		#include <shared_mutex>

		#include <cutils/sockets.h>
		#include <private/android_filesystem_config.h>
		#include <private/android_logger.h>

		#include "log_portability.h"
		#include "logger.h"
		#include "rwlock.h"
		#include "uio.h"

		static int logdAvailable(log_id_t LogId);
		static int logdOpen();
		static void logdClose();
		static int logdWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, size_t nr);
		static int LogdWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, size_t nr);
		static void LogdClose();

		struct android_log_transport_write logdLoggerWrite = {
		.name = "logd",
		.logMask = 0,
		.context.sock = -EBADF,
		.available = logdAvailable,
		.open = logdOpen,
		.close = logdClose,
		.write = logdWrite,
		.close = LogdClose,
		.write = LogdWrite,
		};

		/* log_init_lock assumed */
		static int logdOpen() {
		int i, ret = 0;
		static int logd_socket;
		static RwLock logd_socket_lock;

		i = atomic_load(&logdLoggerWrite.context.sock);
		if (i < 0) {
		int sock = TEMP_FAILURE_RETRY(socket(PF_UNIX, SOCK_DGRAM \| SOCK_CLOEXEC \| SOCK_NONBLOCK, 0));
		if (sock < 0) {
		ret = -errno;
		} else {
		struct sockaddr_un un;
		memset(&un, 0, sizeof(struct sockaddr_un));
		static void OpenSocketLocked() {
		logd_socket = TEMP_FAILURE_RETRY(socket(PF_UNIX, SOCK_DGRAM \| SOCK_CLOEXEC \| SOCK_NONBLOCK, 0));
		if (logd_socket <= 0) {
		return;
		}

		sockaddr_un un = {};
		un.sun_family = AF_UNIX;
		strcpy(un.sun_path, "/dev/socket/logdw");

		if (TEMP_FAILURE_RETRY(connect(sock, (struct sockaddr*)&un, sizeof(struct sockaddr_un))) <
		0) {
		ret = -errno;
		switch (ret) {
		case -ENOTCONN:
		case -ECONNREFUSED:
		case -ENOENT:
		i = atomic_exchange(&logdLoggerWrite.context.sock, ret);
		[[fallthrough]];
		default:
		break;
		}
		close(sock);
		} else {
		ret = atomic_exchange(&logdLoggerWrite.context.sock, sock);
		if ((ret >= 0) && (ret != sock)) {
		close(ret);
		}
		ret = 0;
		if (TEMP_FAILURE_RETRY(
		connect(logd_socket, reinterpret_cast<sockaddr*>(&un), sizeof(sockaddr_un))) < 0) {
		close(logd_socket);
		logd_socket = 0;
		}
		}
		}

		return ret;
		}

		static void __logdClose(int negative_errno) {
		int sock = atomic_exchange(&logdLoggerWrite.context.sock, negative_errno);
		if (sock >= 0) {
		close(sock);
		}
		static void OpenSocket() {
		auto lock = std::unique_lock{logd_socket_lock};
		if (logd_socket > 0) {
		// Someone raced us and opened the socket already.
		return;
		}

		static void logdClose() {
		__logdClose(-EBADF);
		OpenSocketLocked();
		}

		static int logdAvailable(log_id_t logId) {
		if (logId >= LOG_ID_MAX \|\| logId == LOG_ID_KERNEL) {
		return -EINVAL;
		static void ResetSocket(int old_socket) {
		auto lock = std::unique_lock{logd_socket_lock};
		if (old_socket != logd_socket) {
		// Someone raced us and reset the socket already.
		return;
		}
		if (atomic_load(&logdLoggerWrite.context.sock) < 0) {
		if (access("/dev/socket/logdw", W_OK) == 0) {
		return 0;
		close(logd_socket);
		logd_socket = 0;
		OpenSocketLocked();
		}
		return -EBADF;

		static void LogdClose() {
		auto lock = std::unique_lock{logd_socket_lock};
		if (logd_socket > 0) {
		close(logd_socket);
		}
		return 1;
		logd_socket = 0;
		}

		static int logdWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, size_t nr) {
		static int LogdWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, size_t nr) {
		ssize_t ret;
		int sock;
		static const unsigned headerLength = 1;
		struct iovec newVec[nr + headerLength];
		android_log_header_t header;
		@@ -128,13 +107,14 @@ static int logdWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, siz
		static atomic_int dropped;
		static atomic_int droppedSecurity;

		sock = atomic_load(&logdLoggerWrite.context.sock);
		if (sock < 0) switch (sock) {
		case -ENOTCONN:
		case -ECONNREFUSED:
		case -ENOENT:
		break;
		default:
		auto lock = std::shared_lock{logd_socket_lock};
		if (logd_socket <= 0) {
		lock.unlock();
		OpenSocket();
		lock.lock();
		}

		if (logd_socket <= 0) {
		return -EBADF;
		}

		@@ -155,7 +135,6 @@ static int logdWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, siz
		newVec[0].iov_base = (unsigned char*)&header;
		newVec[0].iov_len = sizeof(header);

		if (sock >= 0) {
		int32_t snapshot = atomic_exchange_explicit(&droppedSecurity, 0, memory_order_relaxed);
		if (snapshot) {
		android_log_event_int_t buffer;
		@@ -168,7 +147,7 @@ static int logdWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, siz
		newVec[headerLength].iov_base = &buffer;
		newVec[headerLength].iov_len = sizeof(buffer);

		ret = TEMP_FAILURE_RETRY(writev(sock, newVec, 2));
		ret = TEMP_FAILURE_RETRY(writev(logd_socket, newVec, 2));
		if (ret != (ssize_t)(sizeof(header) + sizeof(buffer))) {
		atomic_fetch_add_explicit(&droppedSecurity, snapshot, memory_order_relaxed);
		}
		@@ -186,12 +165,11 @@ static int logdWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, siz
		newVec[headerLength].iov_base = &buffer;
		newVec[headerLength].iov_len = sizeof(buffer);

		ret = TEMP_FAILURE_RETRY(writev(sock, newVec, 2));
		ret = TEMP_FAILURE_RETRY(writev(logd_socket, newVec, 2));
		if (ret != (ssize_t)(sizeof(header) + sizeof(buffer))) {
		atomic_fetch_add_explicit(&dropped, snapshot, memory_order_relaxed);
		}
		}
		}

		header.id = logId;

		@@ -208,49 +186,26 @@ static int logdWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, siz
		}
		}

		/*
		* The write below could be lost, but will never block.
		*
		* ENOTCONN occurs if logd has died.
		* ENOENT occurs if logd is not running and socket is missing.
		* ECONNREFUSED occurs if we can not reconnect to logd.
		* EAGAIN occurs if logd is overloaded.
		*/
		if (sock < 0) {
		ret = sock;
		} else {
		ret = TEMP_FAILURE_RETRY(writev(sock, newVec, i));
		if (ret < 0) {
		ret = -errno;
		}
		}
		switch (ret) {
		case -ENOTCONN:
		case -ECONNREFUSED:
		case -ENOENT:
		if (__android_log_trylock()) {
		return ret; /* in a signal handler? try again when less stressed */
		}
		__logdClose(ret);
		ret = logdOpen();
		__android_log_unlock();
		// The write below could be lost, but will never block.
		// EAGAIN occurs if logd is overloaded, other errors indicate that something went wrong with
		// the connection, so we reset it and try again.
		ret = TEMP_FAILURE_RETRY(writev(logd_socket, newVec, i));
		if (ret < 0 && errno != EAGAIN) {
		int old_socket = logd_socket;
		lock.unlock();
		ResetSocket(old_socket);
		lock.lock();

		if (ret < 0) {
		return ret;
		ret = TEMP_FAILURE_RETRY(writev(logd_socket, newVec, i));
		}

		ret = TEMP_FAILURE_RETRY(writev(atomic_load(&logdLoggerWrite.context.sock), newVec, i));
		if (ret < 0) {
		ret = -errno;
		}
		[[fallthrough]];
		default:
		break;
		}

		if (ret > (ssize_t)sizeof(header)) {
		ret -= sizeof(header);
		} else if (ret == -EAGAIN) {
		} else if (ret < 0) {
		atomic_fetch_add_explicit(&dropped, 1, memory_order_relaxed);
		if (logId == LOG_ID_SECURITY) {
		atomic_fetch_add_explicit(&droppedSecurity, 1, memory_order_relaxed);

liblog/logger.h

+0 −17

Original line number	Diff line number	Diff line
		@@ -26,20 +26,7 @@

		__BEGIN_DECLS

		/* Union, sock or fd of zero is not allowed unless static initialized */
		union android_log_context_union {
		void* priv;
		atomic_int sock;
		atomic_int fd;
		};

		struct android_log_transport_write {
		const char* name; /* human name to describe the transport */
		unsigned logMask; /* mask cache of available() success */
		union android_log_context_union context; /* Initialized by static allocation */

		int (available)(log_id_t logId); / Does not cause resources to be taken */
		int (open)(); / can be called multiple times, reusing current resources */
		void (close)(); / free up resources */
		/* write log to transport, returns number of bytes propagated, or -errno */
		int (write)(log_id_t logId, struct timespec ts, struct iovec* vec,
		@@ -83,8 +70,4 @@ static inline uid_t __android_log_uid() {
		}
		#endif

		void __android_log_lock();
		int __android_log_trylock();
		void __android_log_unlock();

		__END_DECLS

liblog/logger_write.cpp

+10 −92

Original line number	Diff line number	Diff line
		@@ -46,11 +46,8 @@ android_log_transport_write* android_log_write = &fakeLoggerWrite;
		android_log_transport_write* android_log_persist_write = nullptr;
		#endif

		static int __write_to_log_init(log_id_t, struct iovec* vec, size_t nr);
		static int (write_to_log)(log_id_t, struct iovec vec, size_t nr) = __write_to_log_init;

		static int check_log_uid_permissions() {
		#if defined(__ANDROID__)
		static int check_log_uid_permissions() {
		uid_t uid = __android_log_uid();

		/* Matches clientHasLogCredentials() in logd */
		@@ -87,43 +84,14 @@ static int check_log_uid_permissions() {
		}
		}
		}
		#endif
		return 0;
		}

		static void __android_log_cache_available(struct android_log_transport_write* node) {
		uint32_t i;

		if (node->logMask) {
		return;
		}

		for (i = LOG_ID_MIN; i < LOG_ID_MAX; ++i) {
		if (i != LOG_ID_KERNEL && (i != LOG_ID_SECURITY \|\| check_log_uid_permissions() == 0) &&
		(*node->available)(static_cast<log_id_t>(i)) >= 0) {
		node->logMask \|= 1 << i;
		}
		}
		}
		#endif

		/*
		* Release any logger resources. A new log write will immediately re-acquire.
		*/
		void __android_log_close() {
		__android_log_lock();

		write_to_log = __write_to_log_init;

		/*
		* Threads that are actively writing at this point are not held back
		* by a lock and are at risk of dropping the messages with a return code
		* -EBADF. Prefer to return error code than add the overhead of a lock to
		* each log writing call to guarantee delivery. In addition, anyone
		* calling this is doing so to release the logging resources and shut down,
		* for them to do so with outstanding log requests in other threads is a
		* disengenuous use of this function.
		*/

		if (android_log_write != nullptr) {
		android_log_write->close();
		}
		@@ -132,44 +100,18 @@ void __android_log_close() {
		android_log_persist_write->close();
		}

		__android_log_unlock();
		}

		static bool transport_initialize(android_log_transport_write* transport) {
		if (transport == nullptr) {
		return false;
		}

		__android_log_cache_available(transport);
		if (!transport->logMask) {
		return false;
		}

		// TODO: Do we actually need to call close() if open() fails?
		if (transport->open() < 0) {
		transport->close();
		return false;
		}

		return true;
		}

		/* log_init_lock assumed */
		static int __write_to_log_initialize() {
		if (!transport_initialize(android_log_write)) {
		return -ENODEV;
		}

		transport_initialize(android_log_persist_write);

		return 1;
		}

		static int __write_to_log_daemon(log_id_t log_id, struct iovec* vec, size_t nr) {
		static int write_to_log(log_id_t log_id, struct iovec* vec, size_t nr) {
		int ret, save_errno;
		struct timespec ts;

		save_errno = errno;

		if (log_id == LOG_ID_KERNEL) {
		return -EINVAL;
		}

		#if defined(__ANDROID__)
		clock_gettime(android_log_clockid(), &ts);

		@@ -215,9 +157,8 @@ static int __write_to_log_daemon(log_id_t log_id, struct iovec* vec, size_t nr)
		#endif

		ret = 0;
		size_t i = 1 << log_id;

		if (android_log_write != nullptr && (android_log_write->logMask & i)) {
		if (android_log_write != nullptr) {
		ssize_t retval;
		retval = android_log_write->write(log_id, &ts, vec, nr);
		if (ret >= 0) {
		@@ -225,7 +166,7 @@ static int __write_to_log_daemon(log_id_t log_id, struct iovec* vec, size_t nr)
		}
		}

		if (android_log_persist_write != nullptr && (android_log_persist_write->logMask & i)) {
		if (android_log_persist_write != nullptr) {
		android_log_persist_write->write(log_id, &ts, vec, nr);
		}

		@@ -233,29 +174,6 @@ static int __write_to_log_daemon(log_id_t log_id, struct iovec* vec, size_t nr)
		return ret;
		}

		static int __write_to_log_init(log_id_t log_id, struct iovec* vec, size_t nr) {
		int ret, save_errno = errno;

		__android_log_lock();

		if (write_to_log == __write_to_log_init) {
		ret = __write_to_log_initialize();
		if (ret < 0) {
		__android_log_unlock();
		errno = save_errno;
		return ret;
		}

		write_to_log = __write_to_log_daemon;
		}

		__android_log_unlock();

		ret = write_to_log(log_id, vec, nr);
		errno = save_errno;
		return ret;
		}

		int __android_log_write(int prio, const char* tag, const char* msg) {
		return __android_log_buf_write(LOG_ID_MAIN, prio, tag, msg);
		}