1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3 * Data Differential YATL (i.e. libtest) library
5 * Copyright (C) 2012 Data Differential, http://datadifferential.com/
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
14 * * Redistributions in binary form must reproduce the above
15 * copyright notice, this list of conditions and the following disclaimer
16 * in the documentation and/or other materials provided with the
19 * * The names of its contributors may not be used to endorse or
20 * promote products derived from this software without specific prior
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 #include <libtest/common.h>
40 using namespace libtest
;
53 #include <sys/types.h>
59 static char **environ
= NULL
;
63 static int exited_successfully(int status
)
70 if (WIFEXITED(status
) == true)
72 return WEXITSTATUS(status
);
74 else if (WIFSIGNALED(status
) == true)
76 return WTERMSIG(status
);
85 std::string
print_argv(libtest::vchar_ptr_t
& built_argv
)
87 std::stringstream arg_buffer
;
89 for (vchar_ptr_t::iterator iter
= built_argv
.begin();
90 iter
== built_argv
.end();
93 arg_buffer
<< *iter
<< " ";
96 return arg_buffer
.str();
99 std::string
print_argv(char** argv
)
101 std::stringstream arg_buffer
;
103 for (char** ptr
= argv
; *ptr
; ++ptr
)
105 arg_buffer
<< *ptr
<< " ";
108 return arg_buffer
.str();
111 static Application::error_t
int_to_error_t(int arg
)
116 return Application::INVALID
;
119 return Application::SUCCESS
;
123 return Application::FAILURE
;
130 Application::Application(const std::string
& arg
, const bool _use_libtool_arg
) :
131 _use_libtool(_use_libtool_arg
),
132 _use_valgrind(false),
134 _use_ptrcheck(false),
138 stdin_fd(STDIN_FILENO
),
139 stdout_fd(STDOUT_FILENO
),
140 stderr_fd(STDERR_FILENO
),
145 if (libtool() == NULL
)
147 fatal_message("libtool requested, but know libtool was found");
151 // Find just the name of the application with no path
153 size_t found
= arg
.find_last_of("/\\");
156 _exectuble_name
= arg
.substr(found
+1);
160 _exectuble_name
= arg
;
164 if (_use_libtool
and getenv("PWD"))
166 _exectuble_with_path
+= getenv("PWD");
167 _exectuble_with_path
+= "/";
169 _exectuble_with_path
+= _exectuble
;
172 Application::~Application()
178 Application::error_t
Application::run(const char *args
[])
183 _stdout_buffer
.clear();
184 _stderr_buffer
.clear();
186 posix_spawn_file_actions_t file_actions
;
187 posix_spawn_file_actions_init(&file_actions
);
189 stdin_fd
.dup_for_spawn(file_actions
);
190 stdout_fd
.dup_for_spawn(file_actions
);
191 stderr_fd
.dup_for_spawn(file_actions
);
193 posix_spawnattr_t spawnattr
;
194 posix_spawnattr_init(&spawnattr
);
198 fatal_assert(posix_spawnattr_setsigmask(&spawnattr
, &set
) == 0);
205 std::string gdb_run_file
= create_tmpfile(_exectuble_name
);
206 std::fstream file_stream
;
207 file_stream
.open(gdb_run_file
.c_str(), std::fstream::out
| std::fstream::trunc
);
209 _gdb_filename
= create_tmpfile(_exectuble_name
);
211 << "set logging redirect on" << std::endl
212 << "set logging file " << _gdb_filename
<< std::endl
213 << "set logging overwrite on" << std::endl
214 << "set logging on" << std::endl
215 << "set environment LIBTEST_IN_GDB=1" << std::endl
216 << "run " << arguments() << std::endl
217 << "thread apply all bt" << std::endl
218 << "quit" << std::endl
;
220 fatal_assert(file_stream
.good());
225 // libtool --mode=execute gdb -f -x binary
227 const_cast<char *>(libtool()),
228 const_cast<char *>("--mode=execute"),
229 const_cast<char *>("gdb"),
230 const_cast<char *>("-batch"),
231 const_cast<char *>("-f"),
232 const_cast<char *>("-x"),
233 const_cast<char *>(gdb_run_file
.c_str()),
234 const_cast<char *>(_exectuble_with_path
.c_str()),
237 spawn_ret
= posix_spawnp(&_pid
, libtool(), &file_actions
, &spawnattr
, argv
, environ
);
243 const_cast<char *>("gdb"),
244 const_cast<char *>("-batch"),
245 const_cast<char *>("-f"),
246 const_cast<char *>("-x"),
247 const_cast<char *>(gdb_run_file
.c_str()),
248 const_cast<char *>(_exectuble_with_path
.c_str()),
250 spawn_ret
= posix_spawnp(&_pid
, "gdb", &file_actions
, &spawnattr
, argv
, environ
);
258 spawn_ret
= posix_spawn(&_pid
, built_argv
[0], &file_actions
, &spawnattr
, &built_argv
[0], NULL
);
262 spawn_ret
= posix_spawnp(&_pid
, built_argv
[0], &file_actions
, &spawnattr
, &built_argv
[0], NULL
);
266 posix_spawn_file_actions_destroy(&file_actions
);
267 posix_spawnattr_destroy(&spawnattr
);
269 stdin_fd
.close(Application::Pipe::READ
);
270 stdout_fd
.close(Application::Pipe::WRITE
);
271 stderr_fd
.close(Application::Pipe::WRITE
);
275 if (_will_fail
== false)
277 Error
<< strerror(spawn_ret
) << "(" << spawn_ret
<< ")";
280 return Application::INVALID
;
283 return Application::SUCCESS
;
286 bool Application::check() const
288 if (_pid
> 1 and kill(_pid
, 0) == 0)
296 void Application::murder()
301 while ((count
--) > 0 and check())
303 int kill_ret
= kill(_pid
, SIGTERM
);
308 if ((waitpid_ret
= waitpid(_pid
, &status
, WNOHANG
)) == -1)
317 Error
<< "waitpid() failed after kill with error of " << strerror(errno
);
322 if (waitpid_ret
== 0)
324 libtest::dream(1, 0);
329 Error
<< "kill(pid, SIGTERM) failed after kill with error of " << strerror(errno
);
336 // If for whatever reason it lives, kill it hard
339 (void)kill(_pid
, SIGKILL
);
345 // false means that no data was returned
346 bool Application::slurp()
348 struct pollfd fds
[2];
349 fds
[0].fd
= stdout_fd
.fd();
350 fds
[0].events
= POLLRDNORM
;
352 fds
[1].fd
= stderr_fd
.fd();
353 fds
[1].events
= POLLRDNORM
;
357 if ((active_fd
= poll(fds
, 2, 0)) == -1)
360 switch ((error
= errno
))
362 #ifdef TARGET_OS_LINUX
370 fatal_message(strerror(error
));
374 fatal_message("RLIMIT_NOFILE exceeded, or if OSX the timeout value was invalid");
378 fatal_message(strerror(error
));
390 bool data_was_read
= false;
391 if (fds
[0].revents
& POLLRDNORM
)
393 if (stdout_fd
.read(_stdout_buffer
) == true)
399 if (fds
[1].revents
& POLLRDNORM
)
401 if (stderr_fd
.read(_stderr_buffer
) == true)
407 return data_was_read
;
410 Application::error_t
Application::wait(bool nohang
)
414 return Application::INVALID
;
419 error_t exit_code
= FAILURE
;
423 if ((waited_pid
= waitpid(_pid
, &status
, nohang
? WNOHANG
: 0)) == -1)
428 exit_code
= Application::SUCCESS
;
435 Error
<< "Error occured while waitpid(" << strerror(errno
) << ") on pid " << int(_pid
);
439 else if (waited_pid
== 0)
441 exit_code
= Application::SUCCESS
;
445 if (waited_pid
!= _pid
)
447 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "Pid mismatch, %d != %d", int(waited_pid
), int(_pid
));
449 exit_code
= int_to_error_t(exited_successfully(status
));
456 if (exit_code
== Application::INVALID
)
458 Error
<< print_argv(built_argv
, _argc
);
465 Application::error_t
Application::join()
469 return Application::INVALID
;
474 error_t exit_code
= FAILURE
;
479 waited_pid
= waitpid(_pid
, &status
, 0);
480 } while (waited_pid
== -1 and (errno
== EINTR
or errno
== EAGAIN
));
482 if (waited_pid
== -1)
487 exit_code
= Application::SUCCESS
;
494 Error
<< "Error occured while waitpid(" << strerror(errno
) << ") on pid " << int(_pid
);
498 else if (waited_pid
== 0)
500 exit_code
= Application::SUCCESS
;
504 if (waited_pid
!= _pid
)
506 throw libtest::fatal(LIBYATL_DEFAULT_PARAM
, "Pid mismatch, %d != %d", int(waited_pid
), int(_pid
));
509 exit_code
= int_to_error_t(exited_successfully(status
));
516 if (exit_code
== Application::INVALID
)
518 Error
<< print_argv(built_argv
, _argc
);
525 void Application::add_long_option(const std::string
& name
, const std::string
& option_value
)
527 std::string
arg(name
);
529 _options
.push_back(std::make_pair(arg
, std::string()));
532 void Application::add_option(const std::string
& arg
)
534 _options
.push_back(std::make_pair(arg
, std::string()));
537 void Application::add_option(const std::string
& name
, const std::string
& value
)
539 _options
.push_back(std::make_pair(name
, value
));
542 Application::Pipe::Pipe(int arg
) :
551 int Application::Pipe::Pipe::fd()
553 if (_std_fd
== STDOUT_FILENO
)
555 return _pipe_fd
[READ
];
557 else if (_std_fd
== STDERR_FILENO
)
559 return _pipe_fd
[READ
];
562 return _pipe_fd
[WRITE
]; // STDIN_FILENO
566 bool Application::Pipe::read(libtest::vchar_t
& arg
)
568 fatal_assert(_std_fd
== STDOUT_FILENO
or _std_fd
== STDERR_FILENO
);
570 bool data_was_read
= false;
573 char buffer
[1024]= { 0 };
574 while ((read_length
= ::read(_pipe_fd
[READ
], buffer
, sizeof(buffer
))))
576 if (read_length
== -1)
584 Error
<< strerror(errno
);
592 arg
.reserve(read_length
+1);
593 for (size_t x
= 0; x
< size_t(read_length
); ++x
)
595 arg
.push_back(buffer
[x
]);
597 // @todo Suck up all errput code here
600 return data_was_read
;
603 void Application::Pipe::nonblock()
606 if ((ret
= fcntl(_pipe_fd
[READ
], F_GETFL
, 0)) == -1)
608 Error
<< "fcntl(F_GETFL) " << strerror(errno
);
609 throw strerror(errno
);
612 if ((ret
= fcntl(_pipe_fd
[READ
], F_SETFL
, ret
| O_NONBLOCK
)) == -1)
614 Error
<< "fcntl(F_SETFL) " << strerror(errno
);
615 throw strerror(errno
);
619 void Application::Pipe::reset()
625 if (pipe2(_pipe_fd
, O_NONBLOCK
) == -1)
627 if (pipe(_pipe_fd
) == -1)
630 fatal_message(strerror(errno
));
642 void Application::Pipe::cloexec()
645 if ((ret
= fcntl(_pipe_fd
[WRITE
], F_GETFD
, 0)) == -1)
647 Error
<< "fcntl(F_GETFD) " << strerror(errno
);
648 throw strerror(errno
);
651 if ((ret
= fcntl(_pipe_fd
[WRITE
], F_SETFD
, ret
| FD_CLOEXEC
)) == -1)
653 Error
<< "fcntl(F_SETFD) " << strerror(errno
);
654 throw strerror(errno
);
658 Application::Pipe::~Pipe()
660 if (_pipe_fd
[0] != -1)
662 ::close(_pipe_fd
[0]);
665 if (_pipe_fd
[1] != -1)
667 ::close(_pipe_fd
[1]);
671 void Application::Pipe::dup_for_spawn(posix_spawn_file_actions_t
& file_actions
)
673 int type
= STDIN_FILENO
== _std_fd
? 0 : 1;
676 if ((ret
= posix_spawn_file_actions_adddup2(&file_actions
, _pipe_fd
[type
], _std_fd
)) < 0)
678 Error
<< "posix_spawn_file_actions_adddup2(" << strerror(ret
) << ")";
679 fatal_message(strerror(ret
));
682 if ((ret
= posix_spawn_file_actions_addclose(&file_actions
, _pipe_fd
[type
])) < 0)
684 Error
<< "posix_spawn_file_actions_adddup2(" << strerror(ret
) << ")";
685 fatal_message(strerror(ret
));
689 void Application::Pipe::close(const close_t
& arg
)
695 if (::close(_pipe_fd
[type
]) == -1)
697 Error
<< "close(" << strerror(errno
) << ")";
704 void Application::create_argv(const char *args
[])
710 built_argv
.push_back(strdup(libtool()));
711 built_argv
.push_back(strdup("--mode=execute"));
717 valgrind --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE
719 built_argv
.push_back(strdup("valgrind"));
720 built_argv
.push_back(strdup("--error-exitcode=1"));
721 built_argv
.push_back(strdup("--leak-check=yes"));
722 built_argv
.push_back(strdup("--show-reachable=yes"));
723 built_argv
.push_back(strdup("--track-fds=yes"));
725 built_argv
[x
++]= strdup("--track-origin=yes");
727 built_argv
.push_back(strdup("--malloc-fill=A5"));
728 built_argv
.push_back(strdup("--free-fill=DE"));
730 std::string log_file
= create_tmpfile("valgrind");
732 int length
= snprintf(buffer
, sizeof(buffer
), "--log-file=%s", log_file
.c_str());
733 fatal_assert(length
> 0 and size_t(length
) < sizeof(buffer
));
734 built_argv
.push_back(strdup(buffer
));
736 else if (_use_ptrcheck
)
739 valgrind --error-exitcode=1 --tool=exp-ptrcheck --log-file=
741 built_argv
.push_back(strdup("valgrind"));
742 built_argv
.push_back(strdup("--error-exitcode=1"));
743 built_argv
.push_back(strdup("--tool=exp-ptrcheck"));
744 std::string log_file
= create_tmpfile("ptrcheck");
746 int length
= snprintf(buffer
, sizeof(buffer
), "--log-file=%s", log_file
.c_str());
747 fatal_assert(length
> 0 and size_t(length
) < sizeof(buffer
));
748 built_argv
.push_back(strdup(buffer
));
752 built_argv
.push_back(strdup("gdb"));
755 built_argv
.push_back(strdup(_exectuble_with_path
.c_str()));
757 for (Options::const_iterator iter
= _options
.begin(); iter
!= _options
.end(); ++iter
)
759 built_argv
.push_back(strdup((*iter
).first
.c_str()));
760 if ((*iter
).second
.empty() == false)
762 built_argv
.push_back(strdup((*iter
).second
.c_str()));
768 for (const char **ptr
= args
; *ptr
; ++ptr
)
770 built_argv
.push_back(strdup(*ptr
));
773 built_argv
.push_back(NULL
);
776 std::string
Application::print()
778 return print_argv(built_argv
);
781 std::string
Application::arguments()
783 std::stringstream arg_buffer
;
785 for (size_t x
= (1 +_use_libtool
) ? 2 : 0;
786 x
< _argc
and built_argv
[x
];
789 arg_buffer
<< built_argv
[x
] << " ";
792 return arg_buffer
.str();
795 struct DeleteFromVector
798 void operator() ( T
* ptr
) const
804 void Application::delete_argv()
806 std::for_each(built_argv
.begin(), built_argv
.end(), DeleteFromVector());
813 int exec_cmdline(const std::string
& command
, const char *args
[], bool use_libtool
)
815 Application
app(command
, use_libtool
);
817 Application::error_t ret
= app
.run(args
);
819 if (ret
!= Application::SUCCESS
)
824 return int(app
.join());
827 const char *gearmand_binary()
829 return GEARMAND_BINARY
;
832 const char *drizzled_binary()
834 return DRIZZLED_BINARY
;
837 } // namespace exec_cmdline