00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
#include "kprocess.h"
00021
#include "kprocctrl.h"
00022
00023
#include <config.h>
00024
00025
#include <sys/time.h>
00026
#include <sys/types.h>
00027
#include <sys/wait.h>
00028
#include <unistd.h>
00029
#include <errno.h>
00030
#include <fcntl.h>
00031
#include <stdio.h>
00032
#include <stdlib.h>
00033
00034
#include <qsocketnotifier.h>
00035
00036 KProcessController *
KProcessController::theKProcessController;
00037
int KProcessController::refCount;
00038
00039 void KProcessController::ref()
00040 {
00041
if( !refCount )
00042
theKProcessController =
new KProcessController;
00043 refCount++;
00044 }
00045
00046 void KProcessController::deref()
00047 {
00048 refCount--;
00049
if( !refCount ) {
00050
delete theKProcessController;
00051
theKProcessController = 0;
00052 }
00053 }
00054
00055 KProcessController::KProcessController()
00056 : needcheck( false )
00057 {
00058
if( pipe( fd ) )
00059 {
00060 perror(
"pipe" );
00061 abort();
00062 }
00063
00064 fcntl( fd[0], F_SETFL, O_NONBLOCK );
00065 fcntl( fd[1], F_SETFL, O_NONBLOCK );
00066 fcntl( fd[0], F_SETFD, FD_CLOEXEC );
00067 fcntl( fd[1], F_SETFD, FD_CLOEXEC );
00068
00069 notifier =
new QSocketNotifier( fd[0], QSocketNotifier::Read );
00070 notifier->
setEnabled(
true );
00071
QObject::connect( notifier, SIGNAL(activated(
int)),
00072 SLOT(slotDoHousekeeping()));
00073
00074 setupHandlers();
00075 }
00076
00077 KProcessController::~KProcessController()
00078 {
00079 resetHandlers();
00080
00081
delete notifier;
00082
00083
close( fd[0] );
00084
close( fd[1] );
00085 }
00086
00087
00088
extern "C" {
00089
static void theReaper(
int num )
00090 {
00091
KProcessController::theSigCHLDHandler( num );
00092 }
00093 }
00094
00095
struct sigaction KProcessController::oldChildHandlerData;
00096 bool KProcessController::handlerSet = false;
00097
00098 void KProcessController::setupHandlers()
00099 {
00100
if( handlerSet )
00101
return;
00102 handlerSet =
true;
00103
00104
struct sigaction act;
00105 sigemptyset( &act.sa_mask );
00106
00107 act.sa_handler = SIG_IGN;
00108 act.sa_flags = 0;
00109 sigaction( SIGPIPE, &act, 0L );
00110
00111 act.sa_handler = theReaper;
00112 act.sa_flags = SA_NOCLDSTOP;
00113
00114
00115
#ifdef SA_RESTART
00116
act.sa_flags |= SA_RESTART;
00117
#endif
00118
sigaction( SIGCHLD, &act, &oldChildHandlerData );
00119
00120 sigaddset( &act.sa_mask, SIGCHLD );
00121
00122 sigprocmask( SIG_UNBLOCK, &act.sa_mask, 0 );
00123 }
00124
00125
void KProcessController::resetHandlers()
00126 {
00127
if( !handlerSet )
00128
return;
00129 handlerSet =
false;
00130
00131 sigaction( SIGCHLD, &oldChildHandlerData, 0 );
00132
00133 }
00134
00135
00136
00137
00138 void KProcessController::theSigCHLDHandler(
int arg )
00139 {
00140
int saved_errno = errno;
00141
00142
char dummy = 0;
00143 ::write(
theKProcessController->
fd[1], &dummy, 1 );
00144
00145
if( oldChildHandlerData.sa_handler != SIG_IGN &&
00146 oldChildHandlerData.sa_handler != SIG_DFL )
00147 oldChildHandlerData.sa_handler( arg );
00148
00149 errno = saved_errno;
00150 }
00151
00152
int KProcessController::notifierFd()
const
00153
{
00154
return fd[0];
00155 }
00156
00157 void KProcessController::unscheduleCheck()
00158 {
00159
char dummy[16];
00160
if( ::read( fd[0], dummy,
sizeof(dummy) ) > 0 )
00161 needcheck =
true;
00162 }
00163
00164
void
00165 KProcessController::rescheduleCheck()
00166 {
00167
if( needcheck )
00168 {
00169 needcheck =
false;
00170
char dummy = 0;
00171 ::write( fd[1], &dummy, 1 );
00172 }
00173 }
00174
00175
void KProcessController::slotDoHousekeeping()
00176 {
00177
char dummy[16];
00178 ::read( fd[0], dummy,
sizeof(dummy) );
00179
00180
int status;
00181 again:
00182
QValueListIterator<KProcess*> it( kProcessList.
begin() );
00183
QValueListIterator<KProcess*> eit( kProcessList.
end() );
00184
while( it != eit )
00185 {
00186
KProcess *prc = *it;
00187
if( prc->
runs && waitpid( prc->
pid_, &status, WNOHANG ) > 0 )
00188 {
00189 prc->
processHasExited( status );
00190
00191
if (!theKProcessController)
00192
return;
00193
goto again;
00194 }
00195 ++it;
00196 }
00197
QValueListIterator<int> uit( unixProcessList.
begin() );
00198
QValueListIterator<int> ueit( unixProcessList.
end() );
00199
while( uit != ueit )
00200 {
00201
if( waitpid( *uit, 0, WNOHANG ) > 0 )
00202 {
00203 uit = unixProcessList.
remove( uit );
00204
deref();
00205 }
else
00206 ++uit;
00207 }
00208 }
00209
00210 bool KProcessController::waitForProcessExit(
int timeout )
00211 {
00212
for(;;)
00213 {
00214
struct timeval tv, *tvp;
00215
if (timeout < 0)
00216 tvp = 0;
00217
else
00218 {
00219 tv.tv_sec = timeout;
00220 tv.tv_usec = 0;
00221 tvp = &tv;
00222 }
00223
00224 fd_set fds;
00225 FD_ZERO( &fds );
00226 FD_SET( fd[0], &fds );
00227
00228
switch( select( fd[0]+1, &fds, 0, 0, tvp ) )
00229 {
00230
case -1:
00231
if( errno == EINTR )
00232
continue;
00233
00234
case 0:
00235
return false;
00236
default:
00237 slotDoHousekeeping();
00238
return true;
00239 }
00240 }
00241 }
00242
00243
void KProcessController::addKProcess(
KProcess* p )
00244 {
00245 kProcessList.
append( p );
00246 }
00247
00248
void KProcessController::removeKProcess(
KProcess* p )
00249 {
00250 kProcessList.
remove( p );
00251 }
00252
00253
void KProcessController::addProcess(
int pid )
00254 {
00255 unixProcessList.
append( pid );
00256
ref();
00257 }
00258
00259
#include "kprocctrl.moc"