blob: b52c80484a38aad2528da27cf8a0489d2f3bfb17 [file] [log] [blame]
/*
* 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 "perfetto/ext/base/subprocess.h"
#include <thread>
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
#include <Windows.h>
#else
#include <signal.h>
#include <sys/stat.h>
#include <unistd.h>
#endif
#include "perfetto/base/time.h"
#include "perfetto/ext/base/file_utils.h"
#include "perfetto/ext/base/pipe.h"
#include "perfetto/ext/base/temp_file.h"
#include "test/gtest_and_gmock.h"
namespace perfetto {
namespace base {
namespace {
std::string GetOutput(const Subprocess& p) {
std::string output = p.output();
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
size_t pos = 0;
while ((pos = output.find("\r\n", pos)) != std::string::npos)
output.erase(pos, 1);
#endif
return output;
}
std::string GenLargeString() {
std::string contents;
for (int i = 0; i < 4096; i++) {
contents += "very long text " + std::to_string(i) + "\n";
}
// Make sure that |contents| is > the default pipe buffer on Linux (4 pages).
PERFETTO_DCHECK(contents.size() > 4096 * 4);
return contents;
}
TEST(SubprocessTest, InvalidPath) {
Subprocess p({"/usr/bin/invalid_1337"});
EXPECT_FALSE(p.Call());
EXPECT_EQ(p.status(), Subprocess::kTerminated);
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
EXPECT_EQ(p.returncode(), ERROR_FILE_NOT_FOUND);
#else
EXPECT_EQ(p.returncode(), 128);
EXPECT_EQ(GetOutput(p), "execve() failed\n");
#endif
}
TEST(SubprocessTest, StdoutOnly) {
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
Subprocess p({"cmd", "/c", "(echo skip_err 1>&2) && echo out_only"});
#else
Subprocess p({"sh", "-c", "(echo skip_err >&2); echo out_only"});
#endif
p.args.stdout_mode = Subprocess::kBuffer;
p.args.stderr_mode = Subprocess::kDevNull;
EXPECT_TRUE(p.Call());
EXPECT_EQ(p.status(), Subprocess::kTerminated);
EXPECT_EQ(GetOutput(p), "out_only\n");
}
TEST(SubprocessTest, StderrOnly) {
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
Subprocess p({"cmd", "/c", "(echo err_only>&2) && echo skip_out"});
#else
Subprocess p({"sh", "-c", "(echo err_only >&2); echo skip_out"});
#endif
p.args.stdout_mode = Subprocess::kDevNull;
p.args.stderr_mode = Subprocess::kBuffer;
EXPECT_TRUE(p.Call());
EXPECT_EQ(GetOutput(p), "err_only\n");
}
TEST(SubprocessTest, BothStdoutAndStderr) {
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
Subprocess p({"cmd", "/c", "echo out&&(echo err>&2)&&echo out2"});
#else
Subprocess p({"sh", "-c", "echo out; (echo err >&2); echo out2"});
#endif
p.args.stdout_mode = Subprocess::kBuffer;
p.args.stderr_mode = Subprocess::kBuffer;
EXPECT_TRUE(p.Call());
EXPECT_EQ(GetOutput(p), "out\nerr\nout2\n");
}
TEST(SubprocessTest, BinTrue) {
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
Subprocess p({"cmd", "/c", "(exit 0)"});
#else
Subprocess p({"true"});
#endif
EXPECT_TRUE(p.Call());
EXPECT_EQ(p.status(), Subprocess::kTerminated);
EXPECT_EQ(p.returncode(), 0);
}
TEST(SubprocessTest, BinFalse) {
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
Subprocess p({"cmd", "/c", "(exit 1)"});
#else
Subprocess p({"false"});
#endif
EXPECT_FALSE(p.Call());
EXPECT_EQ(p.status(), Subprocess::kTerminated);
EXPECT_EQ(p.returncode(), 1);
}
TEST(SubprocessTest, Echo) {
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
Subprocess p({"cmd", "/c", "echo|set /p ignored_var=foobar"});
#else
Subprocess p({"echo", "-n", "foobar"});
#endif
p.args.stdout_mode = Subprocess::kBuffer;
EXPECT_TRUE(p.Call());
EXPECT_EQ(p.status(), Subprocess::kTerminated);
EXPECT_EQ(p.returncode(), 0);
EXPECT_EQ(GetOutput(p), "foobar");
}
TEST(SubprocessTest, FeedbackLongInput) {
std::string contents = GenLargeString();
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
Subprocess p({"cmd", "/C", "findstr ."});
#else
Subprocess p({"cat", "-"});
#endif
p.args.stdout_mode = Subprocess::kBuffer;
p.args.input = contents;
EXPECT_TRUE(p.Call());
EXPECT_EQ(p.status(), Subprocess::kTerminated);
EXPECT_EQ(p.returncode(), 0);
EXPECT_EQ(GetOutput(p), contents);
}
TEST(SubprocessTest, CatLargeFile) {
std::string contents = GenLargeString();
TempFile tf = TempFile::Create();
WriteAll(tf.fd(), contents.data(), contents.size());
FlushFile(tf.fd());
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
Subprocess p({"cmd", "/c", ("type \"" + tf.path() + "\"").c_str()});
#else
Subprocess p({"cat", tf.path().c_str()});
#endif
p.args.stdout_mode = Subprocess::kBuffer;
EXPECT_TRUE(p.Call());
EXPECT_EQ(GetOutput(p), contents);
}
TEST(SubprocessTest, Timeout) {
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
Subprocess p({"ping", "127.0.0.1", "-n", "60"});
p.args.stdout_mode = Subprocess::kDevNull;
#else
Subprocess p({"sleep", "60"});
#endif
EXPECT_FALSE(p.Call(/*timeout_ms=*/1));
EXPECT_EQ(p.status(), Subprocess::kTerminated);
EXPECT_TRUE(p.timed_out());
}
TEST(SubprocessTest, TimeoutNotHit) {
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
Subprocess p({"ping", "127.0.0.1", "-n", "1"});
p.args.stdout_mode = Subprocess::kDevNull;
#else
Subprocess p({"sleep", "0.01"});
#endif
EXPECT_TRUE(p.Call(/*timeout_ms=*/100000));
EXPECT_EQ(p.status(), Subprocess::kTerminated);
}
TEST(SubprocessTest, TimeoutStopOutput) {
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
Subprocess p({"cmd", "/c", "FOR /L %N IN () DO @echo stuff>NUL"});
#else
Subprocess p({"sh", "-c", "while true; do echo stuff; done"});
#endif
p.args.stdout_mode = Subprocess::kDevNull;
EXPECT_FALSE(p.Call(/*timeout_ms=*/10));
EXPECT_EQ(p.status(), Subprocess::kTerminated);
EXPECT_TRUE(p.timed_out());
}
TEST(SubprocessTest, ExitBeforeReadingStdin) {
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
Subprocess p({"ping", "127.0.0.1", "-n", "1"});
#else
// 'sh -c' is to avoid closing stdin (sleep closes it before sleeping).
Subprocess p({"sh", "-c", "sleep 0.01"});
#endif
p.args.stdout_mode = Subprocess::kDevNull;
p.args.stderr_mode = Subprocess::kDevNull;
p.args.input = GenLargeString();
EXPECT_TRUE(p.Call());
EXPECT_EQ(p.status(), Subprocess::kTerminated);
EXPECT_EQ(p.returncode(), 0);
}
TEST(SubprocessTest, StdinWriteStall) {
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
Subprocess p({"ping", "127.0.0.1", "-n", "10"});
#else
// 'sh -c' is to avoid closing stdin (sleep closes it before sleeping).
// This causes a situation where the write on the stdin will stall because
// nobody reads it and the pipe buffer fills up. In this situation we should
// still handle the timeout properly.
Subprocess p({"sh", "-c", "sleep 10"});
#endif
p.args.stdout_mode = Subprocess::kDevNull;
p.args.stderr_mode = Subprocess::kDevNull;
p.args.input = GenLargeString();
EXPECT_FALSE(p.Call(/*timeout_ms=*/10));
EXPECT_EQ(p.status(), Subprocess::kTerminated);
EXPECT_TRUE(p.timed_out());
}
TEST(SubprocessTest, StartAndWait) {
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
Subprocess p({"ping", "127.0.0.1", "-n", "1000"});
#else
Subprocess p({"sleep", "1000"});
#endif
p.args.stdout_mode = Subprocess::kDevNull;
p.Start();
EXPECT_EQ(p.Poll(), Subprocess::kRunning);
p.KillAndWaitForTermination();
EXPECT_EQ(p.status(), Subprocess::kTerminated);
EXPECT_EQ(p.Poll(), Subprocess::kTerminated);
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
EXPECT_EQ(p.returncode(), static_cast<int>(STATUS_CONTROL_C_EXIT));
#else
EXPECT_EQ(p.returncode(), static_cast<int>(128 + SIGKILL));
#endif
}
TEST(SubprocessTest, PollBehavesProperly) {
Pipe pipe = Pipe::Create();
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
Subprocess p({"cmd", "/c", "(exit 0)"});
#else
Subprocess p({"true"});
#endif
p.args.stdout_mode = Subprocess::kFd;
p.args.out_fd = std::move(pipe.wr);
p.Start();
// Wait for EOF (which really means the child process has terminated).
std::string ignored;
ReadPlatformHandle(*pipe.rd, &ignored);
// The kernel takes some time to detect the termination of the process. The
// best thing we can do here is check that we detect the termination within
// some reasonable time.
auto start_ms = GetWallTimeMs();
while (p.Poll() != Subprocess::kTerminated) {
auto elapsed_ms = GetWallTimeMs() - start_ms;
ASSERT_LT(elapsed_ms, TimeMillis(10000));
std::this_thread::sleep_for(TimeMillis(5));
}
// At this point Poll() must detect the termination.
EXPECT_EQ(p.Poll(), Subprocess::kTerminated);
EXPECT_EQ(p.returncode(), 0);
}
TEST(SubprocessTest, Wait) {
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
Subprocess p({"cmd", "/c", "echo exec_done && FOR /L %N IN () DO @echo>NUL"});
#else
Subprocess p({"sh", "-c", "echo exec_done; while true; do true; done"});
#endif
p.args.stdout_mode = Subprocess::kBuffer;
p.Start();
// Wait for the fork()+exec() to complete.
while (p.output().find("exec_done") == std::string::npos) {
EXPECT_FALSE(p.Wait(1 /*ms*/));
EXPECT_EQ(p.status(), Subprocess::kRunning);
}
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
ScopedPlatformHandle proc_handle(::OpenProcess(
PROCESS_TERMINATE, /*inherit=*/false, static_cast<DWORD>(p.pid())));
ASSERT_TRUE(proc_handle);
ASSERT_TRUE(::TerminateProcess(*proc_handle, DBG_CONTROL_BREAK));
#else
kill(p.pid(), SIGBUS);
#endif
EXPECT_TRUE(p.Wait(30000 /*ms*/)); // We shouldn't hit this.
EXPECT_TRUE(p.Wait()); // Should be a no-op.
EXPECT_EQ(p.status(), Subprocess::kTerminated);
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
EXPECT_EQ(p.returncode(), static_cast<int>(DBG_CONTROL_BREAK));
#else
EXPECT_EQ(p.returncode(), 128 + SIGBUS);
#endif
}
TEST(SubprocessTest, KillOnDtor) {
auto is_process_alive = [](PlatformProcessId pid) {
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
DWORD ignored = 0;
return ProcessIdToSessionId(static_cast<DWORD>(pid), &ignored);
#else
// We use kill(SIGWINCH) as a way to tell if the process is still alive by
// looking at the kill(2) return value. SIGWINCH is one of the few signals
// that has default ignore disposition.
return kill(pid, SIGWINCH) == 0;
#endif
};
PlatformProcessId pid;
{
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
Subprocess p({"ping", "127.0.0.1", "-n", "1000"});
#else
Subprocess p({"sleep", "1000"});
#endif
p.Start();
pid = p.pid();
EXPECT_TRUE(is_process_alive(pid));
}
// Both on Windows and Linux, kill can take some time to free up the pid.
bool alive = true;
for (int attempt = 0; attempt < 1000 && alive; attempt++) {
alive = is_process_alive(pid);
std::this_thread::sleep_for(TimeMillis(5));
}
EXPECT_FALSE(alive);
}
// Regression test for b/162505491.
TEST(SubprocessTest, MoveOperators) {
{
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
Subprocess initial({"ping", "127.0.0.1", "-n", "100"});
#else
Subprocess initial = Subprocess({"sleep", "10000"});
#endif
initial.args.stdout_mode = Subprocess::kDevNull;
initial.Start();
Subprocess moved(std::move(initial));
EXPECT_EQ(moved.Poll(), Subprocess::kRunning);
EXPECT_EQ(initial.Poll(), Subprocess::kNotStarted);
// Check that reuse works
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
initial = Subprocess({"cmd", "/c", "echo|set /p ignored_var=hello"});
#else
initial = Subprocess({"echo", "-n", "hello"});
#endif
initial.args.stdout_mode = Subprocess::OutputMode::kBuffer;
initial.Start();
initial.Wait(/*timeout=*/5000);
EXPECT_EQ(initial.status(), Subprocess::kTerminated);
EXPECT_EQ(initial.returncode(), 0);
EXPECT_EQ(initial.output(), "hello");
}
std::vector<Subprocess> v;
for (int i = 0; i < 10; i++) {
#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
v.emplace_back(Subprocess({"ping", "127.0.0.1", "-n", "10"}));
#else
v.emplace_back(Subprocess({"sleep", "10"}));
#endif
v.back().args.stdout_mode = Subprocess::OutputMode::kDevNull;
v.back().Start();
}
for (auto& p : v)
EXPECT_EQ(p.Poll(), Subprocess::kRunning);
}
// posix_entrypoint_for_testing is not supported on Windows.
#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
// Test the case of passing a lambda in |entrypoint| but no cmd.c
TEST(SubprocessTest, Entrypoint) {
Subprocess p;
p.args.input = "ping\n";
p.args.stdout_mode = Subprocess::kBuffer;
p.args.posix_entrypoint_for_testing = [] {
char buf[32]{};
PERFETTO_CHECK(fgets(buf, sizeof(buf), stdin));
PERFETTO_CHECK(strcmp(buf, "ping\n") == 0);
printf("pong\n");
fflush(stdout);
_exit(42);
};
EXPECT_FALSE(p.Call());
EXPECT_EQ(p.returncode(), 42);
EXPECT_EQ(GetOutput(p), "pong\n");
}
// Test the case of passing both a lambda entrypoint and a process to exec.
TEST(SubprocessTest, EntrypointAndExec) {
base::Pipe pipe1 = base::Pipe::Create();
base::Pipe pipe2 = base::Pipe::Create();
int pipe1_wr = *pipe1.wr;
int pipe2_wr = *pipe2.wr;
Subprocess p({"echo", "123"});
p.args.stdout_mode = Subprocess::kBuffer;
p.args.preserve_fds.push_back(pipe2_wr);
p.args.posix_entrypoint_for_testing = [pipe1_wr, pipe2_wr] {
base::ignore_result(write(pipe1_wr, "fail", 4));
base::ignore_result(write(pipe2_wr, "pass", 4));
};
p.Start();
pipe1.wr.reset();
pipe2.wr.reset();
char buf[8];
EXPECT_LE(read(*pipe1.rd, buf, sizeof(buf)), 0);
EXPECT_EQ(read(*pipe2.rd, buf, sizeof(buf)), 4);
buf[4] = '\0';
EXPECT_STREQ(buf, "pass");
EXPECT_TRUE(p.Wait());
EXPECT_EQ(p.status(), Subprocess::kTerminated);
EXPECT_EQ(GetOutput(p), "123\n");
}
#endif
} // namespace
} // namespace base
} // namespace perfetto