2015-08-01 03:45:25 +08:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2015 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 "service.h"
|
|
|
|
|
|
|
|
#include <fcntl.h>
|
2016-04-22 06:35:09 +08:00
|
|
|
#include <sched.h>
|
|
|
|
#include <sys/mount.h>
|
|
|
|
#include <sys/prctl.h>
|
2016-05-19 08:36:30 +08:00
|
|
|
#include <sys/resource.h>
|
2015-08-01 03:45:25 +08:00
|
|
|
#include <sys/stat.h>
|
2016-05-19 08:36:30 +08:00
|
|
|
#include <sys/time.h>
|
2015-08-01 03:45:25 +08:00
|
|
|
#include <sys/types.h>
|
2015-12-19 03:39:59 +08:00
|
|
|
#include <sys/wait.h>
|
2015-08-01 03:45:25 +08:00
|
|
|
#include <termios.h>
|
2015-08-12 07:37:04 +08:00
|
|
|
#include <unistd.h>
|
2015-08-01 03:45:25 +08:00
|
|
|
|
|
|
|
#include <selinux/selinux.h>
|
|
|
|
|
2015-12-05 14:00:26 +08:00
|
|
|
#include <android-base/file.h>
|
2016-10-12 08:09:00 +08:00
|
|
|
#include <android-base/parseint.h>
|
2015-12-05 14:00:26 +08:00
|
|
|
#include <android-base/stringprintf.h>
|
2016-06-25 06:12:21 +08:00
|
|
|
#include <android-base/strings.h>
|
2015-08-01 03:45:25 +08:00
|
|
|
#include <cutils/android_reboot.h>
|
|
|
|
#include <cutils/sockets.h>
|
2016-05-19 08:36:30 +08:00
|
|
|
#include <system/thread_defs.h>
|
2015-08-01 03:45:25 +08:00
|
|
|
|
2016-06-02 05:03:55 +08:00
|
|
|
#include <processgroup/processgroup.h>
|
|
|
|
|
2015-08-01 03:45:25 +08:00
|
|
|
#include "action.h"
|
|
|
|
#include "init.h"
|
|
|
|
#include "init_parser.h"
|
|
|
|
#include "log.h"
|
|
|
|
#include "property_service.h"
|
|
|
|
#include "util.h"
|
|
|
|
|
2016-10-12 08:09:00 +08:00
|
|
|
using android::base::ParseInt;
|
2015-08-27 02:43:36 +08:00
|
|
|
using android::base::StringPrintf;
|
|
|
|
using android::base::WriteStringToFile;
|
|
|
|
|
2015-08-01 03:45:25 +08:00
|
|
|
#define CRITICAL_CRASH_THRESHOLD 4 // if we crash >4 times ...
|
|
|
|
#define CRITICAL_CRASH_WINDOW (4*60) // ... in 4 minutes, goto recovery
|
|
|
|
|
2016-07-09 01:32:26 +08:00
|
|
|
static std::string ComputeContextFromExecutable(std::string& service_name,
|
|
|
|
const std::string& service_path) {
|
|
|
|
std::string computed_context;
|
|
|
|
|
|
|
|
char* raw_con = nullptr;
|
|
|
|
char* raw_filecon = nullptr;
|
|
|
|
|
|
|
|
if (getcon(&raw_con) == -1) {
|
|
|
|
LOG(ERROR) << "could not get context while starting '" << service_name << "'";
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
std::unique_ptr<char> mycon(raw_con);
|
|
|
|
|
|
|
|
if (getfilecon(service_path.c_str(), &raw_filecon) == -1) {
|
|
|
|
LOG(ERROR) << "could not get file context while starting '" << service_name << "'";
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
std::unique_ptr<char> filecon(raw_filecon);
|
|
|
|
|
|
|
|
char* new_con = nullptr;
|
|
|
|
int rc = security_compute_create(mycon.get(), filecon.get(),
|
|
|
|
string_to_security_class("process"), &new_con);
|
|
|
|
if (rc == 0) {
|
|
|
|
computed_context = new_con;
|
|
|
|
free(new_con);
|
|
|
|
}
|
|
|
|
if (rc == 0 && computed_context == mycon.get()) {
|
|
|
|
LOG(ERROR) << "service " << service_name << " does not have a SELinux domain defined";
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
if (rc < 0) {
|
|
|
|
LOG(ERROR) << "could not get context while starting '" << service_name << "'";
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
return computed_context;
|
|
|
|
}
|
|
|
|
|
2016-04-22 06:35:09 +08:00
|
|
|
static void SetUpPidNamespace(const std::string& service_name) {
|
|
|
|
constexpr unsigned int kSafeFlags = MS_NODEV | MS_NOEXEC | MS_NOSUID;
|
|
|
|
|
|
|
|
// It's OK to LOG(FATAL) in this function since it's running in the first
|
|
|
|
// child process.
|
|
|
|
if (mount("", "/proc", "proc", kSafeFlags | MS_REMOUNT, "") == -1) {
|
2016-07-26 09:18:16 +08:00
|
|
|
PLOG(FATAL) << "couldn't remount(/proc) for " << service_name;
|
2016-04-22 06:35:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (prctl(PR_SET_NAME, service_name.c_str()) == -1) {
|
2016-07-26 09:18:16 +08:00
|
|
|
PLOG(FATAL) << "couldn't set name for " << service_name;
|
2016-04-22 06:35:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
pid_t child_pid = fork();
|
|
|
|
if (child_pid == -1) {
|
2016-07-26 09:18:16 +08:00
|
|
|
PLOG(FATAL) << "couldn't fork init inside the PID namespace for " << service_name;
|
2016-04-22 06:35:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (child_pid > 0) {
|
|
|
|
// So that we exit with the right status.
|
|
|
|
static int init_exitstatus = 0;
|
|
|
|
signal(SIGTERM, [](int) { _exit(init_exitstatus); });
|
|
|
|
|
|
|
|
pid_t waited_pid;
|
|
|
|
int status;
|
|
|
|
while ((waited_pid = wait(&status)) > 0) {
|
|
|
|
// This loop will end when there are no processes left inside the
|
|
|
|
// PID namespace or when the init process inside the PID namespace
|
|
|
|
// gets a signal.
|
|
|
|
if (waited_pid == child_pid) {
|
|
|
|
init_exitstatus = status;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!WIFEXITED(init_exitstatus)) {
|
|
|
|
_exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
_exit(WEXITSTATUS(init_exitstatus));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-09 01:32:26 +08:00
|
|
|
static void ExpandArgs(const std::vector<std::string>& args, std::vector<char*>* strs) {
|
|
|
|
std::vector<std::string> expanded_args;
|
|
|
|
expanded_args.resize(args.size());
|
|
|
|
strs->push_back(const_cast<char*>(args[0].c_str()));
|
|
|
|
for (std::size_t i = 1; i < args.size(); ++i) {
|
|
|
|
if (!expand_props(args[i], &expanded_args[i])) {
|
|
|
|
LOG(FATAL) << args[0] << ": cannot expand '" << args[i] << "'";
|
|
|
|
}
|
|
|
|
strs->push_back(const_cast<char*>(expanded_args[i].c_str()));
|
|
|
|
}
|
|
|
|
strs->push_back(nullptr);
|
|
|
|
}
|
|
|
|
|
2015-08-01 03:45:25 +08:00
|
|
|
SocketInfo::SocketInfo() : uid(0), gid(0), perm(0) {
|
|
|
|
}
|
|
|
|
|
|
|
|
SocketInfo::SocketInfo(const std::string& name, const std::string& type, uid_t uid,
|
|
|
|
gid_t gid, int perm, const std::string& socketcon)
|
|
|
|
: name(name), type(type), uid(uid), gid(gid), perm(perm), socketcon(socketcon) {
|
|
|
|
}
|
|
|
|
|
|
|
|
ServiceEnvironmentInfo::ServiceEnvironmentInfo() {
|
|
|
|
}
|
|
|
|
|
|
|
|
ServiceEnvironmentInfo::ServiceEnvironmentInfo(const std::string& name,
|
|
|
|
const std::string& value)
|
|
|
|
: name(name), value(value) {
|
|
|
|
}
|
|
|
|
|
|
|
|
Service::Service(const std::string& name, const std::string& classname,
|
|
|
|
const std::vector<std::string>& args)
|
|
|
|
: name_(name), classname_(classname), flags_(0), pid_(0), time_started_(0),
|
2016-04-22 06:35:09 +08:00
|
|
|
time_crashed_(0), nr_crashed_(0), uid_(0), gid_(0), namespace_flags_(0),
|
|
|
|
seclabel_(""), ioprio_class_(IoSchedClass_NONE), ioprio_pri_(0),
|
2016-07-23 03:07:06 +08:00
|
|
|
priority_(0), oom_score_adjust_(-1000), args_(args) {
|
2015-08-01 03:45:25 +08:00
|
|
|
onrestart_.InitSingleTrigger("onrestart");
|
|
|
|
}
|
|
|
|
|
|
|
|
Service::Service(const std::string& name, const std::string& classname,
|
2016-04-22 06:35:09 +08:00
|
|
|
unsigned flags, uid_t uid, gid_t gid,
|
|
|
|
const std::vector<gid_t>& supp_gids, unsigned namespace_flags,
|
|
|
|
const std::string& seclabel,
|
|
|
|
const std::vector<std::string>& args)
|
|
|
|
: name_(name), classname_(classname), flags_(flags), pid_(0),
|
|
|
|
time_started_(0), time_crashed_(0), nr_crashed_(0), uid_(uid), gid_(gid),
|
|
|
|
supp_gids_(supp_gids), namespace_flags_(namespace_flags),
|
|
|
|
seclabel_(seclabel), ioprio_class_(IoSchedClass_NONE), ioprio_pri_(0),
|
2016-07-23 03:07:06 +08:00
|
|
|
priority_(0), oom_score_adjust_(-1000), args_(args) {
|
2015-08-01 03:45:25 +08:00
|
|
|
onrestart_.InitSingleTrigger("onrestart");
|
|
|
|
}
|
|
|
|
|
|
|
|
void Service::NotifyStateChange(const std::string& new_state) const {
|
|
|
|
if ((flags_ & SVC_EXEC) != 0) {
|
|
|
|
// 'exec' commands don't have properties tracking their state.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-08-27 02:43:36 +08:00
|
|
|
std::string prop_name = StringPrintf("init.svc.%s", name_.c_str());
|
2015-08-01 03:45:25 +08:00
|
|
|
if (prop_name.length() >= PROP_NAME_MAX) {
|
|
|
|
// If the property name would be too long, we can't set it.
|
2016-06-25 06:12:21 +08:00
|
|
|
LOG(ERROR) << "Property name \"init.svc." << name_ << "\" too long; not setting to " << new_state;
|
2015-08-01 03:45:25 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
property_set(prop_name.c_str(), new_state.c_str());
|
|
|
|
}
|
|
|
|
|
2016-06-16 05:49:57 +08:00
|
|
|
void Service::KillProcessGroup(int signal) {
|
2016-08-03 05:20:40 +08:00
|
|
|
LOG(INFO) << "Sending signal " << signal
|
|
|
|
<< " to service '" << name_
|
|
|
|
<< "' (pid " << pid_ << ") process group...";
|
|
|
|
if (killProcessGroup(uid_, pid_, signal) == -1) {
|
|
|
|
PLOG(ERROR) << "killProcessGroup(" << uid_ << ", " << pid_ << ", " << signal << ") failed";
|
|
|
|
}
|
|
|
|
if (kill(-pid_, signal) == -1) {
|
|
|
|
PLOG(ERROR) << "kill(" << pid_ << ", " << signal << ") failed";
|
|
|
|
}
|
2016-06-16 05:49:57 +08:00
|
|
|
}
|
|
|
|
|
2016-07-09 01:32:26 +08:00
|
|
|
void Service::CreateSockets(const std::string& context) {
|
|
|
|
for (const auto& si : sockets_) {
|
|
|
|
int socket_type = ((si.type == "stream" ? SOCK_STREAM :
|
|
|
|
(si.type == "dgram" ? SOCK_DGRAM :
|
|
|
|
SOCK_SEQPACKET)));
|
|
|
|
const char* socketcon = !si.socketcon.empty() ? si.socketcon.c_str() : context.c_str();
|
|
|
|
|
|
|
|
int s = create_socket(si.name.c_str(), socket_type, si.perm, si.uid, si.gid, socketcon);
|
|
|
|
if (s >= 0) {
|
|
|
|
PublishSocket(si.name, s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Service::SetProcessAttributes() {
|
2016-07-26 09:18:16 +08:00
|
|
|
// TODO: work out why this fails for `console` then upgrade to FATAL.
|
|
|
|
if (setpgid(0, getpid()) == -1) PLOG(ERROR) << "setpgid failed for " << name_;
|
2016-07-09 01:32:26 +08:00
|
|
|
|
|
|
|
if (gid_) {
|
|
|
|
if (setgid(gid_) != 0) {
|
2016-07-26 09:18:16 +08:00
|
|
|
PLOG(FATAL) << "setgid failed for " << name_;
|
2016-07-09 01:32:26 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!supp_gids_.empty()) {
|
|
|
|
if (setgroups(supp_gids_.size(), &supp_gids_[0]) != 0) {
|
2016-07-26 09:18:16 +08:00
|
|
|
PLOG(FATAL) << "setgroups failed for " << name_;
|
2016-07-09 01:32:26 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (uid_) {
|
|
|
|
if (setuid(uid_) != 0) {
|
2016-07-26 09:18:16 +08:00
|
|
|
PLOG(FATAL) << "setuid failed for " << name_;
|
2016-07-09 01:32:26 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!seclabel_.empty()) {
|
|
|
|
if (setexeccon(seclabel_.c_str()) < 0) {
|
2016-07-26 09:18:16 +08:00
|
|
|
PLOG(FATAL) << "cannot setexeccon('" << seclabel_ << "') for " << name_;
|
2016-07-09 01:32:26 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (priority_ != 0) {
|
|
|
|
if (setpriority(PRIO_PROCESS, 0, priority_) != 0) {
|
2016-07-26 09:18:16 +08:00
|
|
|
PLOG(FATAL) << "setpriority failed for " << name_;
|
2016-07-09 01:32:26 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-01 03:45:25 +08:00
|
|
|
bool Service::Reap() {
|
|
|
|
if (!(flags_ & SVC_ONESHOT) || (flags_ & SVC_RESTART)) {
|
2016-06-16 05:49:57 +08:00
|
|
|
KillProcessGroup(SIGKILL);
|
2015-08-01 03:45:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Remove any sockets we may have created.
|
|
|
|
for (const auto& si : sockets_) {
|
2015-08-27 02:43:36 +08:00
|
|
|
std::string tmp = StringPrintf(ANDROID_SOCKET_DIR "/%s", si.name.c_str());
|
2015-08-01 03:45:25 +08:00
|
|
|
unlink(tmp.c_str());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags_ & SVC_EXEC) {
|
2016-06-25 06:12:21 +08:00
|
|
|
LOG(INFO) << "SVC_EXEC pid " << pid_ << " finished...";
|
2015-08-01 03:45:25 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
pid_ = 0;
|
|
|
|
flags_ &= (~SVC_RUNNING);
|
|
|
|
|
|
|
|
// Oneshot processes go into the disabled state on exit,
|
|
|
|
// except when manually restarted.
|
|
|
|
if ((flags_ & SVC_ONESHOT) && !(flags_ & SVC_RESTART)) {
|
|
|
|
flags_ |= SVC_DISABLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Disabled and reset processes do not get restarted automatically.
|
|
|
|
if (flags_ & (SVC_DISABLED | SVC_RESET)) {
|
|
|
|
NotifyStateChange("stopped");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
time_t now = gettime();
|
|
|
|
if ((flags_ & SVC_CRITICAL) && !(flags_ & SVC_RESTART)) {
|
|
|
|
if (time_crashed_ + CRITICAL_CRASH_WINDOW >= now) {
|
|
|
|
if (++nr_crashed_ > CRITICAL_CRASH_THRESHOLD) {
|
2016-06-25 06:12:21 +08:00
|
|
|
LOG(ERROR) << "critical process '" << name_ << "' exited "
|
|
|
|
<< CRITICAL_CRASH_THRESHOLD << " times in "
|
|
|
|
<< (CRITICAL_CRASH_WINDOW / 60) << " minutes; "
|
|
|
|
<< "rebooting into recovery mode";
|
2015-08-01 03:45:25 +08:00
|
|
|
android_reboot(ANDROID_RB_RESTART2, 0, "recovery");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
time_crashed_ = now;
|
|
|
|
nr_crashed_ = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
flags_ &= (~SVC_RESTART);
|
|
|
|
flags_ |= SVC_RESTARTING;
|
|
|
|
|
|
|
|
// Execute all onrestart commands for this service.
|
|
|
|
onrestart_.ExecuteAllCommands();
|
|
|
|
|
|
|
|
NotifyStateChange("restarting");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Service::DumpState() const {
|
2016-06-25 06:12:21 +08:00
|
|
|
LOG(INFO) << "service " << name_;
|
|
|
|
LOG(INFO) << " class '" << classname_ << "'";
|
|
|
|
LOG(INFO) << " exec "<< android::base::Join(args_, " ");
|
2015-08-01 03:45:25 +08:00
|
|
|
for (const auto& si : sockets_) {
|
2016-06-25 06:12:21 +08:00
|
|
|
LOG(INFO) << " socket " << si.name << " " << si.type << " " << std::oct << si.perm;
|
2015-08-01 03:45:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
bool Service::ParseClass(const std::vector<std::string>& args, std::string* err) {
|
2015-08-27 02:43:36 +08:00
|
|
|
classname_ = args[1];
|
|
|
|
return true;
|
|
|
|
}
|
2015-08-01 03:45:25 +08:00
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
bool Service::ParseConsole(const std::vector<std::string>& args, std::string* err) {
|
2015-08-27 02:43:36 +08:00
|
|
|
flags_ |= SVC_CONSOLE;
|
2016-03-21 16:08:07 +08:00
|
|
|
console_ = args.size() > 1 ? "/dev/" + args[1] : "";
|
2015-08-27 02:43:36 +08:00
|
|
|
return true;
|
|
|
|
}
|
2015-08-01 03:45:25 +08:00
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
bool Service::ParseCritical(const std::vector<std::string>& args, std::string* err) {
|
2015-08-27 02:43:36 +08:00
|
|
|
flags_ |= SVC_CRITICAL;
|
|
|
|
return true;
|
|
|
|
}
|
2015-08-01 03:45:25 +08:00
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
bool Service::ParseDisabled(const std::vector<std::string>& args, std::string* err) {
|
2015-08-27 02:43:36 +08:00
|
|
|
flags_ |= SVC_DISABLED;
|
|
|
|
flags_ |= SVC_RC_DISABLED;
|
|
|
|
return true;
|
|
|
|
}
|
2015-08-01 03:45:25 +08:00
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
bool Service::ParseGroup(const std::vector<std::string>& args, std::string* err) {
|
2015-08-27 02:43:36 +08:00
|
|
|
gid_ = decode_uid(args[1].c_str());
|
|
|
|
for (std::size_t n = 2; n < args.size(); n++) {
|
|
|
|
supp_gids_.emplace_back(decode_uid(args[n].c_str()));
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
2015-08-01 03:45:25 +08:00
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
bool Service::ParsePriority(const std::vector<std::string>& args, std::string* err) {
|
2016-10-12 08:09:00 +08:00
|
|
|
priority_ = 0;
|
|
|
|
if (!ParseInt(args[1], &priority_,
|
|
|
|
static_cast<int>(ANDROID_PRIORITY_LOWEST),
|
|
|
|
static_cast<int>(ANDROID_PRIORITY_HIGHEST))) {
|
2016-05-19 08:36:30 +08:00
|
|
|
*err = StringPrintf("process priority value must be range %d - %d",
|
|
|
|
ANDROID_PRIORITY_HIGHEST, ANDROID_PRIORITY_LOWEST);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
bool Service::ParseIoprio(const std::vector<std::string>& args, std::string* err) {
|
2016-10-12 08:09:00 +08:00
|
|
|
if (!ParseInt(args[2], &ioprio_pri_, 0, 7)) {
|
2015-08-27 02:43:36 +08:00
|
|
|
*err = "priority value must be range 0 - 7";
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (args[1] == "rt") {
|
|
|
|
ioprio_class_ = IoSchedClass_RT;
|
|
|
|
} else if (args[1] == "be") {
|
|
|
|
ioprio_class_ = IoSchedClass_BE;
|
|
|
|
} else if (args[1] == "idle") {
|
|
|
|
ioprio_class_ = IoSchedClass_IDLE;
|
|
|
|
} else {
|
|
|
|
*err = "ioprio option usage: ioprio <rt|be|idle> <0-7>";
|
|
|
|
return false;
|
2015-08-01 03:45:25 +08:00
|
|
|
}
|
|
|
|
|
2015-08-27 02:43:36 +08:00
|
|
|
return true;
|
|
|
|
}
|
2015-08-01 03:45:25 +08:00
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
bool Service::ParseKeycodes(const std::vector<std::string>& args, std::string* err) {
|
2015-08-27 02:43:36 +08:00
|
|
|
for (std::size_t i = 1; i < args.size(); i++) {
|
2016-10-12 08:09:00 +08:00
|
|
|
int code;
|
|
|
|
if (ParseInt(args[i], &code)) {
|
|
|
|
keycodes_.emplace_back(code);
|
|
|
|
} else {
|
|
|
|
LOG(WARNING) << "ignoring invalid keycode: " << args[i];
|
|
|
|
}
|
2015-08-01 03:45:25 +08:00
|
|
|
}
|
2015-08-27 02:43:36 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
bool Service::ParseOneshot(const std::vector<std::string>& args, std::string* err) {
|
2015-08-27 02:43:36 +08:00
|
|
|
flags_ |= SVC_ONESHOT;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
bool Service::ParseOnrestart(const std::vector<std::string>& args, std::string* err) {
|
2015-08-27 02:43:36 +08:00
|
|
|
std::vector<std::string> str_args(args.begin() + 1, args.end());
|
|
|
|
onrestart_.AddCommand(str_args, "", 0, err);
|
|
|
|
return true;
|
|
|
|
}
|
2015-08-01 03:45:25 +08:00
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
bool Service::ParseNamespace(const std::vector<std::string>& args, std::string* err) {
|
2016-04-22 06:35:09 +08:00
|
|
|
for (size_t i = 1; i < args.size(); i++) {
|
|
|
|
if (args[i] == "pid") {
|
|
|
|
namespace_flags_ |= CLONE_NEWPID;
|
|
|
|
// PID namespaces require mount namespaces.
|
|
|
|
namespace_flags_ |= CLONE_NEWNS;
|
|
|
|
} else if (args[i] == "mnt") {
|
|
|
|
namespace_flags_ |= CLONE_NEWNS;
|
|
|
|
} else {
|
|
|
|
*err = "namespace must be 'pid' or 'mnt'";
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-07-23 03:07:06 +08:00
|
|
|
bool Service::ParseOomScoreAdjust(const std::vector<std::string>& args, std::string* err) {
|
2016-10-12 08:09:00 +08:00
|
|
|
if (!ParseInt(args[1], &oom_score_adjust_, -1000, 1000)) {
|
2016-07-23 03:07:06 +08:00
|
|
|
*err = "oom_score_adjust value must be in range -1000 - +1000";
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
bool Service::ParseSeclabel(const std::vector<std::string>& args, std::string* err) {
|
2015-08-27 02:43:36 +08:00
|
|
|
seclabel_ = args[1];
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
bool Service::ParseSetenv(const std::vector<std::string>& args, std::string* err) {
|
2015-08-27 02:43:36 +08:00
|
|
|
envvars_.emplace_back(args[1], args[2]);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* name type perm [ uid gid context ] */
|
2016-06-30 02:32:49 +08:00
|
|
|
bool Service::ParseSocket(const std::vector<std::string>& args, std::string* err) {
|
2015-08-27 02:43:36 +08:00
|
|
|
if (args[2] != "dgram" && args[2] != "stream" && args[2] != "seqpacket") {
|
|
|
|
*err = "socket type must be 'dgram', 'stream' or 'seqpacket'";
|
2015-08-01 03:45:25 +08:00
|
|
|
return false;
|
|
|
|
}
|
2015-08-27 02:43:36 +08:00
|
|
|
|
2016-10-12 08:09:00 +08:00
|
|
|
int perm = std::strtoul(args[3].c_str(), 0, 8);
|
2015-08-27 02:43:36 +08:00
|
|
|
uid_t uid = args.size() > 4 ? decode_uid(args[4].c_str()) : 0;
|
|
|
|
gid_t gid = args.size() > 5 ? decode_uid(args[5].c_str()) : 0;
|
|
|
|
std::string socketcon = args.size() > 6 ? args[6] : "";
|
|
|
|
|
|
|
|
sockets_.emplace_back(args[1], args[2], uid, gid, perm, socketcon);
|
2015-08-01 03:45:25 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
bool Service::ParseUser(const std::vector<std::string>& args, std::string* err) {
|
2015-08-27 02:43:36 +08:00
|
|
|
uid_ = decode_uid(args[1].c_str());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
bool Service::ParseWritepid(const std::vector<std::string>& args, std::string* err) {
|
2015-08-27 02:43:36 +08:00
|
|
|
writepid_files_.assign(args.begin() + 1, args.end());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
class Service::OptionParserMap : public KeywordMap<OptionParser> {
|
2015-08-27 02:43:36 +08:00
|
|
|
public:
|
2016-06-30 02:32:49 +08:00
|
|
|
OptionParserMap() {
|
2015-08-27 02:43:36 +08:00
|
|
|
}
|
|
|
|
private:
|
|
|
|
Map& map() const override;
|
|
|
|
};
|
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
Service::OptionParserMap::Map& Service::OptionParserMap::map() const {
|
2015-08-27 02:43:36 +08:00
|
|
|
constexpr std::size_t kMax = std::numeric_limits<std::size_t>::max();
|
2016-06-30 02:32:49 +08:00
|
|
|
static const Map option_parsers = {
|
|
|
|
{"class", {1, 1, &Service::ParseClass}},
|
|
|
|
{"console", {0, 1, &Service::ParseConsole}},
|
|
|
|
{"critical", {0, 0, &Service::ParseCritical}},
|
|
|
|
{"disabled", {0, 0, &Service::ParseDisabled}},
|
|
|
|
{"group", {1, NR_SVC_SUPP_GIDS + 1, &Service::ParseGroup}},
|
|
|
|
{"ioprio", {2, 2, &Service::ParseIoprio}},
|
|
|
|
{"priority", {1, 1, &Service::ParsePriority}},
|
|
|
|
{"keycodes", {1, kMax, &Service::ParseKeycodes}},
|
|
|
|
{"oneshot", {0, 0, &Service::ParseOneshot}},
|
|
|
|
{"onrestart", {1, kMax, &Service::ParseOnrestart}},
|
2016-07-23 03:07:06 +08:00
|
|
|
{"oom_score_adjust",
|
|
|
|
{1, 1, &Service::ParseOomScoreAdjust}},
|
2016-06-30 02:32:49 +08:00
|
|
|
{"namespace", {1, 2, &Service::ParseNamespace}},
|
|
|
|
{"seclabel", {1, 1, &Service::ParseSeclabel}},
|
|
|
|
{"setenv", {2, 2, &Service::ParseSetenv}},
|
|
|
|
{"socket", {3, 6, &Service::ParseSocket}},
|
|
|
|
{"user", {1, 1, &Service::ParseUser}},
|
|
|
|
{"writepid", {1, kMax, &Service::ParseWritepid}},
|
2015-08-27 02:43:36 +08:00
|
|
|
};
|
2016-06-30 02:32:49 +08:00
|
|
|
return option_parsers;
|
2015-08-27 02:43:36 +08:00
|
|
|
}
|
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
bool Service::ParseLine(const std::vector<std::string>& args, std::string* err) {
|
2015-08-27 02:43:36 +08:00
|
|
|
if (args.empty()) {
|
|
|
|
*err = "option needed, but not provided";
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
static const OptionParserMap parser_map;
|
|
|
|
auto parser = parser_map.FindFunction(args[0], args.size() - 1, err);
|
2015-08-27 02:43:36 +08:00
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
if (!parser) {
|
2015-08-27 02:43:36 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-06-30 02:32:49 +08:00
|
|
|
return (this->*parser)(args, err);
|
2015-08-27 02:43:36 +08:00
|
|
|
}
|
|
|
|
|
2016-04-13 06:38:27 +08:00
|
|
|
bool Service::Start() {
|
2015-08-01 03:45:25 +08:00
|
|
|
// Starting a service removes it from the disabled or reset state and
|
|
|
|
// immediately takes it out of the restarting state if it was in there.
|
|
|
|
flags_ &= (~(SVC_DISABLED|SVC_RESTARTING|SVC_RESET|SVC_RESTART|SVC_DISABLED_START));
|
|
|
|
time_started_ = 0;
|
|
|
|
|
|
|
|
// Running processes require no additional work --- if they're in the
|
|
|
|
// process of exiting, we've ensured that they will immediately restart
|
|
|
|
// on exit, unless they are ONESHOT.
|
|
|
|
if (flags_ & SVC_RUNNING) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool needs_console = (flags_ & SVC_CONSOLE);
|
2016-03-21 16:08:07 +08:00
|
|
|
if (needs_console) {
|
|
|
|
if (console_.empty()) {
|
|
|
|
console_ = default_console;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool have_console = (open(console_.c_str(), O_RDWR | O_CLOEXEC) != -1);
|
|
|
|
if (!have_console) {
|
2016-06-25 06:12:21 +08:00
|
|
|
PLOG(ERROR) << "service '" << name_ << "' couldn't open console '" << console_ << "'";
|
2016-03-21 16:08:07 +08:00
|
|
|
flags_ |= SVC_DISABLED;
|
|
|
|
return false;
|
|
|
|
}
|
2015-08-01 03:45:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
struct stat sb;
|
|
|
|
if (stat(args_[0].c_str(), &sb) == -1) {
|
2016-06-25 06:12:21 +08:00
|
|
|
PLOG(ERROR) << "cannot find '" << args_[0] << "', disabling '" << name_ << "'";
|
2015-08-01 03:45:25 +08:00
|
|
|
flags_ |= SVC_DISABLED;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string scon;
|
|
|
|
if (!seclabel_.empty()) {
|
|
|
|
scon = seclabel_;
|
|
|
|
} else {
|
2016-07-09 01:32:26 +08:00
|
|
|
LOG(INFO) << "computing context for service '" << name_ << "'";
|
|
|
|
scon = ComputeContextFromExecutable(name_, args_[0]);
|
|
|
|
if (scon == "") {
|
2015-08-01 03:45:25 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-05 05:05:39 +08:00
|
|
|
LOG(INFO) << "starting service '" << name_ << "'...";
|
2015-08-01 03:45:25 +08:00
|
|
|
|
2016-04-22 06:35:09 +08:00
|
|
|
pid_t pid = -1;
|
|
|
|
if (namespace_flags_) {
|
2016-07-09 01:32:26 +08:00
|
|
|
pid = clone(nullptr, nullptr, namespace_flags_ | SIGCHLD, nullptr);
|
2016-04-22 06:35:09 +08:00
|
|
|
} else {
|
|
|
|
pid = fork();
|
|
|
|
}
|
|
|
|
|
2015-08-01 03:45:25 +08:00
|
|
|
if (pid == 0) {
|
|
|
|
umask(077);
|
|
|
|
|
2016-04-22 06:35:09 +08:00
|
|
|
if (namespace_flags_ & CLONE_NEWPID) {
|
|
|
|
// This will fork again to run an init process inside the PID
|
|
|
|
// namespace.
|
|
|
|
SetUpPidNamespace(name_);
|
|
|
|
}
|
|
|
|
|
2015-08-01 03:45:25 +08:00
|
|
|
for (const auto& ei : envvars_) {
|
|
|
|
add_environment(ei.name.c_str(), ei.value.c_str());
|
|
|
|
}
|
|
|
|
|
2016-07-09 01:32:26 +08:00
|
|
|
CreateSockets(scon);
|
2015-08-01 03:45:25 +08:00
|
|
|
|
2016-02-05 22:38:48 +08:00
|
|
|
std::string pid_str = StringPrintf("%d", getpid());
|
2015-08-01 03:45:25 +08:00
|
|
|
for (const auto& file : writepid_files_) {
|
2015-08-27 02:43:36 +08:00
|
|
|
if (!WriteStringToFile(pid_str, file)) {
|
2016-06-25 06:12:21 +08:00
|
|
|
PLOG(ERROR) << "couldn't write " << pid_str << " to " << file;
|
2015-08-01 03:45:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ioprio_class_ != IoSchedClass_NONE) {
|
|
|
|
if (android_set_ioprio(getpid(), ioprio_class_, ioprio_pri_)) {
|
2016-07-09 01:32:26 +08:00
|
|
|
PLOG(ERROR) << "failed to set pid " << getpid()
|
2016-06-25 06:12:21 +08:00
|
|
|
<< " ioprio=" << ioprio_class_ << "," << ioprio_pri_;
|
2015-08-01 03:45:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (needs_console) {
|
|
|
|
setsid();
|
|
|
|
OpenConsole();
|
|
|
|
} else {
|
|
|
|
ZapStdio();
|
|
|
|
}
|
|
|
|
|
2016-07-09 01:32:26 +08:00
|
|
|
// As requested, set our gid, supplemental gids, uid, context, and
|
|
|
|
// priority. Aborts on failure.
|
|
|
|
SetProcessAttributes();
|
2015-08-01 03:45:25 +08:00
|
|
|
|
|
|
|
std::vector<char*> strs;
|
2016-07-09 01:32:26 +08:00
|
|
|
ExpandArgs(args_, &strs);
|
2016-06-08 02:22:00 +08:00
|
|
|
if (execve(strs[0], (char**) &strs[0], (char**) ENV) < 0) {
|
2016-06-25 06:12:21 +08:00
|
|
|
PLOG(ERROR) << "cannot execve('" << strs[0] << "')";
|
2015-08-01 03:45:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
_exit(127);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pid < 0) {
|
2016-06-25 06:12:21 +08:00
|
|
|
PLOG(ERROR) << "failed to fork for '" << name_ << "'";
|
2015-08-01 03:45:25 +08:00
|
|
|
pid_ = 0;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-07-23 03:07:06 +08:00
|
|
|
if (oom_score_adjust_ != -1000) {
|
|
|
|
std::string oom_str = StringPrintf("%d", oom_score_adjust_);
|
|
|
|
std::string oom_file = StringPrintf("/proc/%d/oom_score_adj", pid);
|
|
|
|
if (!WriteStringToFile(oom_str, oom_file)) {
|
|
|
|
PLOG(ERROR) << "couldn't write oom_score_adj: " << strerror(errno);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-01 03:45:25 +08:00
|
|
|
time_started_ = gettime();
|
|
|
|
pid_ = pid;
|
|
|
|
flags_ |= SVC_RUNNING;
|
2016-06-16 05:49:57 +08:00
|
|
|
|
|
|
|
errno = -createProcessGroup(uid_, pid_);
|
|
|
|
if (errno != 0) {
|
2016-07-09 01:32:26 +08:00
|
|
|
PLOG(ERROR) << "createProcessGroup(" << uid_ << ", " << pid_ << ") failed for service '"
|
|
|
|
<< name_ << "'";
|
2016-06-16 05:49:57 +08:00
|
|
|
}
|
2015-08-01 03:45:25 +08:00
|
|
|
|
|
|
|
if ((flags_ & SVC_EXEC) != 0) {
|
2016-07-09 01:32:26 +08:00
|
|
|
LOG(INFO) << android::base::StringPrintf(
|
|
|
|
"SVC_EXEC pid %d (uid %d gid %d+%zu context %s) started; waiting...", pid_, uid_, gid_,
|
|
|
|
supp_gids_.size(), !seclabel_.empty() ? seclabel_.c_str() : "default");
|
2015-08-01 03:45:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
NotifyStateChange("running");
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Service::StartIfNotDisabled() {
|
|
|
|
if (!(flags_ & SVC_DISABLED)) {
|
|
|
|
return Start();
|
|
|
|
} else {
|
|
|
|
flags_ |= SVC_DISABLED_START;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Service::Enable() {
|
|
|
|
flags_ &= ~(SVC_DISABLED | SVC_RC_DISABLED);
|
|
|
|
if (flags_ & SVC_DISABLED_START) {
|
|
|
|
return Start();
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Service::Reset() {
|
|
|
|
StopOrReset(SVC_RESET);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Service::Stop() {
|
|
|
|
StopOrReset(SVC_DISABLED);
|
|
|
|
}
|
|
|
|
|
2015-12-19 03:39:59 +08:00
|
|
|
void Service::Terminate() {
|
|
|
|
flags_ &= ~(SVC_RESTARTING | SVC_DISABLED_START);
|
|
|
|
flags_ |= SVC_DISABLED;
|
|
|
|
if (pid_) {
|
2016-06-16 05:49:57 +08:00
|
|
|
KillProcessGroup(SIGTERM);
|
2015-12-19 03:39:59 +08:00
|
|
|
NotifyStateChange("stopping");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-01 03:45:25 +08:00
|
|
|
void Service::Restart() {
|
|
|
|
if (flags_ & SVC_RUNNING) {
|
|
|
|
/* Stop, wait, then start the service. */
|
|
|
|
StopOrReset(SVC_RESTART);
|
|
|
|
} else if (!(flags_ & SVC_RESTARTING)) {
|
|
|
|
/* Just start the service since it's not running. */
|
|
|
|
Start();
|
|
|
|
} /* else: Service is restarting anyways. */
|
|
|
|
}
|
|
|
|
|
|
|
|
void Service::RestartIfNeeded(time_t& process_needs_restart) {
|
|
|
|
time_t next_start_time = time_started_ + 5;
|
|
|
|
|
|
|
|
if (next_start_time <= gettime()) {
|
|
|
|
flags_ &= (~SVC_RESTARTING);
|
|
|
|
Start();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((next_start_time < process_needs_restart) ||
|
|
|
|
(process_needs_restart == 0)) {
|
|
|
|
process_needs_restart = next_start_time;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-16 05:49:57 +08:00
|
|
|
// The how field should be either SVC_DISABLED, SVC_RESET, or SVC_RESTART.
|
2015-08-01 03:45:25 +08:00
|
|
|
void Service::StopOrReset(int how) {
|
2016-06-16 05:49:57 +08:00
|
|
|
// The service is still SVC_RUNNING until its process exits, but if it has
|
|
|
|
// already exited it shoudn't attempt a restart yet.
|
2015-08-01 03:45:25 +08:00
|
|
|
flags_ &= ~(SVC_RESTARTING | SVC_DISABLED_START);
|
|
|
|
|
|
|
|
if ((how != SVC_DISABLED) && (how != SVC_RESET) && (how != SVC_RESTART)) {
|
2016-06-16 05:49:57 +08:00
|
|
|
// An illegal flag: default to SVC_DISABLED.
|
2015-08-01 03:45:25 +08:00
|
|
|
how = SVC_DISABLED;
|
|
|
|
}
|
2016-06-16 05:49:57 +08:00
|
|
|
|
|
|
|
// If the service has not yet started, prevent it from auto-starting with its class.
|
2015-08-01 03:45:25 +08:00
|
|
|
if (how == SVC_RESET) {
|
|
|
|
flags_ |= (flags_ & SVC_RC_DISABLED) ? SVC_DISABLED : SVC_RESET;
|
|
|
|
} else {
|
|
|
|
flags_ |= how;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pid_) {
|
2016-06-16 05:49:57 +08:00
|
|
|
KillProcessGroup(SIGKILL);
|
2015-08-01 03:45:25 +08:00
|
|
|
NotifyStateChange("stopping");
|
|
|
|
} else {
|
|
|
|
NotifyStateChange("stopped");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Service::ZapStdio() const {
|
|
|
|
int fd;
|
|
|
|
fd = open("/dev/null", O_RDWR);
|
|
|
|
dup2(fd, 0);
|
|
|
|
dup2(fd, 1);
|
|
|
|
dup2(fd, 2);
|
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Service::OpenConsole() const {
|
2016-03-21 16:08:07 +08:00
|
|
|
int fd = open(console_.c_str(), O_RDWR);
|
|
|
|
if (fd == -1) fd = open("/dev/null", O_RDWR);
|
2015-08-01 03:45:25 +08:00
|
|
|
ioctl(fd, TIOCSCTTY, 0);
|
|
|
|
dup2(fd, 0);
|
|
|
|
dup2(fd, 1);
|
|
|
|
dup2(fd, 2);
|
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Service::PublishSocket(const std::string& name, int fd) const {
|
2015-08-27 02:43:36 +08:00
|
|
|
std::string key = StringPrintf(ANDROID_SOCKET_ENV_PREFIX "%s", name.c_str());
|
|
|
|
std::string val = StringPrintf("%d", fd);
|
2015-08-01 03:45:25 +08:00
|
|
|
add_environment(key.c_str(), val.c_str());
|
|
|
|
|
|
|
|
/* make sure we don't close-on-exec */
|
|
|
|
fcntl(fd, F_SETFD, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
int ServiceManager::exec_count_ = 0;
|
|
|
|
|
|
|
|
ServiceManager::ServiceManager() {
|
|
|
|
}
|
|
|
|
|
|
|
|
ServiceManager& ServiceManager::GetInstance() {
|
|
|
|
static ServiceManager instance;
|
|
|
|
return instance;
|
|
|
|
}
|
|
|
|
|
2015-08-27 02:43:36 +08:00
|
|
|
void ServiceManager::AddService(std::unique_ptr<Service> service) {
|
|
|
|
Service* old_service = FindServiceByName(service->name());
|
|
|
|
if (old_service) {
|
2016-06-25 06:12:21 +08:00
|
|
|
LOG(ERROR) << "ignored duplicate definition of service '" << service->name() << "'";
|
2015-08-27 02:43:36 +08:00
|
|
|
return;
|
2015-08-01 03:45:25 +08:00
|
|
|
}
|
2015-08-27 02:43:36 +08:00
|
|
|
services_.emplace_back(std::move(service));
|
2015-08-01 03:45:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
Service* ServiceManager::MakeExecOneshotService(const std::vector<std::string>& args) {
|
|
|
|
// Parse the arguments: exec [SECLABEL [UID [GID]*] --] COMMAND ARGS...
|
|
|
|
// SECLABEL can be a - to denote default
|
|
|
|
std::size_t command_arg = 1;
|
|
|
|
for (std::size_t i = 1; i < args.size(); ++i) {
|
|
|
|
if (args[i] == "--") {
|
|
|
|
command_arg = i + 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (command_arg > 4 + NR_SVC_SUPP_GIDS) {
|
2016-06-25 06:12:21 +08:00
|
|
|
LOG(ERROR) << "exec called with too many supplementary group ids";
|
2015-08-01 03:45:25 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (command_arg >= args.size()) {
|
2016-06-25 06:12:21 +08:00
|
|
|
LOG(ERROR) << "exec called without command";
|
2015-08-01 03:45:25 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
std::vector<std::string> str_args(args.begin() + command_arg, args.end());
|
|
|
|
|
|
|
|
exec_count_++;
|
2015-08-27 02:43:36 +08:00
|
|
|
std::string name = StringPrintf("exec %d (%s)", exec_count_, str_args[0].c_str());
|
2015-08-01 03:45:25 +08:00
|
|
|
unsigned flags = SVC_EXEC | SVC_ONESHOT;
|
2016-04-22 06:35:09 +08:00
|
|
|
unsigned namespace_flags = 0;
|
2015-08-01 03:45:25 +08:00
|
|
|
|
|
|
|
std::string seclabel = "";
|
|
|
|
if (command_arg > 2 && args[1] != "-") {
|
|
|
|
seclabel = args[1];
|
|
|
|
}
|
|
|
|
uid_t uid = 0;
|
|
|
|
if (command_arg > 3) {
|
|
|
|
uid = decode_uid(args[2].c_str());
|
|
|
|
}
|
|
|
|
gid_t gid = 0;
|
|
|
|
std::vector<gid_t> supp_gids;
|
|
|
|
if (command_arg > 4) {
|
|
|
|
gid = decode_uid(args[3].c_str());
|
|
|
|
std::size_t nr_supp_gids = command_arg - 1 /* -- */ - 4 /* exec SECLABEL UID GID */;
|
|
|
|
for (size_t i = 0; i < nr_supp_gids; ++i) {
|
|
|
|
supp_gids.push_back(decode_uid(args[4 + i].c_str()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<Service> svc_p(new Service(name, "default", flags, uid, gid,
|
2016-04-22 06:35:09 +08:00
|
|
|
supp_gids, namespace_flags,
|
|
|
|
seclabel, str_args));
|
2015-08-01 03:45:25 +08:00
|
|
|
if (!svc_p) {
|
2016-06-25 06:12:21 +08:00
|
|
|
LOG(ERROR) << "Couldn't allocate service for exec of '" << str_args[0] << "'";
|
2015-08-01 03:45:25 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
Service* svc = svc_p.get();
|
|
|
|
services_.push_back(std::move(svc_p));
|
|
|
|
|
|
|
|
return svc;
|
|
|
|
}
|
|
|
|
|
|
|
|
Service* ServiceManager::FindServiceByName(const std::string& name) const {
|
|
|
|
auto svc = std::find_if(services_.begin(), services_.end(),
|
|
|
|
[&name] (const std::unique_ptr<Service>& s) {
|
|
|
|
return name == s->name();
|
|
|
|
});
|
|
|
|
if (svc != services_.end()) {
|
|
|
|
return svc->get();
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
Service* ServiceManager::FindServiceByPid(pid_t pid) const {
|
|
|
|
auto svc = std::find_if(services_.begin(), services_.end(),
|
|
|
|
[&pid] (const std::unique_ptr<Service>& s) {
|
|
|
|
return s->pid() == pid;
|
|
|
|
});
|
|
|
|
if (svc != services_.end()) {
|
|
|
|
return svc->get();
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
Service* ServiceManager::FindServiceByKeychord(int keychord_id) const {
|
|
|
|
auto svc = std::find_if(services_.begin(), services_.end(),
|
|
|
|
[&keychord_id] (const std::unique_ptr<Service>& s) {
|
|
|
|
return s->keychord_id() == keychord_id;
|
|
|
|
});
|
|
|
|
|
|
|
|
if (svc != services_.end()) {
|
|
|
|
return svc->get();
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2016-07-28 07:25:51 +08:00
|
|
|
void ServiceManager::ForEachService(const std::function<void(Service*)>& callback) const {
|
2015-08-01 03:45:25 +08:00
|
|
|
for (const auto& s : services_) {
|
2015-12-19 03:39:59 +08:00
|
|
|
callback(s.get());
|
2015-08-01 03:45:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ServiceManager::ForEachServiceInClass(const std::string& classname,
|
|
|
|
void (*func)(Service* svc)) const {
|
|
|
|
for (const auto& s : services_) {
|
|
|
|
if (classname == s->classname()) {
|
|
|
|
func(s.get());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ServiceManager::ForEachServiceWithFlags(unsigned matchflags,
|
|
|
|
void (*func)(Service* svc)) const {
|
|
|
|
for (const auto& s : services_) {
|
|
|
|
if (s->flags() & matchflags) {
|
|
|
|
func(s.get());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-27 02:43:36 +08:00
|
|
|
void ServiceManager::RemoveService(const Service& svc) {
|
2015-08-01 03:45:25 +08:00
|
|
|
auto svc_it = std::find_if(services_.begin(), services_.end(),
|
|
|
|
[&svc] (const std::unique_ptr<Service>& s) {
|
|
|
|
return svc.name() == s->name();
|
|
|
|
});
|
|
|
|
if (svc_it == services_.end()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
services_.erase(svc_it);
|
|
|
|
}
|
|
|
|
|
2015-08-27 02:43:36 +08:00
|
|
|
void ServiceManager::DumpState() const {
|
|
|
|
for (const auto& s : services_) {
|
|
|
|
s->DumpState();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-19 03:39:59 +08:00
|
|
|
bool ServiceManager::ReapOneProcess() {
|
|
|
|
int status;
|
|
|
|
pid_t pid = TEMP_FAILURE_RETRY(waitpid(-1, &status, WNOHANG));
|
|
|
|
if (pid == 0) {
|
|
|
|
return false;
|
|
|
|
} else if (pid == -1) {
|
2016-06-25 06:12:21 +08:00
|
|
|
PLOG(ERROR) << "waitpid failed";
|
2015-12-19 03:39:59 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
Service* svc = FindServiceByPid(pid);
|
|
|
|
|
|
|
|
std::string name;
|
|
|
|
if (svc) {
|
|
|
|
name = android::base::StringPrintf("Service '%s' (pid %d)",
|
|
|
|
svc->name().c_str(), pid);
|
|
|
|
} else {
|
|
|
|
name = android::base::StringPrintf("Untracked pid %d", pid);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (WIFEXITED(status)) {
|
2016-10-05 05:05:39 +08:00
|
|
|
LOG(INFO) << name << " exited with status " << WEXITSTATUS(status);
|
2015-12-19 03:39:59 +08:00
|
|
|
} else if (WIFSIGNALED(status)) {
|
2016-10-05 05:05:39 +08:00
|
|
|
LOG(INFO) << name << " killed by signal " << WTERMSIG(status);
|
2015-12-19 03:39:59 +08:00
|
|
|
} else if (WIFSTOPPED(status)) {
|
2016-10-05 05:05:39 +08:00
|
|
|
LOG(INFO) << name << " stopped by signal " << WSTOPSIG(status);
|
2015-12-19 03:39:59 +08:00
|
|
|
} else {
|
2016-10-05 05:05:39 +08:00
|
|
|
LOG(INFO) << name << " state changed";
|
2015-12-19 03:39:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!svc) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (svc->Reap()) {
|
|
|
|
waiting_for_exec = false;
|
|
|
|
RemoveService(*svc);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ServiceManager::ReapAnyOutstandingChildren() {
|
|
|
|
while (ReapOneProcess()) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-27 02:43:36 +08:00
|
|
|
bool ServiceParser::ParseSection(const std::vector<std::string>& args,
|
|
|
|
std::string* err) {
|
|
|
|
if (args.size() < 3) {
|
|
|
|
*err = "services must have a name and a program";
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
const std::string& name = args[1];
|
|
|
|
if (!IsValidName(name)) {
|
|
|
|
*err = StringPrintf("invalid service name '%s'", name.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<std::string> str_args(args.begin() + 2, args.end());
|
|
|
|
service_ = std::make_unique<Service>(name, "default", str_args);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ServiceParser::ParseLineSection(const std::vector<std::string>& args,
|
|
|
|
const std::string& filename, int line,
|
|
|
|
std::string* err) const {
|
2016-06-30 02:32:49 +08:00
|
|
|
return service_ ? service_->ParseLine(args, err) : false;
|
2015-08-27 02:43:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void ServiceParser::EndSection() {
|
|
|
|
if (service_) {
|
|
|
|
ServiceManager::GetInstance().AddService(std::move(service_));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ServiceParser::IsValidName(const std::string& name) const {
|
2016-09-20 11:58:20 +08:00
|
|
|
return is_legal_property_name("init.svc." + name);
|
2015-08-01 03:45:25 +08:00
|
|
|
}
|