/*
* Copyright 1993, 1995 Christopher Seiwald.
* Copyright 2007 Noel Belcourt.
*
* This file is part of Jam - see jam.c for Copyright information.
*/
#include "jam.h"
#include "lists.h"
#include "execcmd.h"
#include "output.h"
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <time.h>
#include <unistd.h> /* needed for vfork(), _exit() prototypes */
#include <sys/resource.h>
#include <sys/times.h>
#include <sys/wait.h>
#if defined(sun) || defined(__sun) || defined(linux)
#include <wait.h>
#endif
#ifdef USE_EXECUNIX
#include <sys/times.h>
#if defined(__APPLE__)
#define NO_VFORK
#endif
#ifdef NO_VFORK
#define vfork() fork()
#endif
/*
* execunix.c - execute a shell script on UNIX/WinNT/OS2/AmigaOS
*
* If $(JAMSHELL) is defined, uses that to formulate execvp()/spawnvp().
* The default is:
*
* /bin/sh -c % [ on UNIX/AmigaOS ]
* cmd.exe /c % [ on OS2/WinNT ]
*
* Each word must be an individual element in a jam variable value.
*
* In $(JAMSHELL), % expands to the command string and ! expands to the slot
* number (starting at 1) for multiprocess (-j) invocations. If $(JAMSHELL) does
* not include a %, it is tacked on as the last argument.
*
* Do not just set JAMSHELL to /bin/sh or cmd.exe - it will not work!
*
* External routines:
* exec_cmd() - launch an async command execution.
* exec_wait() - wait and drive at most one execution completion.
*
* Internal routines:
* onintr() - bump intr to note command interruption.
*
* 04/08/94 (seiwald) - Coherent/386 support added.
* 05/04/94 (seiwald) - async multiprocess interface
* 01/22/95 (seiwald) - $(JAMSHELL) support
* 06/02/97 (gsar) - full async multiprocess support for Win32
*/
static clock_t tps = 0;
static struct timeval tv;
static int select_timeout = 0;
static int intr = 0;
static int cmdsrunning = 0;
static struct tms old_time;
#define OUT 0
#define ERR 1
static struct
{
int pid; /* on win32, a real process handle */
int fd[2]; /* file descriptors for stdout and stderr */
FILE *stream[2]; /* child's stdout (0) and stderr (1) file stream */
clock_t start_time; /* start time of child process */
int exit_reason; /* termination status */
int action_length; /* length of action string */
int target_length; /* length of target string */
char *action; /* buffer to hold action and target invoked */
char *target; /* buffer to hold action and target invoked */
char *command; /* buffer to hold command being invoked */
char *buffer[2]; /* buffer to hold stdout and stderr, if any */
void (*func)( void *closure, int status, timing_info*, char *, char * );
void *closure;
time_t start_dt; /* start of command timestamp */
} cmdtab[ MAXJOBS ] = {{0}};
/*
* onintr() - bump intr to note command interruption
*/
void onintr( int disp )
{
++intr;
printf( "...interrupted\n" );
}
/*
* exec_cmd() - launch an async command execution.
*/
void exec_cmd
(
char * string,
void (*func)( void *closure, int status, timing_info*, char *, char * ),
void * closure,
LIST * shell,
char * action,
char * target
)
{
static int initialized = 0;
int out[2];
int err[2];
int slot;
int len;
char * argv[ MAXARGC + 1 ]; /* +1 for NULL */
/* Find a slot in the running commands table for this one. */
for ( slot = 0; slot < MAXJOBS; ++slot )
if ( !cmdtab[ slot ].pid )
break;
if ( slot == MAXJOBS )
{
printf( "no slots for child!\n" );
exit( EXITBAD );
}
/* Forumulate argv. If shell was defined, be prepared for % and ! subs.
* Otherwise, use stock /bin/sh on unix or cmd.exe on NT.
*/
if ( shell )
{
int i;
char jobno[4];
int gotpercent = 0;
sprintf( jobno, "%d", slot + 1 );
for ( i = 0; shell && i < MAXARGC; ++i, shell = list_next( shell ) )
{
switch ( shell->string[0] )
{
case '%': argv[ i ] = string; ++gotpercent; break;
case '!': argv[ i ] = jobno; break;
default : argv[ i ] = shell->string;
}
if ( DEBUG_EXECCMD )
printf( "argv[%d] = '%s'\n", i, argv[ i ] );
}
if ( !gotpercent )
argv[ i++ ] = string;
argv[ i ] = 0;
}
else
{
argv[ 0 ] = "/bin/sh";
argv[ 1 ] = "-c";
argv[ 2 ] = string;
argv[ 3 ] = 0;
}
/* Increment jobs running. */
++cmdsrunning;
/* Save off actual command string. */
cmdtab[ slot ].command = BJAM_MALLOC_ATOMIC( strlen( string ) + 1 );
strcpy( cmdtab[ slot ].command, string );
/* Initialize only once. */
if ( !initialized )
{
times( &old_time );
initialized = 1;
}
/* Create pipes from child to parent. */
{
if ( pipe( out ) < 0 )
exit( EXITBAD );
if ( pipe( err ) < 0 )
exit( EXITBAD );
}
/* Start the command */
cmdtab[ slot ].start_dt = time(0);
if ( 0 < globs.timeout )
{
/*
* Handle hung processes by manually tracking elapsed time and signal
* process when time limit expires.
*/
struct tms buf;
cmdtab[ slot ].start_time = times( &buf );
/* Make a global, only do this once. */
if ( tps == 0 ) tps = sysconf( _SC_CLK_TCK );
}
if ( ( cmdtab[ slot ].pid = vfork() ) == 0 )
{
int pid = getpid();
close( out[0] );
close( err[0] );
dup2( out[1], STDOUT_FILENO );
if ( globs.pipe_action == 0 )
dup2( out[1], STDERR_FILENO );
else
dup2( err[1], STDERR_FILENO );
close( out[1] );
close( err[1] );
/* Make this process a process group leader so that when we kill it, all
* child processes of this process are terminated as well. We use
* killpg(pid, SIGKILL) to kill the process group leader and all its
* children.
*/
if ( 0 < globs.timeout )
{
struct rlimit r_limit;
r_limit.rlim_cur = globs.timeout;
r_limit.rlim_max = globs.timeout;
setrlimit( RLIMIT_CPU, &r_limit );
}
setpgid( pid,pid );
execvp( argv[0], argv );
perror( "execvp" );
_exit( 127 );
}
else if ( cmdtab[ slot ].pid == -1 )
{
perror( "vfork" );
exit( EXITBAD );
}
setpgid( cmdtab[ slot ].pid, cmdtab[ slot ].pid );
/* close write end of pipes */
close( out[1] );
close( err[1] );
/* set both file descriptors to non-blocking */
fcntl(out[0], F_SETFL, O_NONBLOCK);
fcntl(err[0], F_SETFL, O_NONBLOCK);
/* child writes stdout to out[1], parent reads from out[0] */
cmdtab[ slot ].fd[ OUT ] = out[0];
cmdtab[ slot ].stream[ OUT ] = fdopen( cmdtab[ slot ].fd[ OUT ], "rb" );
if ( cmdtab[ slot ].stream[ OUT ] == NULL )
{
perror( "fdopen" );
exit( EXITBAD );
}
/* child writes stderr to err[1], parent reads from err[0] */
if (globs.pipe_action == 0)
{
close(err[0]);
}
else
{
cmdtab[ slot ].fd[ ERR ] = err[0];
cmdtab[ slot ].stream[ ERR ] = fdopen( cmdtab[ slot ].fd[ ERR ], "rb" );
if ( cmdtab[ slot ].stream[ ERR ] == NULL )
{
perror( "fdopen" );
exit( EXITBAD );
}
}
/* Ensure enough room for rule and target name. */
if ( action && target )
{
len = strlen( action ) + 1;
if ( cmdtab[ slot ].action_length < len )
{
BJAM_FREE( cmdtab[ slot ].action );
cmdtab[ slot ].action = BJAM_MALLOC_ATOMIC( len );
cmdtab[ slot ].action_length = len;
}
strcpy( cmdtab[ slot ].action, action );
len = strlen( target ) + 1;
if ( cmdtab[ slot ].target_length < len )
{
BJAM_FREE( cmdtab[ slot ].target );
cmdtab[ slot ].target = BJAM_MALLOC_ATOMIC( len );
cmdtab[ slot ].target_length = len;
}
strcpy( cmdtab[ slot ].target, target );
}
else
{
BJAM_FREE( cmdtab[ slot ].action );
BJAM_FREE( cmdtab[ slot ].target );
cmdtab[ slot ].action = 0;
cmdtab[ slot ].target = 0;
cmdtab[ slot ].action_length = 0;
cmdtab[ slot ].target_length = 0;
}
/* Save the operation for exec_wait() to find. */
cmdtab[ slot ].func = func;
cmdtab[ slot ].closure = closure;
/* Wait until we are under the limit of concurrent commands. Do not trust
* globs.jobs alone.
*/
while ( ( cmdsrunning >= MAXJOBS ) || ( cmdsrunning >= globs.jobs ) )
if ( !exec_wait() )
break;
}
/* Returns 1 if file is closed, 0 if descriptor is still live.
*
* i is index into cmdtab
*
* s (stream) indexes:
* - cmdtab[ i ].stream[ s ]
* - cmdtab[ i ].buffer[ s ]
* - cmdtab[ i ].fd [ s ]
*/
int read_descriptor( int i, int s )
{
int ret;
int len;
char buffer[BUFSIZ];
while ( 0 < ( ret = fread( buffer, sizeof(char), BUFSIZ-1, cmdtab[ i ].stream[ s ] ) ) )
{
buffer[ret] = 0;
if ( !cmdtab[ i ].buffer[ s ] )
{
/* Never been allocated. */
cmdtab[ i ].buffer[ s ] = (char*)BJAM_MALLOC_ATOMIC( ret + 1 );
memcpy( cmdtab[ i ].buffer[ s ], buffer, ret + 1 );
}
else
{
/* Previously allocated. */
char * tmp = cmdtab[ i ].buffer[ s ];
len = strlen( tmp );
cmdtab[ i ].buffer[ s ] = (char*)BJAM_MALLOC_ATOMIC( len + ret + 1 );
memcpy( cmdtab[ i ].buffer[ s ], tmp, len );
memcpy( cmdtab[ i ].buffer[ s ] + len, buffer, ret + 1 );
BJAM_FREE( tmp );
}
}
return feof(cmdtab[ i ].stream[ s ]);
}
void close_streams( int i, int s )
{
/* Close the stream and pipe descriptor. */
fclose(cmdtab[ i ].stream[ s ]);
cmdtab[ i ].stream[ s ] = 0;
close(cmdtab[ i ].fd[ s ]);
cmdtab[ i ].fd[ s ] = 0;
}
void populate_file_descriptors( int * fmax, fd_set * fds)
{
int i, fd_max = 0;
struct tms buf;
clock_t current = times( &buf );
select_timeout = globs.timeout;
/* Compute max read file descriptor for use in select. */
FD_ZERO(fds);
for ( i = 0; i < globs.jobs; ++i )
{
if ( 0 < cmdtab[ i ].fd[ OUT ] )
{
fd_max = fd_max < cmdtab[ i ].fd[ OUT ] ? cmdtab[ i ].fd[ OUT ] : fd_max;
FD_SET(cmdtab[ i ].fd[ OUT ], fds);
}
if ( globs.pipe_action != 0 )
{
if (0 < cmdtab[ i ].fd[ ERR ])
{
fd_max = fd_max < cmdtab[ i ].fd[ ERR ] ? cmdtab[ i ].fd[ ERR ] : fd_max;
FD_SET(cmdtab[ i ].fd[ ERR ], fds);
}
}
if (globs.timeout && cmdtab[ i ].pid) {
clock_t consumed = (current - cmdtab[ i ].start_time) / tps;
clock_t process_timesout = globs.timeout - consumed;
if (0 < process_timesout && process_timesout < select_timeout) {
select_timeout = process_timesout;
}
if ( globs.timeout <= consumed )
{
killpg( cmdtab[ i ].pid, SIGKILL );
cmdtab[ i ].exit_reason = EXIT_TIMEOUT;
}
}
}
*fmax = fd_max;
}
/*
* exec_wait() - wait and drive at most one execution completion.
*/
int exec_wait()
{
int i;
int ret;
int fd_max;
int pid;
int status;
int finished;
int rstat;
timing_info time_info;
fd_set fds;
struct tms new_time;
/* Handle naive make1() which does not know if commands are running. */
if ( !cmdsrunning )
return 0;
/* Process children that signaled. */
finished = 0;
while ( !finished && cmdsrunning )
{
/* Compute max read file descriptor for use in select(). */
populate_file_descriptors( &fd_max, &fds );
if ( 0 < globs.timeout )
{
/* Force select() to timeout so we can terminate expired processes.
*/
tv.tv_sec = select_timeout;
tv.tv_usec = 0;
/* select() will wait until: i/o on a descriptor, a signal, or we
* time out.
*/
ret = select( fd_max + 1, &fds, 0, 0, &tv );
}
else
{
/* select() will wait until i/o on a descriptor or a signal. */
ret = select( fd_max + 1, &fds, 0, 0, 0 );
}
if ( 0 < ret )
{
for ( i = 0; i < globs.jobs; ++i )
{
int out = 0;
int err = 0;
if ( FD_ISSET( cmdtab[ i ].fd[ OUT ], &fds ) )
out = read_descriptor( i, OUT );
if ( ( globs.pipe_action != 0 ) &&
( FD_ISSET( cmdtab[ i ].fd[ ERR ], &fds ) ) )
err = read_descriptor( i, ERR );
/* If feof on either descriptor, then we are done. */
if ( out || err )
{
/* Close the stream and pipe descriptors. */
close_streams( i, OUT );
if ( globs.pipe_action != 0 )
close_streams( i, ERR );
/* Reap the child and release resources. */
pid = waitpid( cmdtab[ i ].pid, &status, 0 );
if ( pid == cmdtab[ i ].pid )
{
finished = 1;
pid = 0;
cmdtab[ i ].pid = 0;
/* Set reason for exit if not timed out. */
if ( WIFEXITED( status ) )
{
cmdtab[ i ].exit_reason = 0 == WEXITSTATUS( status )
? EXIT_OK
: EXIT_FAIL;
}
/* Print out the rule and target name. */
out_action( cmdtab[ i ].action, cmdtab[ i ].target,
cmdtab[ i ].command, cmdtab[ i ].buffer[ OUT ],
cmdtab[ i ].buffer[ ERR ], cmdtab[ i ].exit_reason
);
times( &new_time );
time_info.system = (double)( new_time.tms_cstime - old_time.tms_cstime ) / CLOCKS_PER_SEC;
time_info.user = (double)( new_time.tms_cutime - old_time.tms_cutime ) / CLOCKS_PER_SEC;
time_info.start = cmdtab[ i ].start_dt;
time_info.end = time( 0 );
old_time = new_time;
/* Drive the completion. */
--cmdsrunning;
if ( intr )
rstat = EXEC_CMD_INTR;
else if ( status != 0 )
rstat = EXEC_CMD_FAIL;
else
rstat = EXEC_CMD_OK;
/* Assume -p0 in effect so only pass buffer[ 0 ]
* containing merged output.
*/
(*cmdtab[ i ].func)( cmdtab[ i ].closure, rstat,
&time_info, cmdtab[ i ].command,
cmdtab[ i ].buffer[ 0 ] );
BJAM_FREE( cmdtab[ i ].buffer[ OUT ] );
cmdtab[ i ].buffer[ OUT ] = 0;
BJAM_FREE( cmdtab[ i ].buffer[ ERR ] );
cmdtab[ i ].buffer[ ERR ] = 0;
BJAM_FREE( cmdtab[ i ].command );
cmdtab[ i ].command = 0;
cmdtab[ i ].func = 0;
cmdtab[ i ].closure = 0;
cmdtab[ i ].start_time = 0;
}
else
{
printf( "unknown pid %d with errno = %d\n", pid, errno );
exit( EXITBAD );
}
}
}
}
}
return 1;
}
# endif /* USE_EXECUNIX */