blob: bac9e4890322d302a5ba6aafb08690fda3c5cb14 [file] [log] [blame]
Alex Deymoaea4c1c2015-08-19 20:24:43 -07001//
2// Copyright (C) 2011 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//
adlr@google.com3defe6a2009-12-04 20:57:17 +000016
Alex Deymo39910dc2015-11-09 17:04:30 -080017#ifndef UPDATE_ENGINE_COMMON_SUBPROCESS_H_
18#define UPDATE_ENGINE_COMMON_SUBPROCESS_H_
adlr@google.com3defe6a2009-12-04 20:57:17 +000019
Alex Deymo461b2592015-07-24 20:10:52 -070020#include <unistd.h>
Ben Chan05735a12014-09-03 07:48:22 -070021
adlr@google.com3defe6a2009-12-04 20:57:17 +000022#include <map>
Alex Deymobc91a272014-05-20 16:45:33 -070023#include <memory>
adlr@google.com3defe6a2009-12-04 20:57:17 +000024#include <string>
25#include <vector>
Darin Petkov6f03a3b2010-11-10 14:27:14 -080026
Alex Deymo461b2592015-07-24 20:10:52 -070027#include <base/callback.h>
Hidehiko Abe493fecb2019-07-10 23:30:50 +090028#include <base/files/file_descriptor_watcher_posix.h>
Ben Chan05735a12014-09-03 07:48:22 -070029#include <base/logging.h>
30#include <base/macros.h>
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -070031#include <brillo/asynchronous_signal_handler_interface.h>
32#include <brillo/message_loops/message_loop.h>
33#include <brillo/process.h>
34#include <brillo/process_reaper.h>
Alex Deymo60ca1a72015-06-18 18:19:15 -070035#include <gtest/gtest_prod.h> // for FRIEND_TEST
adlr@google.com3defe6a2009-12-04 20:57:17 +000036
37// The Subprocess class is a singleton. It's used to spawn off a subprocess
38// and get notified when the subprocess exits. The result of Exec() can
Alex Deymo29b81532015-07-09 11:51:49 -070039// be saved and used to cancel the callback request and kill your process. If
40// you know you won't call KillExec(), you may safely lose the return value
41// from Exec().
adlr@google.com3defe6a2009-12-04 20:57:17 +000042
Alex Deymo461b2592015-07-24 20:10:52 -070043// To create the Subprocess singleton just instantiate it with and call Init().
44// You can't have two Subprocess instances initialized at the same time.
45
adlr@google.com3defe6a2009-12-04 20:57:17 +000046namespace chromeos_update_engine {
47
48class Subprocess {
49 public:
Alex Deymo461b2592015-07-24 20:10:52 -070050 enum Flags {
51 kSearchPath = 1 << 0,
52 kRedirectStderrToStdout = 1 << 1,
53 };
Darin Petkov6f03a3b2010-11-10 14:27:14 -080054
Alex Deymo461b2592015-07-24 20:10:52 -070055 // Callback type used when an async process terminates. It receives the exit
56 // code and the stdout output (and stderr if redirected).
57 using ExecCallback = base::Callback<void(int, const std::string&)>;
adlr@google.com3defe6a2009-12-04 20:57:17 +000058
Alex Deymo461b2592015-07-24 20:10:52 -070059 Subprocess() = default;
60
61 // Destroy and unregister the Subprocess singleton.
62 ~Subprocess();
63
64 // Initialize and register the Subprocess singleton.
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -070065 void Init(brillo::AsynchronousSignalHandlerInterface* async_signal_handler);
Alex Deymo461b2592015-07-24 20:10:52 -070066
67 // Launches a process in the background and calls the passed |callback| when
Alex Deymoe384bb22016-03-29 17:23:33 -070068 // the process exits. The file descriptors specified in |output_pipes| will
69 // be available in the child as the writer end of a pipe. Use GetPipeFd() to
70 // know the reader end in the parent. Only stdin, stdout, stderr and the file
71 // descriptors in |output_pipes| will be open in the child.
Alex Deymo461b2592015-07-24 20:10:52 -070072 // Returns the process id of the new launched process or 0 in case of failure.
73 pid_t Exec(const std::vector<std::string>& cmd, const ExecCallback& callback);
74 pid_t ExecFlags(const std::vector<std::string>& cmd,
75 uint32_t flags,
Alex Deymoe384bb22016-03-29 17:23:33 -070076 const std::vector<int>& output_pipes,
Alex Deymo461b2592015-07-24 20:10:52 -070077 const ExecCallback& callback);
adlr@google.com3defe6a2009-12-04 20:57:17 +000078
Alex Deymo29b81532015-07-09 11:51:49 -070079 // Kills the running process with SIGTERM and ignores the callback.
Alex Deymoe384bb22016-03-29 17:23:33 -070080 void KillExec(pid_t pid);
81
82 // Return the parent end of the pipe mapped onto |fd| in the child |pid|. This
83 // file descriptor is available until the callback for the child |pid|
84 // returns. After that the file descriptor will be closed. The passed |fd|
85 // must be one of the file descriptors passed to ExecFlags() in
86 // |output_pipes|, otherwise returns -1.
87 int GetPipeFd(pid_t pid, int fd) const;
adlr@google.com3defe6a2009-12-04 20:57:17 +000088
Darin Petkov85d02b72011-05-17 13:25:51 -070089 // Executes a command synchronously. Returns true on success. If |stdout| is
90 // non-null, the process output is stored in it, otherwise the output is
91 // logged. Note that stderr is redirected to stdout.
adlr@google.com3defe6a2009-12-04 20:57:17 +000092 static bool SynchronousExec(const std::vector<std::string>& cmd,
Darin Petkov85d02b72011-05-17 13:25:51 -070093 int* return_code,
94 std::string* stdout);
Alex Deymo461b2592015-07-24 20:10:52 -070095 static bool SynchronousExecFlags(const std::vector<std::string>& cmd,
96 uint32_t flags,
97 int* return_code,
98 std::string* stdout);
adlr@google.com3defe6a2009-12-04 20:57:17 +000099
Alex Deymo29b81532015-07-09 11:51:49 -0700100 // Gets the one instance.
Amin Hassanib2689592019-01-13 17:04:28 -0800101 static Subprocess& Get() { return *subprocess_singleton_; }
Darin Petkov6f03a3b2010-11-10 14:27:14 -0800102
Amin Hassania8859542018-03-07 16:24:43 -0800103 // Tries to log all in flight processes's output. It is used right before
104 // exiting the update_engine, probably when the subprocess caused a system
105 // shutdown.
106 void FlushBufferedLogsAtExit();
107
adlr@google.com3defe6a2009-12-04 20:57:17 +0000108 private:
Alex Deymo60ca1a72015-06-18 18:19:15 -0700109 FRIEND_TEST(SubprocessTest, CancelTest);
110
Darin Petkov6f03a3b2010-11-10 14:27:14 -0800111 struct SubprocessRecord {
Alex Deymo461b2592015-07-24 20:10:52 -0700112 explicit SubprocessRecord(const ExecCallback& callback)
Amin Hassanib2689592019-01-13 17:04:28 -0800113 : callback(callback) {}
Alex Deymo29b81532015-07-09 11:51:49 -0700114
Alex Deymo461b2592015-07-24 20:10:52 -0700115 // The callback supplied by the caller.
116 ExecCallback callback;
Alex Deymo29b81532015-07-09 11:51:49 -0700117
Alex Deymo461b2592015-07-24 20:10:52 -0700118 // The ProcessImpl instance managing the child process. Destroying this
119 // will close our end of the pipes we have open.
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700120 brillo::ProcessImpl proc;
Alex Deymo29b81532015-07-09 11:51:49 -0700121
Alex Deymo461b2592015-07-24 20:10:52 -0700122 // These are used to monitor the stdout of the running process, including
123 // the stderr if it was redirected.
Hidehiko Abe493fecb2019-07-10 23:30:50 +0900124 std::unique_ptr<base::FileDescriptorWatcher::Controller> stdout_controller;
Alex Deymo29b81532015-07-09 11:51:49 -0700125 int stdout_fd{-1};
Darin Petkov6f03a3b2010-11-10 14:27:14 -0800126 std::string stdout;
127 };
128
Darin Petkov6f03a3b2010-11-10 14:27:14 -0800129 // Callback which runs whenever there is input available on the subprocess
130 // stdout pipe.
Alex Deymo29b81532015-07-09 11:51:49 -0700131 static void OnStdoutReady(SubprocessRecord* record);
adlr@google.com3defe6a2009-12-04 20:57:17 +0000132
Alex Deymo461b2592015-07-24 20:10:52 -0700133 // Callback for when any subprocess terminates. This calls the user
134 // requested callback.
135 void ChildExitedCallback(const siginfo_t& info);
136
Darin Petkov6f03a3b2010-11-10 14:27:14 -0800137 // The global instance.
138 static Subprocess* subprocess_singleton_;
adlr@google.com3defe6a2009-12-04 20:57:17 +0000139
Darin Petkov6f03a3b2010-11-10 14:27:14 -0800140 // A map from the asynchronous subprocess tag (see Exec) to the subprocess
141 // record structure for all active asynchronous subprocesses.
Alex Deymo461b2592015-07-24 20:10:52 -0700142 std::map<pid_t, std::unique_ptr<SubprocessRecord>> subprocess_records_;
143
144 // Used to watch for child processes.
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700145 brillo::ProcessReaper process_reaper_;
Darin Petkov6f03a3b2010-11-10 14:27:14 -0800146
adlr@google.com3defe6a2009-12-04 20:57:17 +0000147 DISALLOW_COPY_AND_ASSIGN(Subprocess);
148};
149
150} // namespace chromeos_update_engine
151
Alex Deymo39910dc2015-11-09 17:04:30 -0800152#endif // UPDATE_ENGINE_COMMON_SUBPROCESS_H_