Merge "Remove liblog's rate limiting" (0cb1ce78) · Commits · e / os / android_system_core

liblog/Android.bp

+0 −1

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

liblog/include/log/log.h

+0 −27

Original line number	Diff line number	Diff line
		@@ -165,33 +165,6 @@ clockid_t android_log_clockid(void);
		*/
		void __android_log_close(void);

		/*
		* if last is NULL, caller _must_ provide a consistent value for seconds.
		*
		* Return -1 if we can not acquire a lock, which below will permit the logging,
		* error on allowing a log message through.
		*/
		int __android_log_ratelimit(time_t seconds, time_t* last);

		/*
		* Usage:
		*
		* // Global default and state
		* IF_ALOG_RATELIMIT() {
		* ALOG*(...);
		* }
		*
		* // local state, 10 seconds ratelimit
		* static time_t local_state;
		* IF_ALOG_RATELIMIT_LOCAL(10, &local_state) {
		* ALOG*(...);
		* }
		*/

		#define IF_ALOG_RATELIMIT() if (__android_log_ratelimit(0, NULL) > 0)
		#define IF_ALOG_RATELIMIT_LOCAL(seconds, state) \
		if (__android_log_ratelimit(seconds, state) > 0)

		#if defined(__clang__)
		#pragma clang diagnostic pop
		#endif

liblog/log_ratelimit.cpp

deleted100644 → 0

+0 −86

Original line number	Diff line number	Diff line
		/*
		** Copyright 2016, The Android Open Source Project
		**
		** Licensed under the Apache License, Version 2.0 (the "License");
		** you may not use this file except in compliance with the License.
		** You may obtain a copy of the License at
		**
		** http://www.apache.org/licenses/LICENSE-2.0
		**
		** Unless required by applicable law or agreed to in writing, software
		** distributed under the License is distributed on an "AS IS" BASIS,
		** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		** See the License for the specific language governing permissions and
		** limitations under the License.
		*/

		#include <errno.h>
		#include <pthread.h>
		#include <time.h>

		#include <log/log.h>

		#include "log_portability.h"

		// Global default if 'last' argument in __android_log_ratelimit is NULL
		static time_t g_last_clock;
		// Global above can not deal well with callers playing games with the
		// seconds argument, so we will also hold on to the maximum value
		// ever provided and use that to gain consistency. If the caller
		// provides their own 'last' argument, then they can play such games
		// of varying the 'seconds' argument to their pleasure.
		static time_t g_last_seconds;
		static const time_t last_seconds_default = 10;
		static const time_t last_seconds_max = 24 * 60 * 60; // maximum of a day
		static const time_t last_seconds_min = 2; // granularity
		// Lock to protect last_clock and last_seconds, but also 'last'
		// argument (not NULL) as supplied to __android_log_ratelimit.
		static pthread_mutex_t lock_ratelimit = PTHREAD_MUTEX_INITIALIZER;

		// if last is NULL, caller _must_ provide a consistent value for
		// seconds, otherwise we will take the maximum ever issued and hold
		// on to that. Preserves value of non-zero errno. Return -1 if we
		// can not acquire a lock, 0 if we are not to log a message, and 1
		// if we are ok to log a message. Caller should check > 0 for true.
		LIBLOG_ABI_PUBLIC int __android_log_ratelimit(time_t seconds, time_t* last) {
		int save_errno = errno;

		// Two reasons for trylock failure:
		// 1. In a signal handler. Must prevent deadlock
		// 2. Too many threads calling __android_log_ratelimit.
		// Bonus to not print if they race here because that
		// dovetails the goal of ratelimiting. One may print
		// and the others will wait their turn ...
		if (pthread_mutex_trylock(&lock_ratelimit)) {
		if (save_errno) errno = save_errno;
		return -1;
		}

		if (seconds == 0) {
		seconds = last_seconds_default;
		} else if (seconds < last_seconds_min) {
		seconds = last_seconds_min;
		} else if (seconds > last_seconds_max) {
		seconds = last_seconds_max;
		}

		if (!last) {
		if (g_last_seconds > seconds) {
		seconds = g_last_seconds;
		} else if (g_last_seconds < seconds) {
		g_last_seconds = seconds;
		}
		last = &g_last_clock;
		}

		time_t now = time(NULL);
		if ((now == (time_t)-1) \|\| ((*last + seconds) > now)) {
		pthread_mutex_unlock(&lock_ratelimit);
		if (save_errno) errno = save_errno;
		return 0;
		}
		*last = now;
		pthread_mutex_unlock(&lock_ratelimit);
		if (save_errno) errno = save_errno;
		return 1;
		}

liblog/tests/liblog_test.cpp

+0 −35

Original line number	Diff line number	Diff line
		@@ -3160,41 +3160,6 @@ TEST(liblog, __android_log_pmsg_file_read) {
		}
		#endif // USING_LOGGER_DEFAULT

		#ifdef USING_LOGGER_DEFAULT // Do not retest ratelimit
		TEST(liblog, __android_log_ratelimit) {
		time_t state = 0;

		errno = 42;
		// Prime
		__android_log_ratelimit(3, &state);
		EXPECT_EQ(errno, 42);
		// Check
		EXPECT_FALSE(__android_log_ratelimit(3, &state));
		sleep(1);
		EXPECT_FALSE(__android_log_ratelimit(3, &state));
		sleep(4);
		EXPECT_TRUE(__android_log_ratelimit(3, &state));
		sleep(5);
		EXPECT_TRUE(__android_log_ratelimit(3, &state));

		// API checks
		IF_ALOG_RATELIMIT_LOCAL(3, &state) {
		EXPECT_FALSE(0 != "IF_ALOG_RATELIMIT_LOCAL(3, &state)");
		}

		IF_ALOG_RATELIMIT() {
		;
		}
		else {
		EXPECT_TRUE(0 == "IF_ALOG_RATELIMIT()");
		}
		IF_ALOG_RATELIMIT() {
		EXPECT_FALSE(0 != "IF_ALOG_RATELIMIT()");
		}
		// Do not test default seconds, to allow liblog to tune freely
		}
		#endif // USING_LOGGER_DEFAULT

		#ifdef USING_LOGGER_DEFAULT // Do not retest event mapping functionality
		TEST(liblog, android_lookupEventTagNum) {
		#ifdef __ANDROID__

storaged/storaged.cpp

+2 −8

Original line number	Diff line number	Diff line
		@@ -341,20 +341,14 @@ void storaged_t::event_checked(void) {
		if (mConfig.event_time_check_usec &&
		clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start_ts) < 0) {
		check_time = false;
		static time_t state_a;
		IF_ALOG_RATELIMIT_LOCAL(300, &state_a) {
		PLOG_TO(SYSTEM, ERROR) << "clock_gettime() failed";
		}
		}

		event();

		if (mConfig.event_time_check_usec && check_time) {
		if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end_ts) < 0) {
		static time_t state_b;
		IF_ALOG_RATELIMIT_LOCAL(300, &state_b) {
		PLOG_TO(SYSTEM, ERROR) << "clock_gettime() failed";
		}
		return;
		}
		int64_t cost = (end_ts.tv_sec - start_ts.tv_sec) * SEC_TO_USEC +