[ceph.git] / ceph / src / common / SubProcess.h

// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
 * Ceph distributed storage system
 *
 * Copyright (C) 2015 Mirantis Inc
 *
 * Author: Mykola Golub <mgolub@mirantis.com>
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 */

#ifndef SUB_PROCESS_H
#define SUB_PROCESS_H

#include <sys/wait.h>
#include <stdarg.h>
#include <sstream>
#include <vector>
#include <iostream>
#include <include/assert.h>
#include <common/errno.h>
#if defined(__FreeBSD__)
#include <sys/types.h>
#include <signal.h>
#endif

/**
 * SubProcess:
 * A helper class to spawn a subprocess.
 *
 * Example:
 *
 *   SubProcess cat("cat", SubProcess::PIPE, SubProcess::PIPE);
 *   if (cat.spawn() != 0) {
 *     std::cerr << "cat failed: " << cat.err() << std::endl;
 *     return false;
 *   }
 *   write_to_fd(cat.get_stdout(), "hello world!\n");
 *   cat.close_stdout();
 *   read_from_fd(cat.get_stdin(), buf);
 *   if (cat.join() != 0) {
 *     std::cerr << cat.err() << std::endl;
 *     return false;
 *   }
 */

class SubProcess {
public:
  enum std_fd_op{
    KEEP,
    CLOSE,
    PIPE
  };
public:
  SubProcess(const char *cmd,
             std_fd_op stdin_op = CLOSE,
             std_fd_op stdout_op = CLOSE,
             std_fd_op stderr_op = CLOSE);
  virtual ~SubProcess();

  void add_cmd_args(const char *arg, ...);
  void add_cmd_arg(const char *arg);

  virtual int spawn(); // Returns 0 on success or -errno on failure.
  virtual int join();  // Returns exit code (0 on success).

  bool is_spawned() const { return pid > 0; }

  int get_stdin() const;
  int get_stdout() const;
  int get_stderr() const;

  void close_stdin();
  void close_stdout();
  void close_stderr();

  void kill(int signo = SIGTERM) const;

  const std::string err() const;

protected:
  bool is_child() const { return pid == 0; }
  virtual void exec();

private:
  void close(int &fd);

protected:
  std::string cmd;
  std::vector<std::string> cmd_args;
  std_fd_op stdin_op;
  std_fd_op stdout_op;
  std_fd_op stderr_op;
  int stdin_pipe_out_fd;
  int stdout_pipe_in_fd;
  int stderr_pipe_in_fd;
  int pid;
  std::ostringstream errstr;
};

class SubProcessTimed : public SubProcess {
public:
  SubProcessTimed(const char *cmd, std_fd_op stdin_op = CLOSE,
		  std_fd_op stdout_op = CLOSE, std_fd_op stderr_op = CLOSE,
		  int timeout = 0, int sigkill = SIGKILL);

protected:
  void exec() override;

private:
  int timeout;
  int sigkill;
};

inline SubProcess::SubProcess(const char *cmd_, std_fd_op stdin_op_, std_fd_op stdout_op_, std_fd_op stderr_op_) :
  cmd(cmd_),
  cmd_args(),
  stdin_op(stdin_op_),
  stdout_op(stdout_op_),
  stderr_op(stderr_op_),
  stdin_pipe_out_fd(-1),
  stdout_pipe_in_fd(-1),
  stderr_pipe_in_fd(-1),
  pid(-1),
  errstr() {
}

inline SubProcess::~SubProcess() {
  assert(!is_spawned());
  assert(stdin_pipe_out_fd == -1);
  assert(stdout_pipe_in_fd == -1);
  assert(stderr_pipe_in_fd == -1);
}

inline void SubProcess::add_cmd_args(const char *arg, ...) {
  assert(!is_spawned());

  va_list ap;
  va_start(ap, arg);
  const char *p = arg;
  do {
    add_cmd_arg(p);
    p = va_arg(ap, const char*);
  } while (p != NULL);
  va_end(ap);
}

