tequilaOS/platform_system_core
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge "Remove liblog's rate limiting"

Browse source
This commit is contained in:
Treehugger Robot 2019-01-17 01:25:27 +00:00 committed by Gerrit Code Review
commit 6a462405d0
5 changed files with 2 additions and 157 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
liblog/Android.bp
View file

@ -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",

27
liblog/include/log/log.h
View file

@ -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

86
liblog/log_ratelimit.cpp
View file

@ -1,86 +0,0 @@
/*
** 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;
}

35
liblog/tests/liblog_test.cpp
View file

@ -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__

10
storaged/storaged.cpp
View file

@ -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";
}
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";
}
PLOG_TO(SYSTEM, ERROR) << "clock_gettime() failed";
return;
}
int64_t cost = (end_ts.tv_sec - start_ts.tv_sec) * SEC_TO_USEC +