blob: f4b505d5ab86582bf5f5ae4a9f1f163307dfbf53 [file] [log] [blame]
/*
* Copyright (C) 2018 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.
*/
#define LOG_TAG "TcpSocketMonitor"
#include <chrono>
#include <cinttypes>
#include <thread>
#include <vector>
#include <arpa/inet.h>
#include <netinet/tcp.h>
#include <linux/tcp.h>
#include "Controllers.h"
#include "SockDiag.h"
#include "TcpSocketMonitor.h"
#include "netdutils/DumpWriter.h"
using android::netdutils::DumpWriter;
using android::netdutils::ScopedIndent;
namespace android {
namespace net {
using std::chrono::duration_cast;
using std::chrono::steady_clock;
constexpr const char* getTcpStateName(int t) {
switch (t) {
case TCP_ESTABLISHED:
return "ESTABLISHED";
case TCP_SYN_SENT:
return "SYN-SENT";
case TCP_SYN_RECV:
return "SYN-RECV";
case TCP_FIN_WAIT1:
return "FIN-WAIT-1";
case TCP_FIN_WAIT2:
return "FIN-WAIT-2";
case TCP_TIME_WAIT:
return "TIME-WAIT";
case TCP_CLOSE:
return "CLOSE";
case TCP_CLOSE_WAIT:
return "CLOSE-WAIT";
case TCP_LAST_ACK:
return "LAST-ACK";
case TCP_LISTEN:
return "LISTEN";
case TCP_CLOSING:
return "CLOSING";
default:
return "UNKNOWN";
}
}
// Helper macro for reading fields into struct tcp_info and handling different struct tcp_info
// versions in the kernel.
#define TCPINFO_GET(ptr, fld, len, zero) \
(((ptr) != nullptr && (offsetof(struct tcp_info, fld) + sizeof((ptr)->fld)) < len) ? \
(ptr)->fld : zero)
static void tcpInfoPrint(DumpWriter &dw, Fwmark mark, const struct inet_diag_msg *sockinfo,
const struct tcp_info *tcpinfo, uint32_t tcpinfoLen) {
char saddr[INET6_ADDRSTRLEN] = {};
char daddr[INET6_ADDRSTRLEN] = {};
inet_ntop(sockinfo->idiag_family, &(sockinfo->id.idiag_src), saddr, sizeof(saddr));
inet_ntop(sockinfo->idiag_family, &(sockinfo->id.idiag_dst), daddr, sizeof(daddr));
dw.println(
"netId=%d uid=%u mark=0x%x saddr=%s daddr=%s sport=%u dport=%u tcp_state=%s(%u) "
"rtt=%gms sent=%u lost=%u",
mark.netId,
sockinfo->idiag_uid,
mark.intValue,
saddr,
daddr,
ntohs(sockinfo->id.idiag_sport),
ntohs(sockinfo->id.idiag_dport),
getTcpStateName(sockinfo->idiag_state), sockinfo->idiag_state,
TCPINFO_GET(tcpinfo, tcpi_rtt, tcpinfoLen, 0) / 1000.0,
TCPINFO_GET(tcpinfo, tcpi_segs_out, tcpinfoLen, 0),
TCPINFO_GET(tcpinfo, tcpi_lost, tcpinfoLen, 0));
}
const String16 TcpSocketMonitor::DUMP_KEYWORD = String16("tcp_socket_info");
const milliseconds TcpSocketMonitor::kDefaultPollingInterval = milliseconds(30000);
void TcpSocketMonitor::dump(DumpWriter& dw) {
std::lock_guard guard(mLock);
dw.println("TcpSocketMonitor");
ScopedIndent tcpSocketMonitorDetails(dw);
const auto now = steady_clock::now();
const auto d = duration_cast<milliseconds>(now - mLastPoll);
dw.println("running=%d, suspended=%d, last poll %lld ms ago",
mIsRunning, mIsSuspended, d.count());
if (!mNetworkStats.empty()) {
dw.blankline();
dw.println("Network stats:");
for (const std::pair<const uint32_t, TcpStats>& stats : mNetworkStats) {
if (stats.second.nSockets == 0) {
continue;
}
dw.println("netId=%d sent=%d lost=%d rttMs=%gms sentAckDiff=%dms",
stats.first,
stats.second.sent,
stats.second.lost,
stats.second.rttUs / 1000.0 / stats.second.nSockets,
stats.second.sentAckDiffMs / stats.second.nSockets);
}
}
if (!mSocketEntries.empty()) {
dw.blankline();
dw.println("Socket entries:");
for (const std::pair<const uint64_t, SocketEntry>& stats : mSocketEntries) {
dw.println("netId=%u uid=%u cookie=%" PRIu64, stats.second.mark.netId, stats.second.uid,
stats.first);
}
}
SockDiag sd;
if (sd.open()) {
dw.blankline();
dw.println("Current socket dump:");
const auto tcpInfoReader = [&dw](Fwmark mark, const struct inet_diag_msg *sockinfo,
const struct tcp_info *tcpinfo, uint32_t tcpinfoLen) {
tcpInfoPrint(dw, mark, sockinfo, tcpinfo, tcpinfoLen);
};
if (int ret = sd.getLiveTcpInfos(tcpInfoReader)) {
ALOGE("Failed to dump TCP socket info: %s", strerror(-ret));
}
} else {
ALOGE("Error opening sock diag for dumping TCP socket info");
}
}
void TcpSocketMonitor::setPollingInterval(milliseconds nextSleepDurationMs) {
std::lock_guard guard(mLock);
mNextSleepDurationMs = nextSleepDurationMs;
ALOGD("tcpinfo polling interval set to %lld ms", mNextSleepDurationMs.count());
}
void TcpSocketMonitor::resumePolling() {
bool wasSuspended;
{
std::lock_guard guard(mLock);
wasSuspended = mIsSuspended;
mIsSuspended = false;
ALOGD("resuming tcpinfo polling (interval=%lldms)", mNextSleepDurationMs.count());
}
if (wasSuspended) {
mCv.notify_all();
}
}
void TcpSocketMonitor::suspendPolling() {
std::lock_guard guard(mLock);
bool wasSuspended = mIsSuspended;
mIsSuspended = true;
ALOGD("suspending tcpinfo polling");
if (!wasSuspended) {
mSocketEntries.clear();
}
}
void TcpSocketMonitor::poll() {
std::lock_guard guard(mLock);
if (mIsSuspended) {
return;
}
SockDiag sd;
if (!sd.open()) {
ALOGE("Error opening sock diag for polling TCP socket info");
return;
}
const auto now = steady_clock::now();
const auto tcpInfoReader = [this, now](Fwmark mark, const struct inet_diag_msg *sockinfo,
const struct tcp_info *tcpinfo,
uint32_t tcpinfoLen) NO_THREAD_SAFETY_ANALYSIS {
if (sockinfo == nullptr || tcpinfo == nullptr || tcpinfoLen == 0 || mark.intValue == 0) {
return;
}
updateSocketStats(now, mark, sockinfo, tcpinfo, tcpinfoLen);
};
// Reset mNetworkStats
mNetworkStats.clear();
if (int ret = sd.getLiveTcpInfos(tcpInfoReader)) {
ALOGE("Failed to poll TCP socket info: %s", strerror(-ret));
return;
}
// Remove any SocketEntry not updated
for (auto it = mSocketEntries.cbegin(); it != mSocketEntries.cend();) {
if (it->second.lastUpdate < now) {
it = mSocketEntries.erase(it);
} else {
it++;
}
}
const auto listener = gCtls->eventReporter.getNetdEventListener();
if (listener != nullptr) {
std::vector<int> netIds;
std::vector<int> sentPackets;
std::vector<int> lostPackets;
std::vector<int> rtts;
std::vector<int> sentAckDiffs;
for (auto const& stats : mNetworkStats) {
int32_t nSockets = stats.second.nSockets;
if (nSockets == 0) {
continue;
}
netIds.push_back(stats.first);
sentPackets.push_back(stats.second.sent);
lostPackets.push_back(stats.second.lost);
rtts.push_back(stats.second.rttUs / nSockets);
sentAckDiffs.push_back(stats.second.sentAckDiffMs / nSockets);
}
listener->onTcpSocketStatsEvent(netIds, sentPackets, lostPackets, rtts, sentAckDiffs);
}
mLastPoll = now;
}
void TcpSocketMonitor::waitForNextPoll() {
bool isSuspended;
milliseconds nextSleepDurationMs;
{
std::lock_guard guard(mLock);
isSuspended = mIsSuspended;
nextSleepDurationMs= mNextSleepDurationMs;
}
std::unique_lock<std::mutex> ul(mLock);
if (isSuspended) {
mCv.wait(ul);
} else {
mCv.wait_for(ul, nextSleepDurationMs);
}
}
bool TcpSocketMonitor::isRunning() {
std::lock_guard guard(mLock);
return mIsRunning;
}
void TcpSocketMonitor::updateSocketStats(time_point now, Fwmark mark,
const struct inet_diag_msg *sockinfo,
const struct tcp_info *tcpinfo,
uint32_t tcpinfoLen) NO_THREAD_SAFETY_ANALYSIS {
int32_t lastAck = TCPINFO_GET(tcpinfo, tcpi_last_ack_recv, tcpinfoLen, 0);
int32_t lastSent = TCPINFO_GET(tcpinfo, tcpi_last_data_sent, tcpinfoLen, 0);
TcpStats diff = {
.sent = TCPINFO_GET(tcpinfo, tcpi_segs_out, tcpinfoLen, 0),
.lost = TCPINFO_GET(tcpinfo, tcpi_lost, tcpinfoLen, 0),
.rttUs = TCPINFO_GET(tcpinfo, tcpi_rtt, tcpinfoLen, 0),
.sentAckDiffMs = lastAck - lastSent,
.nSockets = 1,
};
{
// Update socket stats with the newest entry, computing the diff w.r.t the previous entry.
const uint64_t cookie = (static_cast<uint64_t>(sockinfo->id.idiag_cookie[0]) << 32)
| static_cast<uint64_t>(sockinfo->id.idiag_cookie[1]);
const SocketEntry previous = mSocketEntries[cookie];
mSocketEntries[cookie] = {
.sent = diff.sent,
.lost = diff.lost,
.lastUpdate = now,
.mark = mark,
.uid = sockinfo->idiag_uid,
};
diff.sent -= previous.sent;
diff.lost -= previous.lost;
}
{
// Aggregate the diff per network id.
auto& stats = mNetworkStats[mark.netId];
stats.sent += diff.sent;
stats.lost += diff.lost;
stats.rttUs += diff.rttUs;
stats.sentAckDiffMs += diff.sentAckDiffMs;
stats.nSockets += diff.nSockets;
}
}
TcpSocketMonitor::TcpSocketMonitor() {
std::lock_guard guard(mLock);
mNextSleepDurationMs = kDefaultPollingInterval;
mIsRunning = true;
mIsSuspended = true;
mPollingThread = std::thread([this] {
(void) this;
while (isRunning()) {
poll();
waitForNextPoll();
}
});
}
TcpSocketMonitor::~TcpSocketMonitor() {
{
std::lock_guard guard(mLock);
mIsRunning = false;
mIsSuspended = true;
}
mCv.notify_all();
mPollingThread.join();
}
} // namespace net
} // namespace android