inline void SubProcess::add_cmd_arg(const char *arg) {
  assert(!is_spawned());

  cmd_args.push_back(arg);
}

inline int SubProcess::get_stdin() const {
  assert(is_spawned());
  assert(stdin_op == PIPE);

  return stdin_pipe_out_fd;
}

inline int SubProcess::get_stdout() const {
  assert(is_spawned());
  assert(stdout_op == PIPE);

  return stdout_pipe_in_fd;
}

inline int SubProcess::get_stderr() const {
  assert(is_spawned());
  assert(stderr_op == PIPE);

  return stderr_pipe_in_fd;
}

inline void SubProcess::close(int &fd) {
  if (fd == -1)
    return;

  ::close(fd);
  fd = -1;
}

inline void SubProcess::close_stdin() {
  assert(is_spawned());
  assert(stdin_op == PIPE);

  close(stdin_pipe_out_fd);
}

inline void SubProcess::close_stdout() {
  assert(is_spawned());
  assert(stdout_op == PIPE);

  close(stdout_pipe_in_fd);
}

inline void SubProcess::close_stderr() {
  assert(is_spawned());
  assert(stderr_op == PIPE);

  close(stderr_pipe_in_fd);
}

inline void SubProcess::kill(int signo) const {
  assert(is_spawned());

  int ret = ::kill(pid, signo);
  assert(ret == 0);
}

inline const std::string SubProcess::err() const {
  return errstr.str();
}

class fd_buf : public std::streambuf {
  int fd;
public:
  fd_buf (int fd) : fd(fd)
  {}
protected:
  int_type overflow (int_type c) override {
    if (c == EOF) return EOF;
    char buf = c;
    if (write (fd, &buf, 1) != 1) {
      return EOF;
    }
    return c;
  }
  std::streamsize xsputn (const char* s, std::streamsize count) override {
    return write(fd, s, count);
  }
};

inline int SubProcess::spawn() {
  assert(!is_spawned());
  assert(stdin_pipe_out_fd == -1);
  assert(stdout_pipe_in_fd == -1);
  assert(stderr_pipe_in_fd == -1);

  enum { IN = 0, OUT = 1 };

  int ipipe[2], opipe[2], epipe[2];

  ipipe[0] = ipipe[1] = opipe[0] = opipe[1] = epipe[0] = epipe[1] = -1;

  int ret = 0;

  if ((stdin_op == PIPE  && ::pipe(ipipe) == -1) ||
      (stdout_op == PIPE && ::pipe(opipe) == -1) ||
      (stderr_op == PIPE && ::pipe(epipe) == -1)) {
    ret = -errno;
    errstr << "pipe failed: " << cpp_strerror(errno);
    goto fail;
  }

  pid = fork();

  if (pid > 0) { // Parent
    stdin_pipe_out_fd = ipipe[OUT]; close(ipipe[IN ]);
    stdout_pipe_in_fd = opipe[IN ]; close(opipe[OUT]);
    stderr_pipe_in_fd = epipe[IN ]; close(epipe[OUT]);
    return 0;
  }

  if (pid == 0) { // Child
    close(ipipe[OUT]);
    close(opipe[IN ]);
    close(epipe[IN ]);

    if (ipipe[IN] != -1 && ipipe[IN] != STDIN_FILENO) {
      ::dup2(ipipe[IN], STDIN_FILENO);
      close(ipipe[IN]);
    }
    if (opipe[OUT] != -1 && opipe[OUT] != STDOUT_FILENO) {
      ::dup2(opipe[OUT], STDOUT_FILENO);
      close(opipe[OUT]);
      static fd_buf buf(STDOUT_FILENO);
      std::cout.rdbuf(&buf);
    }
    if (epipe[OUT] != -1 && epipe[OUT] != STDERR_FILENO) {
      ::dup2(epipe[OUT], STDERR_FILENO);
      close(epipe[OUT]);
      static fd_buf buf(STDERR_FILENO);
      std::cerr.rdbuf(&buf);
    }

    int maxfd = sysconf(_SC_OPEN_MAX);
    if (maxfd == -1)
      maxfd = 16384;
    for (int fd = 0; fd <= maxfd; fd++) {
      if (fd == STDIN_FILENO && stdin_op != CLOSE)
	continue;
      if (fd == STDOUT_FILENO && stdout_op != CLOSE)
	continue;
      if (fd == STDERR_FILENO && stderr_op != CLOSE)
	continue;
      ::close(fd);
    }

    exec();
    ceph_abort(); // Never reached
  }

  ret = -errno;
  errstr << "fork failed: " << cpp_strerror(errno);

fail:
  close(ipipe[0]);
  close(ipipe[1]);
  close(opipe[0]);
  close(opipe[1]);
  close(epipe[0]);
  close(epipe[1]);

  return ret;
}

