init/service_utils.cpp - platform/system/core - Git at Google

 /*
  * Copyright (C) 2019 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_utils.h"

 #include <grp.h>
 #include <sys/mount.h>
 #include <sys/prctl.h>
 #include <sys/wait.h>

 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/properties.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
 #include <cutils/android_get_control_file.h>
 #include <cutils/sockets.h>
 #include <processgroup/processgroup.h>

 #include "mount_namespace.h"
 #include "util.h"

 using android::base::GetProperty;
 using android::base::StartsWith;
 using android::base::StringPrintf;
 using android::base::unique_fd;
 using android::base::WriteStringToFile;

 namespace android {
 namespace init {

 namespace {

 Result<void> EnterNamespace(int nstype, const char* path) {
     auto fd = unique_fd{open(path, O_RDONLY | O_CLOEXEC)};
     if (fd == -1) {
         return ErrnoError() << "Could not open namespace at " << path;
     }
     if (setns(fd, nstype) == -1) {
         return ErrnoError() << "Could not setns() namespace at " << path;
     }
     return {};
 }

 Result<void> SetUpMountNamespace(bool remount_proc, bool remount_sys) {
     constexpr unsigned int kSafeFlags = MS_NODEV | MS_NOEXEC | MS_NOSUID;

     // Recursively remount / as slave like zygote does so unmounting and mounting /proc
     // doesn't interfere with the parent namespace's /proc mount. This will also
     // prevent any other mounts/unmounts initiated by the service from interfering
     // with the parent namespace but will still allow mount events from the parent
     // namespace to propagate to the child.
     if (mount("rootfs", "/", nullptr, (MS_SLAVE | MS_REC), nullptr) == -1) {
         return ErrnoError() << "Could not remount(/) recursively as slave";
     }

     // umount() then mount() /proc and/or /sys
     // Note that it is not sufficient to mount with MS_REMOUNT.
     if (remount_proc) {
         if (umount("/proc") == -1) {
             return ErrnoError() << "Could not umount(/proc)";
         }
         if (mount("", "/proc", "proc", kSafeFlags, "") == -1) {
             return ErrnoError() << "Could not mount(/proc)";
         }
     }
     if (remount_sys) {
         if (umount2("/sys", MNT_DETACH) == -1) {
             return ErrnoError() << "Could not umount(/sys)";
         }
         if (mount("", "/sys", "sysfs", kSafeFlags, "") == -1) {
             return ErrnoError() << "Could not mount(/sys)";
         }
     }
     return {};
 }

 Result<void> SetUpPidNamespace(const char* name) {
     if (prctl(PR_SET_NAME, name) == -1) {
         return ErrnoError() << "Could not set name";
     }

     pid_t child_pid = fork();
     if (child_pid == -1) {
         return ErrnoError() << "Could not fork init inside the PID namespace";
     }

     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));
     }
     return {};
 }

 void ZapStdio() {
     auto fd = unique_fd{open("/dev/null", O_RDWR | O_CLOEXEC)};
     dup2(fd, 0);
     dup2(fd, 1);
     dup2(fd, 2);
 }

 void OpenConsole(const std::string& console) {
     auto fd = unique_fd{open(console.c_str(), O_RDWR | O_CLOEXEC)};
     if (fd == -1) fd.reset(open("/dev/null", O_RDWR | O_CLOEXEC));
     ioctl(fd, TIOCSCTTY, 0);
     dup2(fd, 0);
     dup2(fd, 1);
     dup2(fd, 2);
 }

 void PublishDescriptor(const std::string& key, const std::string& name, int fd) {
     std::string published_name = key + name;
     for (auto& c : published_name) {
         c = isalnum(c) ? c : '_';
     }

     std::string val = std::to_string(fd);
     setenv(published_name.c_str(), val.c_str(), 1);
 }

 }  // namespace

 Result<void> SocketDescriptor::CreateAndPublish(const std::string& global_context) const {
     const auto& socket_context = context.empty() ? global_context : context;
     auto result = CreateSocket(name, type, passcred, perm, uid, gid, socket_context);
     if (!result) {
         return result.error();
     }

     PublishDescriptor(ANDROID_SOCKET_ENV_PREFIX, name, *result);

     return {};
 }

 Result<void> FileDescriptor::CreateAndPublish() const {
     int flags = (type == "r") ? O_RDONLY : (type == "w") ? O_WRONLY : O_RDWR;

     // Make sure we do not block on open (eg: devices can chose to block on carrier detect).  Our
     // intention is never to delay launch of a service for such a condition.  The service can
     // perform its own blocking on carrier detect.
     android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(name.c_str(), flags | O_NONBLOCK)));

     if (fd < 0) {
         return ErrnoError() << "Failed to open file '" << name << "'";
     }

     // Fixup as we set O_NONBLOCK for open, the intent for fd is to block reads.
     fcntl(fd, F_SETFL, flags);

     LOG(INFO) << "Opened file '" << name << "', flags " << flags;

     PublishDescriptor(ANDROID_FILE_ENV_PREFIX, name, fd.release());

     return {};
 }

 Result<void> EnterNamespaces(const NamespaceInfo& info, const std::string& name, bool pre_apexd) {
     for (const auto& [nstype, path] : info.namespaces_to_enter) {
         if (auto result = EnterNamespace(nstype, path.c_str()); !result) {
             return result;
         }
     }

 #if defined(__ANDROID__)
     if (pre_apexd) {
         if (!SwitchToBootstrapMountNamespaceIfNeeded()) {
             return Error() << "could not enter into the bootstrap mount namespace";
         }
     }
 #endif

     if (info.flags & CLONE_NEWNS) {
         bool remount_proc = info.flags & CLONE_NEWPID;
         bool remount_sys =
                 std::any_of(info.namespaces_to_enter.begin(), info.namespaces_to_enter.end(),
                             [](const auto& entry) { return entry.first == CLONE_NEWNET; });
         if (auto result = SetUpMountNamespace(remount_proc, remount_sys); !result) {
             return result;
         }
     }

     if (info.flags & CLONE_NEWPID) {
         // This will fork again to run an init process inside the PID namespace.
         if (auto result = SetUpPidNamespace(name.c_str()); !result) {
             return result;
         }
     }

     return {};
 }

 Result<void> SetProcessAttributes(const ProcessAttributes& attr) {
     if (attr.ioprio_class != IoSchedClass_NONE) {
         if (android_set_ioprio(getpid(), attr.ioprio_class, attr.ioprio_pri)) {
             PLOG(ERROR) << "failed to set pid " << getpid() << " ioprio=" << attr.ioprio_class
                         << "," << attr.ioprio_pri;
         }
     }

     if (!attr.console.empty()) {
         setsid();
         OpenConsole(attr.console);
     } else {
         if (setpgid(0, getpid()) == -1) {
             return ErrnoError() << "setpgid failed";
         }
         ZapStdio();
     }

     for (const auto& rlimit : attr.rlimits) {
         if (setrlimit(rlimit.first, &rlimit.second) == -1) {
             return ErrnoError() << StringPrintf(
                            "setrlimit(%d, {rlim_cur=%ld, rlim_max=%ld}) failed", rlimit.first,
                            rlimit.second.rlim_cur, rlimit.second.rlim_max);
         }
     }

     if (attr.gid) {
         if (setgid(attr.gid) != 0) {
             return ErrnoError() << "setgid failed";
         }
     }
     if (setgroups(attr.supp_gids.size(), const_cast<gid_t*>(&attr.supp_gids[0])) != 0) {
         return ErrnoError() << "setgroups failed";
     }
     if (attr.uid) {
         if (setuid(attr.uid) != 0) {
             return ErrnoError() << "setuid failed";
         }
     }

     if (attr.priority != 0) {
         if (setpriority(PRIO_PROCESS, 0, attr.priority) != 0) {
             return ErrnoError() << "setpriority failed";
         }
     }
     return {};
 }

 Result<void> WritePidToFiles(std::vector<std::string>* files) {
     // See if there were "writepid" instructions to write to files under cpuset path.
     std::string cpuset_path;
     if (CgroupGetControllerPath("cpuset", &cpuset_path)) {
         auto cpuset_predicate = [&cpuset_path](const std::string& path) {
             return StartsWith(path, cpuset_path + "/");
         };
         auto iter = std::find_if(files->begin(), files->end(), cpuset_predicate);
         if (iter == files->end()) {
             // There were no "writepid" instructions for cpusets, check if the system default
             // cpuset is specified to be used for the process.
             std::string default_cpuset = GetProperty("ro.cpuset.default", "");
             if (!default_cpuset.empty()) {
                 // Make sure the cpuset name starts and ends with '/'.
                 // A single '/' means the 'root' cpuset.
                 if (default_cpuset.front() != '/') {
                     default_cpuset.insert(0, 1, '/');
                 }
                 if (default_cpuset.back() != '/') {
                     default_cpuset.push_back('/');
                 }
                 files->push_back(
                         StringPrintf("%s%stasks", cpuset_path.c_str(), default_cpuset.c_str()));
             }
         }
     } else {
         LOG(ERROR) << "cpuset cgroup controller is not mounted!";
     }
     std::string pid_str = std::to_string(getpid());
     for (const auto& file : *files) {
         if (!WriteStringToFile(pid_str, file)) {
             return ErrnoError() << "couldn't write " << pid_str << " to " << file;
         }
     }
     return {};
 }

 }  // namespace init
 }  // namespace android
	/*
	* Copyright (C) 2019 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_utils.h"

	#include <grp.h>
	#include <sys/mount.h>
	#include <sys/prctl.h>
	#include <sys/wait.h>

	#include <android-base/file.h>
	#include <android-base/logging.h>
	#include <android-base/properties.h>
	#include <android-base/stringprintf.h>
	#include <android-base/strings.h>
	#include <android-base/unique_fd.h>
	#include <cutils/android_get_control_file.h>
	#include <cutils/sockets.h>
	#include <processgroup/processgroup.h>

	#include "mount_namespace.h"
	#include "util.h"

	using android::base::GetProperty;
	using android::base::StartsWith;
	using android::base::StringPrintf;
	using android::base::unique_fd;
	using android::base::WriteStringToFile;

	namespace android {
	namespace init {

	namespace {

	Result<void> EnterNamespace(int nstype, const char* path) {
	auto fd = unique_fd{open(path, O_RDONLY \| O_CLOEXEC)};
	if (fd == -1) {
	return ErrnoError() << "Could not open namespace at " << path;
	}
	if (setns(fd, nstype) == -1) {
	return ErrnoError() << "Could not setns() namespace at " << path;
	}
	return {};
	}

	Result<void> SetUpMountNamespace(bool remount_proc, bool remount_sys) {
	constexpr unsigned int kSafeFlags = MS_NODEV \| MS_NOEXEC \| MS_NOSUID;

	// Recursively remount / as slave like zygote does so unmounting and mounting /proc
	// doesn't interfere with the parent namespace's /proc mount. This will also
	// prevent any other mounts/unmounts initiated by the service from interfering
	// with the parent namespace but will still allow mount events from the parent
	// namespace to propagate to the child.
	if (mount("rootfs", "/", nullptr, (MS_SLAVE \| MS_REC), nullptr) == -1) {
	return ErrnoError() << "Could not remount(/) recursively as slave";
	}

	// umount() then mount() /proc and/or /sys
	// Note that it is not sufficient to mount with MS_REMOUNT.
	if (remount_proc) {
	if (umount("/proc") == -1) {
	return ErrnoError() << "Could not umount(/proc)";
	}
	if (mount("", "/proc", "proc", kSafeFlags, "") == -1) {
	return ErrnoError() << "Could not mount(/proc)";
	}
	}
	if (remount_sys) {
	if (umount2("/sys", MNT_DETACH) == -1) {
	return ErrnoError() << "Could not umount(/sys)";
	}
	if (mount("", "/sys", "sysfs", kSafeFlags, "") == -1) {
	return ErrnoError() << "Could not mount(/sys)";
	}
	}
	return {};
	}

	Result<void> SetUpPidNamespace(const char* name) {
	if (prctl(PR_SET_NAME, name) == -1) {
	return ErrnoError() << "Could not set name";
	}

	pid_t child_pid = fork();
	if (child_pid == -1) {
	return ErrnoError() << "Could not fork init inside the PID namespace";
	}

	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));
	}
	return {};
	}

	void ZapStdio() {
	auto fd = unique_fd{open("/dev/null", O_RDWR \| O_CLOEXEC)};
	dup2(fd, 0);
	dup2(fd, 1);
	dup2(fd, 2);
	}

	void OpenConsole(const std::string& console) {
	auto fd = unique_fd{open(console.c_str(), O_RDWR \| O_CLOEXEC)};
	if (fd == -1) fd.reset(open("/dev/null", O_RDWR \| O_CLOEXEC));
	ioctl(fd, TIOCSCTTY, 0);
	dup2(fd, 0);
	dup2(fd, 1);
	dup2(fd, 2);
	}

	void PublishDescriptor(const std::string& key, const std::string& name, int fd) {
	std::string published_name = key + name;
	for (auto& c : published_name) {
	c = isalnum(c) ? c : '_';
	}

	std::string val = std::to_string(fd);
	setenv(published_name.c_str(), val.c_str(), 1);
	}

	} // namespace

	Result<void> SocketDescriptor::CreateAndPublish(const std::string& global_context) const {
	const auto& socket_context = context.empty() ? global_context : context;
	auto result = CreateSocket(name, type, passcred, perm, uid, gid, socket_context);
	if (!result) {
	return result.error();
	}

	PublishDescriptor(ANDROID_SOCKET_ENV_PREFIX, name, *result);

	return {};
	}

	Result<void> FileDescriptor::CreateAndPublish() const {
	int flags = (type == "r") ? O_RDONLY : (type == "w") ? O_WRONLY : O_RDWR;

	// Make sure we do not block on open (eg: devices can chose to block on carrier detect). Our
	// intention is never to delay launch of a service for such a condition. The service can
	// perform its own blocking on carrier detect.
	android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(name.c_str(), flags \| O_NONBLOCK)));

	if (fd < 0) {
	return ErrnoError() << "Failed to open file '" << name << "'";
	}

	// Fixup as we set O_NONBLOCK for open, the intent for fd is to block reads.
	fcntl(fd, F_SETFL, flags);

	LOG(INFO) << "Opened file '" << name << "', flags " << flags;

	PublishDescriptor(ANDROID_FILE_ENV_PREFIX, name, fd.release());

	return {};
	}

	Result<void> EnterNamespaces(const NamespaceInfo& info, const std::string& name, bool pre_apexd) {
	for (const auto& [nstype, path] : info.namespaces_to_enter) {
	if (auto result = EnterNamespace(nstype, path.c_str()); !result) {
	return result;
	}
	}

	#if defined(__ANDROID__)
	if (pre_apexd) {
	if (!SwitchToBootstrapMountNamespaceIfNeeded()) {
	return Error() << "could not enter into the bootstrap mount namespace";
	}
	}
	#endif

	if (info.flags & CLONE_NEWNS) {
	bool remount_proc = info.flags & CLONE_NEWPID;
	bool remount_sys =
	std::any_of(info.namespaces_to_enter.begin(), info.namespaces_to_enter.end(),
	[](const auto& entry) { return entry.first == CLONE_NEWNET; });
	if (auto result = SetUpMountNamespace(remount_proc, remount_sys); !result) {
	return result;
	}
	}

	if (info.flags & CLONE_NEWPID) {
	// This will fork again to run an init process inside the PID namespace.
	if (auto result = SetUpPidNamespace(name.c_str()); !result) {
	return result;
	}
	}

	return {};
	}

	Result<void> SetProcessAttributes(const ProcessAttributes& attr) {
	if (attr.ioprio_class != IoSchedClass_NONE) {
	if (android_set_ioprio(getpid(), attr.ioprio_class, attr.ioprio_pri)) {
	PLOG(ERROR) << "failed to set pid " << getpid() << " ioprio=" << attr.ioprio_class
	<< "," << attr.ioprio_pri;
	}
	}

	if (!attr.console.empty()) {
	setsid();
	OpenConsole(attr.console);
	} else {
	if (setpgid(0, getpid()) == -1) {
	return ErrnoError() << "setpgid failed";
	}
	ZapStdio();
	}

	for (const auto& rlimit : attr.rlimits) {
	if (setrlimit(rlimit.first, &rlimit.second) == -1) {
	return ErrnoError() << StringPrintf(
	"setrlimit(%d, {rlim_cur=%ld, rlim_max=%ld}) failed", rlimit.first,
	rlimit.second.rlim_cur, rlimit.second.rlim_max);
	}
	}

	if (attr.gid) {
	if (setgid(attr.gid) != 0) {
	return ErrnoError() << "setgid failed";
	}
	}
	if (setgroups(attr.supp_gids.size(), const_cast<gid_t*>(&attr.supp_gids[0])) != 0) {
	return ErrnoError() << "setgroups failed";
	}
	if (attr.uid) {
	if (setuid(attr.uid) != 0) {
	return ErrnoError() << "setuid failed";
	}
	}

	if (attr.priority != 0) {
	if (setpriority(PRIO_PROCESS, 0, attr.priority) != 0) {
	return ErrnoError() << "setpriority failed";
	}
	}
	return {};
	}

	Result<void> WritePidToFiles(std::vector<std::string>* files) {
	// See if there were "writepid" instructions to write to files under cpuset path.
	std::string cpuset_path;
	if (CgroupGetControllerPath("cpuset", &cpuset_path)) {
	auto cpuset_predicate = [&cpuset_path](const std::string& path) {
	return StartsWith(path, cpuset_path + "/");
	};
	auto iter = std::find_if(files->begin(), files->end(), cpuset_predicate);
	if (iter == files->end()) {
	// There were no "writepid" instructions for cpusets, check if the system default
	// cpuset is specified to be used for the process.
	std::string default_cpuset = GetProperty("ro.cpuset.default", "");
	if (!default_cpuset.empty()) {
	// Make sure the cpuset name starts and ends with '/'.
	// A single '/' means the 'root' cpuset.
	if (default_cpuset.front() != '/') {
	default_cpuset.insert(0, 1, '/');
	}
	if (default_cpuset.back() != '/') {
	default_cpuset.push_back('/');
	}
	files->push_back(
	StringPrintf("%s%stasks", cpuset_path.c_str(), default_cpuset.c_str()));
	}
	}
	} else {
	LOG(ERROR) << "cpuset cgroup controller is not mounted!";
	}
	std::string pid_str = std::to_string(getpid());
	for (const auto& file : *files) {
	if (!WriteStringToFile(pid_str, file)) {
	return ErrnoError() << "couldn't write " << pid_str << " to " << file;
	}
	}
	return {};
	}

	} // namespace init
	} // namespace android