Colin Cross | 9c5366b | 2010-04-13 19:48:59 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2010 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 | |
Luis Hector Chavez | 9f97f47 | 2017-09-06 13:43:57 -0700 | [diff] [blame] | 17 | #include "sigchld_handler.h" |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 18 | |
Elliott Hughes | 8d82ea0 | 2015-02-06 20:15:18 -0800 | [diff] [blame] | 19 | #include <signal.h> |
Tom Cherry | 3f5eaae5 | 2017-04-06 16:30:22 -0700 | [diff] [blame] | 20 | #include <string.h> |
Colin Cross | 9c5366b | 2010-04-13 19:48:59 -0700 | [diff] [blame] | 21 | #include <sys/socket.h> |
Elliott Hughes | da40c00 | 2015-03-27 23:20:44 -0700 | [diff] [blame] | 22 | #include <sys/types.h> |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 23 | #include <sys/wait.h> |
Elliott Hughes | da40c00 | 2015-03-27 23:20:44 -0700 | [diff] [blame] | 24 | #include <unistd.h> |
| 25 | |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 26 | #include <android-base/chrono_utils.h> |
Tom Cherry | 3f5eaae5 | 2017-04-06 16:30:22 -0700 | [diff] [blame] | 27 | #include <android-base/logging.h> |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 28 | #include <android-base/scopeguard.h> |
| 29 | #include <android-base/stringprintf.h> |
Colin Cross | 9c5366b | 2010-04-13 19:48:59 -0700 | [diff] [blame] | 30 | |
Nikita Ioffe | 3f4b0d6 | 2019-10-09 15:23:02 +0100 | [diff] [blame] | 31 | #include <thread> |
| 32 | |
Colin Cross | 9c5366b | 2010-04-13 19:48:59 -0700 | [diff] [blame] | 33 | #include "init.h" |
Tom Cherry | bac3299 | 2015-07-31 12:45:25 -0700 | [diff] [blame] | 34 | #include "service.h" |
Tom Cherry | 2aeb1ad | 2019-06-26 10:46:20 -0700 | [diff] [blame] | 35 | #include "service_list.h" |
Colin Cross | 9c5366b | 2010-04-13 19:48:59 -0700 | [diff] [blame] | 36 | |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 37 | using android::base::boot_clock; |
| 38 | using android::base::make_scope_guard; |
Nikita Ioffe | 3f4b0d6 | 2019-10-09 15:23:02 +0100 | [diff] [blame] | 39 | using android::base::StringPrintf; |
| 40 | using android::base::Timer; |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 41 | |
Tom Cherry | 81f5d3e | 2017-06-22 12:53:17 -0700 | [diff] [blame] | 42 | namespace android { |
| 43 | namespace init { |
| 44 | |
Nikita Ioffe | 3f4b0d6 | 2019-10-09 15:23:02 +0100 | [diff] [blame] | 45 | static pid_t ReapOneProcess() { |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 46 | siginfo_t siginfo = {}; |
| 47 | // This returns a zombie pid or informs us that there are no zombies left to be reaped. |
| 48 | // It does NOT reap the pid; that is done below. |
| 49 | if (TEMP_FAILURE_RETRY(waitid(P_ALL, 0, &siginfo, WEXITED | WNOHANG | WNOWAIT)) != 0) { |
| 50 | PLOG(ERROR) << "waitid failed"; |
Nikita Ioffe | 3f4b0d6 | 2019-10-09 15:23:02 +0100 | [diff] [blame] | 51 | return 0; |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 52 | } |
| 53 | |
| 54 | auto pid = siginfo.si_pid; |
Nikita Ioffe | 3f4b0d6 | 2019-10-09 15:23:02 +0100 | [diff] [blame] | 55 | if (pid == 0) return 0; |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 56 | |
| 57 | // At this point we know we have a zombie pid, so we use this scopeguard to reap the pid |
| 58 | // whenever the function returns from this point forward. |
| 59 | // We do NOT want to reap the zombie earlier as in Service::Reap(), we kill(-pid, ...) and we |
| 60 | // want the pid to remain valid throughout that (and potentially future) usages. |
| 61 | auto reaper = make_scope_guard([pid] { TEMP_FAILURE_RETRY(waitpid(pid, nullptr, WNOHANG)); }); |
| 62 | |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 63 | std::string name; |
| 64 | std::string wait_string; |
Tom Cherry | cb0f9bb | 2017-09-12 15:58:47 -0700 | [diff] [blame] | 65 | Service* service = nullptr; |
| 66 | |
Tom Cherry | fe81541 | 2019-04-23 15:11:07 -0700 | [diff] [blame] | 67 | if (SubcontextChildReap(pid)) { |
Tom Cherry | cb0f9bb | 2017-09-12 15:58:47 -0700 | [diff] [blame] | 68 | name = "Subcontext"; |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 69 | } else { |
Tom Cherry | cb0f9bb | 2017-09-12 15:58:47 -0700 | [diff] [blame] | 70 | service = ServiceList::GetInstance().FindService(pid, &Service::pid); |
| 71 | |
| 72 | if (service) { |
| 73 | name = StringPrintf("Service '%s' (pid %d)", service->name().c_str(), pid); |
| 74 | if (service->flags() & SVC_EXEC) { |
| 75 | auto exec_duration = boot_clock::now() - service->time_started(); |
| 76 | auto exec_duration_ms = |
| 77 | std::chrono::duration_cast<std::chrono::milliseconds>(exec_duration).count(); |
| 78 | wait_string = StringPrintf(" waiting took %f seconds", exec_duration_ms / 1000.0f); |
Wei Wang | f7c2bfe | 2019-07-31 11:35:18 -0700 | [diff] [blame] | 79 | } else if (service->flags() & SVC_ONESHOT) { |
| 80 | auto exec_duration = boot_clock::now() - service->time_started(); |
| 81 | auto exec_duration_ms = |
| 82 | std::chrono::duration_cast<std::chrono::milliseconds>(exec_duration) |
| 83 | .count(); |
| 84 | wait_string = StringPrintf(" oneshot service took %f seconds in background", |
| 85 | exec_duration_ms / 1000.0f); |
Tom Cherry | cb0f9bb | 2017-09-12 15:58:47 -0700 | [diff] [blame] | 86 | } |
| 87 | } else { |
| 88 | name = StringPrintf("Untracked pid %d", pid); |
| 89 | } |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 90 | } |
| 91 | |
Paul Crowley | c73b215 | 2018-04-13 17:38:57 +0000 | [diff] [blame] | 92 | if (siginfo.si_code == CLD_EXITED) { |
| 93 | LOG(INFO) << name << " exited with status " << siginfo.si_status << wait_string; |
| 94 | } else { |
| 95 | LOG(INFO) << name << " received signal " << siginfo.si_status << wait_string; |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 96 | } |
| 97 | |
David Anderson | 0fa7c40 | 2022-03-07 19:10:57 -0800 | [diff] [blame] | 98 | if (!service) { |
| 99 | LOG(INFO) << name << " did not have an associated service entry and will not be reaped"; |
| 100 | return pid; |
| 101 | } |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 102 | |
Paul Crowley | c73b215 | 2018-04-13 17:38:57 +0000 | [diff] [blame] | 103 | service->Reap(siginfo); |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 104 | |
| 105 | if (service->flags() & SVC_TEMPORARY) { |
Tom Cherry | 911b9b1 | 2017-07-27 16:20:58 -0700 | [diff] [blame] | 106 | ServiceList::GetInstance().RemoveService(*service); |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 107 | } |
| 108 | |
Nikita Ioffe | 3f4b0d6 | 2019-10-09 15:23:02 +0100 | [diff] [blame] | 109 | return pid; |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 110 | } |
| 111 | |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 112 | void ReapAnyOutstandingChildren() { |
Nikita Ioffe | 3f4b0d6 | 2019-10-09 15:23:02 +0100 | [diff] [blame] | 113 | while (ReapOneProcess() != 0) { |
Tom Cherry | eeee831 | 2017-07-28 15:22:23 -0700 | [diff] [blame] | 114 | } |
| 115 | } |
| 116 | |
Nikita Ioffe | 3f4b0d6 | 2019-10-09 15:23:02 +0100 | [diff] [blame] | 117 | void WaitToBeReaped(const std::vector<pid_t>& pids, std::chrono::milliseconds timeout) { |
| 118 | Timer t; |
| 119 | std::vector<pid_t> alive_pids(pids.begin(), pids.end()); |
| 120 | while (!alive_pids.empty() && t.duration() < timeout) { |
| 121 | pid_t pid; |
| 122 | while ((pid = ReapOneProcess()) != 0) { |
| 123 | auto it = std::find(alive_pids.begin(), alive_pids.end(), pid); |
| 124 | if (it != alive_pids.end()) { |
| 125 | alive_pids.erase(it); |
| 126 | } |
| 127 | } |
| 128 | if (alive_pids.empty()) { |
| 129 | break; |
| 130 | } |
| 131 | std::this_thread::sleep_for(50ms); |
| 132 | } |
| 133 | LOG(INFO) << "Waiting for " << pids.size() << " pids to be reaped took " << t << " with " |
| 134 | << alive_pids.size() << " of them still running"; |
| 135 | } |
| 136 | |
Tom Cherry | 81f5d3e | 2017-06-22 12:53:17 -0700 | [diff] [blame] | 137 | } // namespace init |
| 138 | } // namespace android |