inline void SubProcess::exec() {
  assert(is_child());

  std::vector<const char *> args;
  args.push_back(cmd.c_str());
  for (std::vector<std::string>::iterator i = cmd_args.begin();
       i != cmd_args.end();
       i++) {
    args.push_back(i->c_str());
  }
  args.push_back(NULL);

  int ret = execvp(cmd.c_str(), (char * const *)&args[0]);
  assert(ret == -1);

  std::cerr << cmd << ": exec failed: " << cpp_strerror(errno) << "\n";
  _exit(EXIT_FAILURE);
}

inline int SubProcess::join() {
  assert(is_spawned());

  close(stdin_pipe_out_fd);
  close(stdout_pipe_in_fd);
  close(stderr_pipe_in_fd);

  int status;

  while (waitpid(pid, &status, 0) == -1)
    assert(errno == EINTR);

  pid = -1;

  if (WIFEXITED(status)) {
    if (WEXITSTATUS(status) != EXIT_SUCCESS)
      errstr << cmd << ": exit status: " << WEXITSTATUS(status);
    return WEXITSTATUS(status);
  }
  if (WIFSIGNALED(status)) {
    errstr << cmd << ": got signal: " << WTERMSIG(status);
    return 128 + WTERMSIG(status);
  }
  errstr << cmd << ": waitpid: unknown status returned\n";
  return EXIT_FAILURE;
}

inline SubProcessTimed::SubProcessTimed(const char *cmd, std_fd_op stdin_op,
				 std_fd_op stdout_op, std_fd_op stderr_op,
				 int timeout_, int sigkill_) :
  SubProcess(cmd, stdin_op, stdout_op, stderr_op),
  timeout(timeout_),
  sigkill(sigkill_) {
}

static bool timedout = false; // only used after fork
static void timeout_sighandler(int sig) {
  timedout = true;
}
static void dummy_sighandler(int sig) {}

