1 /*
2 * Copyright (C) 2013-2017 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <sys/types.h>
18 #include <time.h>
19 #include <unistd.h>
20
21 #include <string>
22
23 #include <android-base/chrono_utils.h>
24 #include <android-base/stringprintf.h>
25 #include <android/log.h> // minimal logging API
26 #include <gtest/gtest.h>
27 #include <log/log_properties.h>
28 #include <log/log_read.h>
29 #include <log/log_time.h>
30 #include <log/log_transport.h>
31
32 #ifdef __ANDROID__
read_with_wrap()33 static void read_with_wrap() {
34 android_set_log_transport(LOGGER_LOGD);
35
36 // Read the last line in the log to get a starting timestamp. We're assuming
37 // the log is not empty.
38 const int mode = ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK;
39 struct logger_list* logger_list =
40 android_logger_list_open(LOG_ID_MAIN, mode, 1000, 0);
41
42 ASSERT_NE(logger_list, nullptr);
43
44 log_msg log_msg;
45 int ret = android_logger_list_read(logger_list, &log_msg);
46 android_logger_list_close(logger_list);
47 ASSERT_GT(ret, 0);
48
49 log_time start(log_msg.entry.sec, log_msg.entry.nsec);
50 ASSERT_NE(start, log_time());
51
52 logger_list =
53 android_logger_list_alloc_time(mode | ANDROID_LOG_WRAP, start, 0);
54 ASSERT_NE(logger_list, nullptr);
55
56 struct logger* logger = android_logger_open(logger_list, LOG_ID_MAIN);
57 EXPECT_NE(logger, nullptr);
58 if (logger) {
59 android_logger_list_read(logger_list, &log_msg);
60 }
61
62 android_logger_list_close(logger_list);
63 }
64
caught_signal(int)65 static void caught_signal(int /* signum */) {
66 }
67 #endif
68
69 // b/64143705 confirm fixed
TEST(liblog,wrap_mode_blocks)70 TEST(liblog, wrap_mode_blocks) {
71 #ifdef __ANDROID__
72
73 android::base::Timer timer;
74
75 // The read call is expected to take up to 2 hours in the happy case.
76 // We only want to make sure it waits for longer than 30s, but we can't
77 // use an alarm as the implementation uses it. So we run the test in
78 // a separate process.
79 pid_t pid = fork();
80
81 if (pid == 0) {
82 // child
83 read_with_wrap();
84 _exit(0);
85 }
86
87 struct sigaction ignore, old_sigaction;
88 memset(&ignore, 0, sizeof(ignore));
89 ignore.sa_handler = caught_signal;
90 sigemptyset(&ignore.sa_mask);
91 sigaction(SIGALRM, &ignore, &old_sigaction);
92 alarm(45);
93
94 bool killed = false;
95 for (;;) {
96 siginfo_t info = {};
97 // This wait will succeed if the child exits, or fail with EINTR if the
98 // alarm goes off first - a loose approximation to a timed wait.
99 int ret = waitid(P_PID, pid, &info, WEXITED);
100 if (ret >= 0 || errno != EINTR) {
101 EXPECT_EQ(ret, 0);
102 if (!killed) {
103 EXPECT_EQ(info.si_status, 0);
104 }
105 break;
106 }
107 unsigned int alarm_left = alarm(0);
108 if (alarm_left > 0) {
109 alarm(alarm_left);
110 } else {
111 kill(pid, SIGTERM);
112 killed = true;
113 }
114 }
115
116 alarm(0);
117 EXPECT_GT(timer.duration(), std::chrono::seconds(40));
118 #else
119 GTEST_LOG_(INFO) << "This test does nothing.\n";
120 #endif
121 }
122