/*
|
* 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.
|
*/
|
|
#include "Process.h"
|
|
#include <errno.h>
|
#include <fcntl.h>
|
#include <signal.h>
|
#include <sys/resource.h>
|
#include <sys/stat.h>
|
#include <sys/time.h>
|
#include <unistd.h>
|
|
#include <chrono>
|
#include <sstream>
|
|
#include "android-base/stringprintf.h"
|
#define LOG_TAG "Netd"
|
#include "log/log.h"
|
|
#include "netdutils/Misc.h"
|
#include "netdutils/Slice.h"
|
#include "netdutils/Syscalls.h"
|
#include "netdutils/UniqueFd.h"
|
|
namespace android {
|
|
using base::StringPrintf;
|
using netdutils::DumpWriter;
|
using netdutils::Fd;
|
using netdutils::isOk;
|
using netdutils::makeCleanup;
|
using netdutils::makeSlice;
|
using netdutils::UniqueFd;
|
|
namespace net {
|
namespace process {
|
namespace {
|
|
const int PID_FILE_FLAGS = O_CREAT | O_TRUNC | O_WRONLY | O_NOFOLLOW | O_CLOEXEC;
|
const mode_t PID_FILE_MODE = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; // mode 0644, rw-r--r--
|
|
// Set up during static initialization.
|
const std::chrono::steady_clock::time_point sStartTime = std::chrono::steady_clock::now();
|
|
std::chrono::milliseconds totalRunningTime() {
|
return std::chrono::duration_cast<std::chrono::milliseconds>(
|
std::chrono::steady_clock::now() - sStartTime);
|
}
|
|
std::string formatDuration(std::chrono::milliseconds duration) {
|
auto hrs = std::chrono::duration_cast<std::chrono::hours>(duration);
|
duration -= hrs;
|
const auto mins = std::chrono::duration_cast<std::chrono::minutes>(duration);
|
duration -= mins;
|
const auto secs = std::chrono::duration_cast<std::chrono::seconds>(duration);
|
duration -= secs;
|
|
// No std::chrono::days until C++20.
|
const unsigned days = hrs.count() / 24;
|
hrs -= std::chrono::hours(days * 24);
|
|
return StringPrintf("%ud%luh%lum%llus%llums",
|
days, hrs.count(), mins.count(), secs.count(), duration.count());
|
}
|
|
} // unnamed namespace
|
|
void blockSigPipe() {
|
sigset_t mask;
|
|
sigemptyset(&mask);
|
sigaddset(&mask, SIGPIPE);
|
if (sigprocmask(SIG_BLOCK, &mask, nullptr) != 0) {
|
ALOGW("WARNING: SIGPIPE not blocked\n");
|
}
|
}
|
|
void writePidFile(const std::string& pidFile) {
|
const std::string pid_buf(StringPrintf("%d\n", (int) getpid()));
|
|
Fd pidFd = open(pidFile.c_str(), PID_FILE_FLAGS, PID_FILE_MODE);
|
if (pidFd.get() == -1) {
|
ALOGE("Unable to create pid file (%s)", strerror(errno));
|
return;
|
}
|
|
const UniqueFd autoClosePidFile(pidFd);
|
auto rmFile = makeCleanup([pidFile] { removePidFile(pidFile); });
|
|
// File creation is affected by umask, so make sure the right mode bits are set.
|
if (fchmod(pidFd.get(), PID_FILE_MODE) == -1) {
|
ALOGE("failed to set mode 0%o on %s (%s)", PID_FILE_MODE, pidFile.c_str(), strerror(errno));
|
return;
|
}
|
|
auto& sys = netdutils::sSyscalls.get();
|
const auto rval = sys.write(pidFd, makeSlice(pid_buf));
|
if (!isOk(rval.status()) || rval.value() != pid_buf.size()) {
|
ALOGE("Unable to write to pid file (%s)", strerror(errno));
|
return;
|
}
|
|
rmFile.release(); // Don't delete the pid file :-)
|
}
|
|
void removePidFile(const std::string& pidFile) {
|
unlink(pidFile.c_str());
|
}
|
|
void dump(DumpWriter& dw) {
|
std::stringstream out;
|
out << "ppid:" << getppid() << " -> pid:" << getpid() << " -> tid:" << gettid() << '\n';
|
const auto runningTime = totalRunningTime();
|
out << "total running time: " << formatDuration(runningTime)
|
<< " (" << totalRunningTime().count() << "ms)" << '\n';
|
|
struct rusage ru{};
|
if (getrusage(RUSAGE_SELF, &ru) == 0) {
|
out << "user: " << ru.ru_utime.tv_sec << "s" << (ru.ru_utime.tv_usec/1000) << "ms"
|
<< " sys: " << ru.ru_stime.tv_sec << "s" << (ru.ru_stime.tv_usec/1000) << "ms"
|
<< '\n';
|
out << "maxrss: " << ru.ru_maxrss << "kB" << '\n';
|
}
|
|
dw.println(out.str());
|
}
|
|
} // namespace process
|
} // namespace net
|
} // namespace android
|