inline void SubProcessTimed::exec() {
  assert(is_child());

  if (timeout <= 0) {
    SubProcess::exec();
    ceph_abort(); // Never reached
  }

  sigset_t mask, oldmask;
  int pid;

  // Restore default action for SIGTERM in case the parent process decided
  // to ignore it.
  if (signal(SIGTERM, SIG_DFL) == SIG_ERR) {
    std::cerr << cmd << ": signal failed: " << cpp_strerror(errno) << "\n";
    goto fail_exit;
  }
  // Because SIGCHLD is ignored by default, setup dummy handler for it,
  // so we can mask it.
  if (signal(SIGCHLD, dummy_sighandler) == SIG_ERR) {
    std::cerr << cmd << ": signal failed: " << cpp_strerror(errno) << "\n";
    goto fail_exit;
  }
  // Setup timeout handler.
  if (signal(SIGALRM, timeout_sighandler) == SIG_ERR) {
    std::cerr << cmd << ": signal failed: " << cpp_strerror(errno) << "\n";
    goto fail_exit;
  }
  // Block interesting signals.
  sigemptyset(&mask);
  sigaddset(&mask, SIGINT);
  sigaddset(&mask, SIGTERM);
  sigaddset(&mask, SIGCHLD);
  sigaddset(&mask, SIGALRM);
  if (sigprocmask(SIG_SETMASK, &mask, &oldmask) == -1) {
    std::cerr << cmd << ": sigprocmask failed: " << cpp_strerror(errno) << "\n";
    goto fail_exit;
  }

  pid = fork();

  if (pid == -1) {
    std::cerr << cmd << ": fork failed: " << cpp_strerror(errno) << "\n";
    goto fail_exit;
  }

  if (pid == 0) { // Child
    // Restore old sigmask.
    if (sigprocmask(SIG_SETMASK, &oldmask, NULL) == -1) {
      std::cerr << cmd << ": sigprocmask failed: " << cpp_strerror(errno) << "\n";
      goto fail_exit;
    }
    (void)setpgid(0, 0); // Become process group leader.
    SubProcess::exec();
    ceph_abort(); // Never reached
  }

  // Parent
  (void)alarm(timeout);

  for (;;) {
    int signo;
    if (sigwait(&mask, &signo) == -1) {
      std::cerr << cmd << ": sigwait failed: " << cpp_strerror(errno) << "\n";
      goto fail_exit;
    }
    switch (signo) {
    case SIGCHLD:
      int status;
      if (waitpid(pid, &status, WNOHANG) == -1) {
	std::cerr << cmd << ": waitpid failed: " << cpp_strerror(errno) << "\n";
	goto fail_exit;
      }
      if (WIFEXITED(status))
	_exit(WEXITSTATUS(status));
      if (WIFSIGNALED(status))
	_exit(128 + WTERMSIG(status));
      std::cerr << cmd << ": unknown status returned\n";
      goto fail_exit;
    case SIGINT:
    case SIGTERM:
      // Pass SIGINT and SIGTERM, which are usually used to terminate
      // a process, to the child.
      if (::kill(pid, signo) == -1) {
	std::cerr << cmd << ": kill failed: " << cpp_strerror(errno) << "\n";
	goto fail_exit;
      }
      continue;
    case SIGALRM:
      std::cerr << cmd << ": timed out (" << timeout << " sec)\n";
      if (::killpg(pid, sigkill) == -1) {
	std::cerr << cmd << ": kill failed: " << cpp_strerror(errno) << "\n";
	goto fail_exit;
      }
      continue;
    default:
      std::cerr << cmd << ": sigwait: invalid signal: " << signo << "\n";
      goto fail_exit;
    }
  }

fail_exit:
  _exit(EXIT_FAILURE);
}

#endif
Commit	Line	Data
7c673cae FG	1	// -- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t --
	2	// vim: ts=8 sw=2 smarttab
	3	/*
	4	* Ceph distributed storage system
	5	*
	6	* Copyright (C) 2015 Mirantis Inc
	7	*
	8	* Author: Mykola Golub <mgolub@mirantis.com>
	9	*
	10	* This library is free software; you can redistribute it and/or
	11	* modify it under the terms of the GNU Lesser General Public
	12	* License as published by the Free Software Foundation; either
	13	* version 2.1 of the License, or (at your option) any later version.
	14	*
	15	*/
	16
	17	#ifndef SUB_PROCESS_H
	18	#define SUB_PROCESS_H
	19
7c673cae	20	#include <sys/wait.h>
7c673cae	21	#include <stdarg.h>
7c673cae FG	22	#include <sstream>
	23	#include <vector>
	24	#include <iostream>
7c673cae FG	25	#include <include/assert.h>
7c673cae FG	26	#include <common/errno.h>
31f18b77 FG	27	#if defined(__FreeBSD__)
	28	#include <sys/types.h>
	29	#include <signal.h>
	30	#endif
