Merge "liblog: introduce ANDROID_LOG_* flags" (110166c1) · Commits · e / os / android_system_core

debuggerd/tombstone.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -453,7 +453,7 @@ static void dump_log_file(
		}

		logger_list = android_logger_list_open(
		android_name_to_log_id(filename), O_RDONLY \| O_NONBLOCK, tail, pid);
		android_name_to_log_id(filename), ANDROID_LOG_RDONLY \| ANDROID_LOG_NONBLOCK, tail, pid);

		if (!logger_list) {
		ALOGE("Unable to open %s: %s\n", filename, strerror(errno));

include/log/logger.h

+6 −0

Original line number	Diff line number	Diff line
		@@ -154,6 +154,12 @@ ssize_t android_logger_get_prune_list(struct logger_list *logger_list,
		int android_logger_set_prune_list(struct logger_list *logger_list,
		char *buf, size_t len);

		#define ANDROID_LOG_RDONLY O_RDONLY
		#define ANDROID_LOG_WRONLY O_WRONLY
		#define ANDROID_LOG_RDWR O_RDWR
		#define ANDROID_LOG_ACCMODE O_ACCMODE
		#define ANDROID_LOG_NONBLOCK O_NONBLOCK

		struct logger_list *android_logger_list_alloc(int mode,
		unsigned int tail,
		pid_t pid);

liblog/README

+7 −6

Original line number	Diff line number	Diff line
		@@ -111,20 +111,21 @@ DESCRIPTION
		ger_list_alloc, calling in turn the android_logger_open for each log
		id. Each entry can be retrieved with android_logger_list_read. The
		log(s) can be closed with android_logger_list_free. The logs should be
		opened with an O_RDONLY mode. O_NDELAY mode will report when the log
		reading is done with an EAGAIN error return code, otherwise the
		android_logger_list_read call will block for new entries.
		opened with an ANDROID_LOG_RDONLY mode. ANDROID_LOG_NONBLOCK mode
		will report when the log reading is done with an EAGAIN error return
		code, otherwise the android_logger_list_read call will block for new
		entries.

		The value returned by android_logger_open can be used as a parameter to
		the android_logger_clear function to empty the sub-log. It is recom‐
		mended to only open log O_WRONLY.
		mended to only open log ANDROID_LOG_WRONLY in that case.

		The value returned by android_logger_open can be used as a parameter to
		the android_logger_get_log_(size\|readable_size\|version) to retrieve the
		sub-log maximum size, readable size and log buffer format protocol ver‐
		sion respectively. android_logger_get_id returns the id that was used
		when opening the sub-log. It is recommended to open the log O_RDONLY
		in these cases.
		when opening the sub-log. It is recommended to open the log
		ANDROID_LOG_RDONLY in these cases.

		SEE ALSO
		syslogd(8)

liblog/log_read.c

+6 −6

Original line number	Diff line number	Diff line
		@@ -582,7 +582,7 @@ int android_logger_list_read(struct logger_list *logger_list,
		return -EINVAL;
		}

		if (logger_list->mode & O_NONBLOCK) {
		if (logger_list->mode & ANDROID_LOG_NONBLOCK) {
		memset(&ignore, 0, sizeof(ignore));
		ignore.sa_handler = caught_signal;
		sigemptyset(&ignore.sa_mask);
		@@ -602,7 +602,7 @@ int android_logger_list_read(struct logger_list *logger_list,
		}

		strcpy(buffer,
		(logger_list->mode & O_NONBLOCK) ? "dumpAndClose" : "stream");
		(logger_list->mode & ANDROID_LOG_NONBLOCK) ? "dumpAndClose" : "stream");
		cp = buffer + strlen(buffer);

		strcpy(cp, " lids");
		@@ -640,14 +640,14 @@ int android_logger_list_read(struct logger_list *logger_list,
		cp += ret;
		}

		if (logger_list->mode & O_NONBLOCK) {
		if (logger_list->mode & ANDROID_LOG_NONBLOCK) {
		/* Deal with an unresponsive logd */
		sigaction(SIGALRM, &ignore, &old_sigaction);
		old_alarm = alarm(30);
		}
		ret = write(sock, buffer, cp - buffer);
		e = errno;
		if (logger_list->mode & O_NONBLOCK) {
		if (logger_list->mode & ANDROID_LOG_NONBLOCK) {
		if (e == EINTR) {
		e = ETIMEDOUT;
		}
		@@ -673,7 +673,7 @@ int android_logger_list_read(struct logger_list *logger_list,
		while(1) {
		memset(log_msg, 0, sizeof(*log_msg));

		if (logger_list->mode & O_NONBLOCK) {
		if (logger_list->mode & ANDROID_LOG_NONBLOCK) {
		/* particularily useful if tombstone is reporting for logd */
		sigaction(SIGALRM, &ignore, &old_sigaction);
		old_alarm = alarm(30);
		@@ -681,7 +681,7 @@ int android_logger_list_read(struct logger_list *logger_list,
		/* NOTE: SOCK_SEQPACKET guarantees we read exactly one full entry */
		ret = recv(logger_list->sock, log_msg, LOGGER_ENTRY_MAX_LEN, 0);
		e = errno;
		if (logger_list->mode & O_NONBLOCK) {
		if (logger_list->mode & ANDROID_LOG_NONBLOCK) {
		if ((ret == 0) \|\| (e == EINTR)) {
		e = EAGAIN;
		ret = -1;

liblog/log_read_kern.c

+11 −11

Original line number	Diff line number	Diff line
		@@ -75,10 +75,10 @@ const char *android_log_id_to_name(log_id_t log_id)

		static int accessmode(int mode)
		{
		if ((mode & O_ACCMODE) == O_WRONLY) {
		if ((mode & ANDROID_LOG_ACCMODE) == ANDROID_LOG_WRONLY) {
		return W_OK;
		}
		if ((mode & O_ACCMODE) == O_RDWR) {
		if ((mode & ANDROID_LOG_ACCMODE) == ANDROID_LOG_RDWR) {
		return R_OK \| W_OK;
		}
		return R_OK;
		@@ -117,7 +117,7 @@ log_id_t android_name_to_log_id(const char *logName)
		++b;
		}

		ret = check_allocate_accessible(&n, b, O_RDONLY);
		ret = check_allocate_accessible(&n, b, ANDROID_LOG_RDONLY);
		free(n);
		if (ret) {
		return ret;
		@@ -201,8 +201,8 @@ static int logger_ioctl(struct logger *logger, int cmd, int mode)
		return -EFAULT;
		}

		if (((mode & O_ACCMODE) == O_RDWR)
		\|\| (((mode ^ logger->top->mode) & O_ACCMODE) == 0)) {
		if (((mode & ANDROID_LOG_ACCMODE) == ANDROID_LOG_RDWR)
		\|\| (((mode ^ logger->top->mode) & ANDROID_LOG_ACCMODE) == 0)) {
		return ioctl(logger->fd, cmd);
		}

		@@ -227,13 +227,13 @@ static int logger_ioctl(struct logger *logger, int cmd, int mode)

		int android_logger_clear(struct logger *logger)
		{
		return logger_ioctl(logger, LOGGER_FLUSH_LOG, O_WRONLY);
		return logger_ioctl(logger, LOGGER_FLUSH_LOG, ANDROID_LOG_WRONLY);
		}

		/* returns the total size of the log's ring buffer */
		long android_logger_get_log_size(struct logger *logger)
		{
		return logger_ioctl(logger, LOGGER_GET_LOG_BUF_SIZE, O_RDWR);
		return logger_ioctl(logger, LOGGER_GET_LOG_BUF_SIZE, ANDROID_LOG_RDWR);
		}

		int android_logger_set_log_size(struct logger *logger __unused,
		@@ -248,7 +248,7 @@ int android_logger_set_log_size(struct logger *logger __unused,
		*/
		long android_logger_get_log_readable_size(struct logger *logger)
		{
		return logger_ioctl(logger, LOGGER_GET_LOG_LEN, O_RDONLY);
		return logger_ioctl(logger, LOGGER_GET_LOG_LEN, ANDROID_LOG_RDONLY);
		}

		/*
		@@ -256,7 +256,7 @@ long android_logger_get_log_readable_size(struct logger *logger)
		*/
		int android_logger_get_log_version(struct logger *logger)
		{
		int ret = logger_ioctl(logger, LOGGER_GET_VERSION, O_RDWR);
		int ret = logger_ioctl(logger, LOGGER_GET_VERSION, ANDROID_LOG_RDWR);
		return (ret < 0) ? 1 : ret;
		}

		@@ -342,7 +342,7 @@ struct logger android_logger_open(struct logger_list logger_list,
		goto err_name;
		}

		logger->fd = open(n, logger_list->mode);
		logger->fd = open(n, logger_list->mode & (ANDROID_LOG_ACCMODE \| ANDROID_LOG_NONBLOCK));
		if (logger->fd < 0) {
		goto err_name;
		}
		@@ -565,7 +565,7 @@ int android_logger_list_read(struct logger_list *logger_list,
		if (result <= 0) {
		if (result) {
		error = errno;
		} else if (logger_list->mode & O_NDELAY) {
		} else if (logger_list->mode & ANDROID_LOG_NONBLOCK) {
		error = EAGAIN;
		} else {
		logger_list->timeout_ms = LOG_TIMEOUT_NEVER;