7c673cae FG	31
	32	/**
	33	* SubProcess:
	34	* A helper class to spawn a subprocess.
	35	*
	36	* Example:
	37	*
	38	* SubProcess cat("cat", SubProcess::PIPE, SubProcess::PIPE);
	39	* if (cat.spawn() != 0) {
	40	* std::cerr << "cat failed: " << cat.err() << std::endl;
	41	* return false;
	42	* }
	43	* write_to_fd(cat.get_stdout(), "hello world!\n");
	44	* cat.close_stdout();
	45	* read_from_fd(cat.get_stdin(), buf);
	46	* if (cat.join() != 0) {
	47	* std::cerr << cat.err() << std::endl;
	48	* return false;
	49	* }
	50	*/
	51
	52	class SubProcess {
	53	public:
	54	enum std_fd_op{
	55	KEEP,
	56	CLOSE,
	57	PIPE
	58	};
	59	public:
	60	SubProcess(const char *cmd,
	61	std_fd_op stdin_op = CLOSE,
	62	std_fd_op stdout_op = CLOSE,
	63	std_fd_op stderr_op = CLOSE);
	64	virtual ~SubProcess();
	65
	66	void add_cmd_args(const char *arg, ...);
	67	void add_cmd_arg(const char *arg);
	68
	69	virtual int spawn(); // Returns 0 on success or -errno on failure.
	70	virtual int join(); // Returns exit code (0 on success).
	71
	72	bool is_spawned() const { return pid > 0; }
	73
	74	int get_stdin() const;
	75	int get_stdout() const;
	76	int get_stderr() const;
	77
	78	void close_stdin();
	79	void close_stdout();
	80	void close_stderr();
	81
	82	void kill(int signo = SIGTERM) const;
	83
	84	const std::string err() const;
	85
	86	protected:
	87	bool is_child() const { return pid == 0; }
	88	virtual void exec();
	89
	90	private:
	91	void close(int &fd);
	92
	93	protected:
	94	std::string cmd;
95	std::vector<std::string> cmd_args;
96	std_fd_op stdin_op;
97	std_fd_op stdout_op;
98	std_fd_op stderr_op;
99	int stdin_pipe_out_fd;
100	int stdout_pipe_in_fd;
101	int stderr_pipe_in_fd;
102	int pid;
103	std::ostringstream errstr;
104	};
105
106	class SubProcessTimed : public SubProcess {
107	public:
108	SubProcessTimed(const char *cmd, std_fd_op stdin_op = CLOSE,
109	std_fd_op stdout_op = CLOSE, std_fd_op stderr_op = CLOSE,
110	int timeout = 0, int sigkill = SIGKILL);
111
112	protected:
113	void exec() override;
114
115	private:
116	int timeout;
117	int sigkill;
118	};
119
120	inline SubProcess::SubProcess(const char *cmd_, std_fd_op stdin_op_, std_fd_op stdout_op_, std_fd_op stderr_op_) :
121	cmd(cmd_),
122	cmd_args(),
123	stdin_op(stdin_op_),
124	stdout_op(stdout_op_),
125	stderr_op(stderr_op_),
126	stdin_pipe_out_fd(-1),
127	stdout_pipe_in_fd(-1),
128	stderr_pipe_in_fd(-1),
129	pid(-1),
130	errstr() {
131	}
132
133	inline SubProcess::~SubProcess() {
134	assert(!is_spawned());
135	assert(stdin_pipe_out_fd == -1);
136	assert(stdout_pipe_in_fd == -1);
137	assert(stderr_pipe_in_fd == -1);
138	}
139
140	inline void SubProcess::add_cmd_args(const char *arg, ...) {
141	assert(!is_spawned());
142
143	va_list ap;
144	va_start(ap, arg);
145	const char *p = arg;
146	do {
147	add_cmd_arg(p);
148	p = va_arg(ap, const char*);
149	} while (p != NULL);
150	va_end(ap);
151	}
152
153	inline void SubProcess::add_cmd_arg(const char *arg) {
154	assert(!is_spawned());
155
156	cmd_args.push_back(arg);
157	}
158
159	inline int SubProcess::get_stdin() const {
160	assert(is_spawned());
161	assert(stdin_op == PIPE);
162
163	return stdin_pipe_out_fd;
164	}
165
166	inline int SubProcess::get_stdout() const {
167	assert(is_spawned());
168	assert(stdout_op == PIPE);
169
170	return stdout_pipe_in_fd;
171	}
172
173	inline int SubProcess::get_stderr() const {
174	assert(is_spawned());
175	assert(stderr_op == PIPE);
176
177	return stderr_pipe_in_fd;
178	}
179
180	inline void SubProcess::close(int &fd) {
181	if (fd == -1)
182	return;
183
184	::close(fd);
185	fd = -1;
186	}
187
188	inline void SubProcess::close_stdin() {
189	assert(is_spawned());
190	assert(stdin_op == PIPE);
191
192	close(stdin_pipe_out_fd);
193	}
194
195	inline void SubProcess::close_stdout() {
196	assert(is_spawned());
197	assert(stdout_op == PIPE);
198
199	close(stdout_pipe_in_fd);
200	}
201
202	inline void SubProcess::close_stderr() {
203	assert(is_spawned());
204	assert(stderr_op == PIPE);
205
206	close(stderr_pipe_in_fd);
207	}
208
209	inline void SubProcess::kill(int signo) const {
210	assert(is_spawned());
211
212	int ret = ::kill(pid, signo);
213	assert(ret == 0);
214	}
215
216	inline const std::string SubProcess::err() const {
217	return errstr.str();
218	}
219
220	class fd_buf : public std::streambuf {
221	int fd;
222	public:
223	fd_buf (int fd) : fd(fd)
224	{}
225	protected:
226	int_type overflow (int_type c) override {
227	if (c == EOF) return EOF;
228	char buf = c;
229	if (write (fd, &buf, 1) != 1) {
230	return EOF;
231	}
232	return c;
233	}
234	std::streamsize xsputn (const char* s, std::streamsize count) override {
235	return write(fd, s, count);
236	}
237	};
238
239	inline int SubProcess::spawn() {
240	assert(!is_spawned());
241	assert(stdin_pipe_out_fd == -1);
242	assert(stdout_pipe_in_fd == -1);
243	assert(stderr_pipe_in_fd == -1);
244
245	enum { IN = 0, OUT = 1 };
246
247	int ipipe[2], opipe[2], epipe[2];
248
249	ipipe[0] = ipipe[1] = opipe[0] = opipe[1] = epipe[0] = epipe[1] = -1;
250
251	int ret = 0;
252
253	if ((stdin_op == PIPE && ::pipe(ipipe) == -1) \|\|
254	(stdout_op == PIPE && ::pipe(opipe) == -1) \|\|
255	(stderr_op == PIPE && ::pipe(epipe) == -1)) {
256	ret = -errno;
257	errstr << "pipe failed: " << cpp_strerror(errno);
258	goto fail;
259	}
260
261	pid = fork();
262
263	if (pid > 0) { // Parent
264	stdin_pipe_out_fd = ipipe[OUT]; close(ipipe[IN ]);
265	stdout_pipe_in_fd = opipe[IN ]; close(opipe[OUT]);
266	stderr_pipe_in_fd = epipe[IN ]; close(epipe[OUT]);
267	return 0;
268	}
269
270	if (pid == 0) { // Child
271	close(ipipe[OUT]);
272	close(opipe[IN ]);
273	close(epipe[IN ]);
274
275	if (ipipe[IN] != -1 && ipipe[IN] != STDIN_FILENO) {
276	::dup2(ipipe[IN], STDIN_FILENO);
277	close(ipipe[IN]);
278	}
279	if (opipe[OUT] != -1 && opipe[OUT] != STDOUT_FILENO) {
280	::dup2(opipe[OUT], STDOUT_FILENO);
281	close(opipe[OUT]);
282	static fd_buf buf(STDOUT_FILENO);
283	std::cout.rdbuf(&buf);
284	}
285	if (epipe[OUT] != -1 && epipe[OUT] != STDERR_FILENO) {
286	::dup2(epipe[OUT], STDERR_FILENO);
287	close(epipe[OUT]);
288	static fd_buf buf(STDERR_FILENO);
289	std::cerr.rdbuf(&buf);
290	}
291
292	int maxfd = sysconf(_SC_OPEN_MAX);
293	if (maxfd == -1)
294	maxfd = 16384;
295	for (int fd = 0; fd <= maxfd; fd++) {
296	if (fd == STDIN_FILENO && stdin_op != CLOSE)
297	continue;
298	if (fd == STDOUT_FILENO && stdout_op != CLOSE)
299	continue;
300	if (fd == STDERR_FILENO && stderr_op != CLOSE)
301	continue;
302	::close(fd);
303	}
304
305	exec();
306	ceph_abort(); // Never reached
307	}
308
309	ret = -errno;
310	errstr << "fork failed: " << cpp_strerror(errno);
311
312	fail:
313	close(ipipe[0]);
314	close(ipipe[1]);
315	close(opipe[0]);
316	close(opipe[1]);
317	close(epipe[0]);
318	close(epipe[1]);
319
320	return ret;
321	}
322
323	inline void SubProcess::exec() {
324	assert(is_child());
325
326	std::vector<const char *> args;
327	args.push_back(cmd.c_str());
328	for (std::vector<std::string>::iterator i = cmd_args.begin();
329	i != cmd_args.end();
330	i++) {
331	args.push_back(i->c_str());
332	}
333	args.push_back(NULL);
334
335	int ret = execvp(cmd.c_str(), (char * const *)&args[0]);
336	assert(ret == -1);
337
338	std::cerr << cmd << ": exec failed: " << cpp_strerror(errno) << "\n";
339	_exit(EXIT_FAILURE);
340	}
341
342	inline int SubProcess::join() {
343	assert(is_spawned());
344
345	close(stdin_pipe_out_fd);
346	close(stdout_pipe_in_fd);
347	close(stderr_pipe_in_fd);
348
349	int status;
350
351	while (waitpid(pid, &status, 0) == -1)
352	assert(errno == EINTR);
353
354	pid = -1;
355
356	if (WIFEXITED(status)) {
357	if (WEXITSTATUS(status) != EXIT_SUCCESS)
358	errstr << cmd << ": exit status: " << WEXITSTATUS(status);
359	return WEXITSTATUS(status);
360	}
361	if (WIFSIGNALED(status)) {
362	errstr << cmd << ": got signal: " << WTERMSIG(status);
363	return 128 + WTERMSIG(status);
364	}
365	errstr << cmd << ": waitpid: unknown status returned\n";
366	return EXIT_FAILURE;
367	}
368
369	inline SubProcessTimed::SubProcessTimed(const char *cmd, std_fd_op stdin_op,
370	std_fd_op stdout_op, std_fd_op stderr_op,
371	int timeout_, int sigkill_) :
372	SubProcess(cmd, stdin_op, stdout_op, stderr_op),
373	timeout(timeout_),
374	sigkill(sigkill_) {
375	}
376
377	static bool timedout = false; // only used after fork
378	static void timeout_sighandler(int sig) {
379	timedout = true;
380	}
381	static void dummy_sighandler(int sig) {}
382
383	inline void SubProcessTimed::exec() {
384	assert(is_child());
385
386	if (timeout <= 0) {
387	SubProcess::exec();
388	ceph_abort(); // Never reached
389	}
390
391	sigset_t mask, oldmask;
392	int pid;
393
394	// Restore default action for SIGTERM in case the parent process decided
395	// to ignore it.
396	if (signal(SIGTERM, SIG_DFL) == SIG_ERR) {
397	std::cerr << cmd << ": signal failed: " << cpp_strerror(errno) << "\n";
398	goto fail_exit;
399	}
400	// Because SIGCHLD is ignored by default, setup dummy handler for it,
401	// so we can mask it.
402	if (signal(SIGCHLD, dummy_sighandler) == SIG_ERR) {
403	std::cerr << cmd << ": signal failed: " << cpp_strerror(errno) << "\n";
404	goto fail_exit;
405	}
406	// Setup timeout handler.
407	if (signal(SIGALRM, timeout_sighandler) == SIG_ERR) {
408	std::cerr << cmd << ": signal failed: " << cpp_strerror(errno) << "\n";
409	goto fail_exit;
410	}
411	// Block interesting signals.
412	sigemptyset(&mask);
413	sigaddset(&mask, SIGINT);
414	sigaddset(&mask, SIGTERM);
415	sigaddset(&mask, SIGCHLD);
416	sigaddset(&mask, SIGALRM);
417	if (sigprocmask(SIG_SETMASK, &mask, &oldmask) == -1) {
418	std::cerr << cmd << ": sigprocmask failed: " << cpp_strerror(errno) << "\n";
419	goto fail_exit;
420	}
421
422	pid = fork();
423
424	if (pid == -1) {
425	std::cerr << cmd << ": fork failed: " << cpp_strerror(errno) << "\n";
426	goto fail_exit;
427	}
428
429	if (pid == 0) { // Child
430	// Restore old sigmask.
431	if (sigprocmask(SIG_SETMASK, &oldmask, NULL) == -1) {
432	std::cerr << cmd << ": sigprocmask failed: " << cpp_strerror(errno) << "\n";
433	goto fail_exit;
434	}
435	(void)setpgid(0, 0); // Become process group leader.
436	SubProcess::exec();
437	ceph_abort(); // Never reached
438	}
439
440	// Parent
441	(void)alarm(timeout);
442
443	for (;;) {
444	int signo;
445	if (sigwait(&mask, &signo) == -1) {
446	std::cerr << cmd << ": sigwait failed: " << cpp_strerror(errno) << "\n";
447	goto fail_exit;
448	}
449	switch (signo) {
450	case SIGCHLD:
451	int status;
452	if (waitpid(pid, &status, WNOHANG) == -1) {
453	std::cerr << cmd << ": waitpid failed: " << cpp_strerror(errno) << "\n";
454	goto fail_exit;
455	}
456	if (WIFEXITED(status))
457	_exit(WEXITSTATUS(status));
458	if (WIFSIGNALED(status))
459	_exit(128 + WTERMSIG(status));
460	std::cerr << cmd << ": unknown status returned\n";
461	goto fail_exit;
462	case SIGINT:
463	case SIGTERM:
464	// Pass SIGINT and SIGTERM, which are usually used to terminate
465	// a process, to the child.
466	if (::kill(pid, signo) == -1) {
467	std::cerr << cmd << ": kill failed: " << cpp_strerror(errno) << "\n";
468	goto fail_exit;
469	}
470	continue;
471	case SIGALRM:
472	std::cerr << cmd << ": timed out (" << timeout << " sec)\n";
473	if (::killpg(pid, sigkill) == -1) {
474	std::cerr << cmd << ": kill failed: " << cpp_strerror(errno) << "\n";
475	goto fail_exit;
476	}
477	continue;
478	default:
479	std::cerr << cmd << ": sigwait: invalid signal: " << signo << "\n";
480	goto fail_exit;
481	}
482	}
483
484	fail_exit:
485	_exit(EXIT_FAILURE);
486	}
487
488	#endif