helm/software/components/binaries/matitaprover/TreeLimitedRun.c

   1 //---------------------------------------------------------------------------
   2 //----Program to watch CPU usage of a process
   3 //----TreeLimitedRun <CPU time limit> <WC time limit> <Memory limit> <Job>
   4 //---------------------------------------------------------------------------
   5 //----SUN or LINUX or OSX (OSX is very generic)
   6 #if (!defined(SUN) && !defined(LINUX) && !defined(OSX))
   7     #define LINUX
   8 #endif
   9 //---------------------------------------------------------------------------
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <sys/time.h>
  13 #include <sys/resource.h>
  14 #include <sys/types.h>
  15 #include <sys/wait.h>
  16 #include <stdlib.h>
  17 #include <unistd.h>
  18 #include <dirent.h>
  19 #include <ctype.h>
  20 #include <signal.h>
  21 #include <errno.h>
  22 #ifdef SUN
  23 #include <procfs.h>
  24 #endif
  25 //---------------------------------------------------------------------------
  26 #define STRING_LENGTH 80
  27 #define MAX_PROCESSES 1000
  28 #define DEFAULT_DELAY_BETWEEN_CHECKS 10
  29 #define NANOSECONDS 1E9
  30 #define MICROSECONDS 1E6
  31 #define JIFFIES 100
  32
  33 #define STDOUT 1
  34 #define STDERR 2
  35
  36 typedef char String[STRING_LENGTH];
  37
  38 typedef struct {
  39     int Active;
  40     pid_t PID;
  41     pid_t PPID;
  42     double CPUTime;
  43     double AccumulatedCPUTime;
  44 } ProcessData;
  45
  46 typedef ProcessData ProcessDataArray[MAX_PROCESSES];
  47
  48 int GlobalInterrupted;
  49 int GlobalSignalReceived;
  50 //---------------------------------------------------------------------------
  51 void SIGCHLDHandler(int TheSignal) {
  52
  53 //DEBUG printf("Some child has died\n");
  54 //----The child is reaped in WatchChildTree
  55
  56 }
  57 //---------------------------------------------------------------------------
  58 void SIGCHLDReaper(int TheSignal) {
  59
  60     int DeadPID;
  61     int Status;
  62
  63     while ((DeadPID = waitpid(-1,&Status,WNOHANG)) > 0) {
  64 //DEBUG printf("!!! Child %d of TreeLimitedRun %d has died\n",DeadPID,getpid());fflush(stdout);
  65     }
  66
  67 }
  68 //---------------------------------------------------------------------------
  69 //----Controllers in the CASC/SystemOnTPTP/SSCPA/etc hierarchy may send
  70 //----SIGQUIT to stop things
  71 void SIGQUITHandler(int TheSignal) {
  72
  73 //DEBUG printf("!!! TreeLimitedRun %d got a signal %d\n",getpid(),TheSignal);fflush(stdout);
  74     GlobalInterrupted = 1;
  75     GlobalSignalReceived = TheSignal;
  76
  77 }
  78 //---------------------------------------------------------------------------
  79 void SetCPUTimeLimit(rlim_t CPUTimeLimit) {
  80
  81     struct rlimit ResourceLimits;
  82
  83 //----Set the signal handler
  84 //----No point - signals are reset on exec
  85 //----For some reason this is still needed, or the signal doesn't work
  86     if (signal(SIGXCPU,SIGQUITHandler) == SIG_ERR) {
  87         perror("Setting signal handler");
  88         exit(EXIT_FAILURE);
  89     }
  90
  91 //----Limit the CPU time. Need to get old one for hard limit field
  92     if (getrlimit(RLIMIT_CPU,&ResourceLimits) == -1) {
  93         perror("Getting CPU limit");
  94         exit(EXIT_FAILURE);
  95     }
  96 //----Set new CPU limit in ms (sent in secs)
  97     ResourceLimits.rlim_cur = CPUTimeLimit;
  98     if (setrlimit(RLIMIT_CPU,&ResourceLimits) == -1) {
  99         perror("Setting CPU limit");
 100         exit(EXIT_FAILURE);
 101     }
 102 }
 103 //-----------------------------------------------------------------------------
 104 void SetMemoryLimit(rlim_t MemoryLimit) {
 105
 106     struct rlimit ResourceLimits;
 107
 108 #ifdef RLIMIT_AS
 109 #define THE_LIMIT RLIMIT_AS
 110 #else
 111 #define THE_LIMIT RLIMIT_DATA
 112 #endif
 113
 114 //----Limit the memory. Need to get old one for hard limit field
 115     if (getrlimit(THE_LIMIT,&ResourceLimits) == -1) {
 116         perror("Getting memory limit");
 117         exit(EXIT_FAILURE);
 118     }
 119 //----Set new memory limit
 120     ResourceLimits.rlim_max = MemoryLimit;
 121     ResourceLimits.rlim_cur = MemoryLimit;
 122     if (setrlimit(THE_LIMIT,&ResourceLimits) == -1) {
 123         perror("Setting memory limit");
 124         exit(EXIT_FAILURE);
 125     }
 126 }
 127 //---------------------------------------------------------------------------
 128 //----Prevent core dumps that occur on timeout
 129 void SetNoCoreDump(void) {
 130
 131     struct rlimit ResourceLimits;
 132
 133 //----Get old resource limits
 134     if (getrlimit(RLIMIT_CORE,&ResourceLimits) == -1) {
 135         perror("Getting resource limit:");
 136         exit(EXIT_FAILURE);
 137     }
 138 //----Set new core limit to 0
 139     ResourceLimits.rlim_cur = 0;
 140     if (setrlimit(RLIMIT_CORE,&ResourceLimits) == -1) {
 141         perror("Setting resource limit:");
 142         exit(EXIT_FAILURE);
 143     }
 144 }
 145 //---------------------------------------------------------------------------
 146 #ifdef LINUX
 147 void GetProcessesOwnedByMe(uid_t MyRealUID,ProcessDataArray OwnedPIDs,
 148 int *NumberOfOwnedPIDs) {
 149
 150     DIR *ProcDir;
 151     struct dirent *ProcessDir;
 152     pid_t UID,PID,PPID;
 153     FILE *ProcFile;
 154     String ProcFileName,Line;
 155
 156     if ((ProcDir = opendir("/proc")) == NULL) {
 157         perror("ERROR: Cannot opendir /proc\n");
 158         exit(EXIT_FAILURE);
 159     }
 160 //DEBUG printf("look for processes owned by %d\n",MyRealUID);
 161
 162     *NumberOfOwnedPIDs = 0;
 163     while ((ProcessDir = readdir(ProcDir)) != NULL) {
 164         if (isdigit(ProcessDir->d_name[0])) {
 165             PID = (pid_t)atoi(ProcessDir->d_name);
 166             sprintf(ProcFileName,"/proc/%d/status",PID);
 167             if ((ProcFile = fopen(ProcFileName,"r")) != NULL) {
 168                 PPID = -1;
 169                 UID = -1;
 170                 while ((PPID == -1 || UID == -1) &&
 171 fgets(Line,STRING_LENGTH,ProcFile) != NULL) {
 172                     sscanf(Line,"PPid: %d",&PPID);
 173                     sscanf(Line,"Uid: %d",&UID);
 174                 }
 175                 fclose(ProcFile);
 176 //----Check that data was found
 177 //DEBUG printf("PID = %d PPID = %d UID = %d\n",PID,PPID,UID);
 178                 if (PPID == -1 || UID == -1) {
 179                     fprintf(stderr,"Could not get process information\n");
 180                     exit(EXIT_FAILURE);
 181                 }
 182 //----Check if this process is owned by this user
 183                 if (UID == MyRealUID) {
 184 //----Record the PIDs as potentially relevant
 185                     OwnedPIDs[*NumberOfOwnedPIDs].Active = 1;
 186                     OwnedPIDs[*NumberOfOwnedPIDs].PID = PID;
 187                     OwnedPIDs[*NumberOfOwnedPIDs].PPID = PPID;
 188                     (*NumberOfOwnedPIDs)++;
 189 //DEBUG printf("%d I own PID = %d PPID = %d UID = %d\n",*NumberOfOwnedPIDs,PID,PPID,UID);
 190                     if (*NumberOfOwnedPIDs >= MAX_PROCESSES) {
 191                         fprintf(stderr,"ERROR: Out of save process space\n");
 192                         exit(EXIT_FAILURE);
 193                     }
 194                 }
 195             } else {
 196 //----Bloody child just died
 197             }
 198         }
 199     }
 200     closedir(ProcDir);
 201 }
 202 //---------------------------------------------------------------------------
 203 float GetProcessTime(pid_t PID,int IncludeSelf,int IncludeChildren) {
 204
 205     FILE *ProcFile;
 206     String ProcFileName;
 207     float MyTime,ChildTime,ProcessTime;
 208     int UserModeJiffies,SystemModeJiffies,ChildUserModeJiffies,
 209 ChildSystemModeJiffies;
 210
 211     ProcessTime = 0;
 212     sprintf(ProcFileName,"/proc/%d/stat",PID);
 213     if ((ProcFile = fopen(ProcFileName,"r")) != NULL) {
 214         fscanf(ProcFile,"%*d %*s %*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u %d %d %d %d",&UserModeJiffies,&SystemModeJiffies,&ChildUserModeJiffies,
 215 &ChildSystemModeJiffies);
 216         fclose(ProcFile);
 217 //DEBUG printf("%d: my jiffies = %d, dead child jiffies = %d\n",PID,UserModeJiffies+SystemModeJiffies,ChildUserModeJiffies+ChildSystemModeJiffies);
 218 //----Time used by this process
 219         MyTime = ((float)(UserModeJiffies + SystemModeJiffies))/JIFFIES;
 220 //----Time used by this process's dead children (man pages are wrong - does
 221 //----not include my jiffies)
 222         ChildTime = ((float)(ChildUserModeJiffies + ChildSystemModeJiffies))/
 223 JIFFIES;
 224         if (IncludeSelf) {
 225             ProcessTime += MyTime;
 226         }
 227         if (IncludeChildren) {
 228             ProcessTime += ChildTime;
 229         }
 230 //DEBUG printf("Process time for %d is %f\n",PID,ProcessTime);
 231         return(ProcessTime);
 232     } else {
 233 //----Bloody process died, return 0 and catch it in the parent next time
 234         return(0);
 235     }
 236 }
 237 #endif
 238 //---------------------------------------------------------------------------
 239 #ifdef SUN
 240 void GetProcessesOwnedByMe(uid_t MyRealUID,ProcessDataArray OwnedPIDs,
 241 int *NumberOfOwnedPIDs) {
 242
 243     DIR *ProcDir;
 244     struct dirent *ProcessDir;
 245     pid_t PID;
 246     struct psinfo ProcessRecord;
 247     FILE *ProcFile;
 248     String ProcFileName;
 249
 250     if ((ProcDir = opendir("/proc")) == NULL) {
 251         perror("ERROR: Cannot opendir /proc\n");
 252         exit(EXIT_FAILURE);
 253     }
 254
 255 //DEBUG printf("look for processes owned by %d\n",MyRealUID);
 256
 257     *NumberOfOwnedPIDs = 0;
 258     while ((ProcessDir = readdir(ProcDir)) != NULL) {
 259         if (isdigit((int)ProcessDir->d_name[0])) {
 260             PID = (pid_t)atoi(ProcessDir->d_name);
 261             sprintf(ProcFileName,"/proc/%d/psinfo",(int)PID);
 262             if ((ProcFile = fopen(ProcFileName,"r")) != NULL) {
 263                 fread(&ProcessRecord,sizeof(ProcessRecord),1,ProcFile);
 264                 fclose(ProcFile);
 265 //----Check if this process is owned by this user
 266                 if (ProcessRecord.pr_uid == MyRealUID) {
 267 //----Record the PIDs as potentially relevant
 268                     OwnedPIDs[*NumberOfOwnedPIDs].PID = PID;
 269                     OwnedPIDs[*NumberOfOwnedPIDs].PPID = ProcessRecord.pr_ppid;
 270                     (*NumberOfOwnedPIDs)++;
 271                     if (*NumberOfOwnedPIDs >= MAX_PROCESSES) {
 272                         fprintf(stderr,"ERROR: Out of save process space\n");
 273                         exit(EXIT_FAILURE);
 274                     }
 275                 }
 276             } else {
 277 //----Bloody child just died
 278             }
 279         }
 280     }
 281     closedir(ProcDir);
 282 }
 283 //---------------------------------------------------------------------------
 284 float GetProcessTime(pid_t PID,int IncludeSelf,int IncludeChildren) {
 285
 286     FILE *ProcFile;
 287     String ProcFileName;
 288     pstatus_t StatusRecord;
 289     float ProcessTime;
 290
 291     ProcessTime = 0;
 292     sprintf(ProcFileName,"/proc/%d/status",(int)PID);
 293     if ((ProcFile = fopen(ProcFileName,"r")) != NULL) {
 294         fread(&StatusRecord,sizeof(StatusRecord),1,ProcFile);
 295         fclose(ProcFile);
 296         if (IncludeSelf) {
 297             ProcessTime += StatusRecord.pr_utime.tv_sec +
 298 StatusRecord.pr_stime.tv_sec +
 299 ((float)(StatusRecord.pr_utime.tv_nsec+StatusRecord.pr_stime.tv_nsec))/
 300 NANOSECONDS;
 301         }
 302         if (IncludeChildren) {
 303             ProcessTime += StatusRecord.pr_cutime.tv_sec +
 304 StatusRecord.pr_cstime.tv_sec +
 305 ((float)(StatusRecord.pr_cutime.tv_nsec+StatusRecord.pr_cstime.tv_nsec))/
 306 NANOSECONDS;
 307         }
 308 //DEBUG printf("Process %d has used U %ld +n%ld + S %ld +n%ld + CU %ld +n%ld + CS %ld +n%ld = %.1f\n",
 309 //DEBUG PID,StatusRecord.pr_utime.tv_sec,StatusRecord.pr_utime.tv_nsec,
 310 //DEBUG StatusRecord.pr_stime.tv_sec,StatusRecord.pr_stime.tv_nsec,
 311 //DEBUG StatusRecord.pr_cutime.tv_sec,StatusRecord.pr_cutime.tv_nsec,
 312 //DEBUG StatusRecord.pr_cstime.tv_sec,StatusRecord.pr_cstime.tv_nsec,
 313 //DEBUG ProcessTime);
 314         return(ProcessTime);
 315     } else {
 316 //----Bloody child died, return 0 and catch it in the parent next time
 317         return(0);
 318     }
 319 }
 320 #endif //----SUN
 321 //---------------------------------------------------------------------------
 322 #ifdef OSX
 323 //----No looking in /proc for OSX
 324 #endif
 325 //---------------------------------------------------------------------------
 326 int PIDInArray(pid_t PID,ProcessDataArray PIDs,int NumberOfPIDs) {
 327
 328     int PIDIndex;
 329
 330     for (PIDIndex = 0;PIDIndex < NumberOfPIDs;PIDIndex++) {
 331         if (PIDs[PIDIndex].PID == PID) {
 332             return(1);
 333         }
 334     }
 335     return(0);
 336 }
 337 //---------------------------------------------------------------------------
 338 #if (defined(LINUX)||defined(SUN))
 339 //----Only for systems that have /proc
 340
 341 int GetTreeTimes(uid_t MyRealUID,pid_t FirstBornPID,ProcessDataArray
 342 TreeTimes) {
 343
 344     ProcessDataArray OwnedPIDs;
 345     int NumberOfOwnedPIDs;
 346     int NumberOfTreeTimes;
 347     int CurrentTreeIndex;
 348     int OwnedIndex;
 349
 350 //----Get the list of processes owned by this user
 351     GetProcessesOwnedByMe(MyRealUID,OwnedPIDs,&NumberOfOwnedPIDs);
 352
 353 //----Check that the root of the tree is still there
 354 //DEBUG printf("Check if %d is alive\n",FirstBornPID);
 355     if (!PIDInArray(FirstBornPID,OwnedPIDs,NumberOfOwnedPIDs)) {
 356 //DEBUG printf("It is dead\n");
 357         return(0);
 358     }
 359 //DEBUG printf("It is alive\n");
 360
 361 //----Find those in the process tree, and get their times
 362     CurrentTreeIndex = 0;
 363     TreeTimes[0].Active = 1;
 364     TreeTimes[0].PID = FirstBornPID;
 365     TreeTimes[0].PPID = MyRealUID;
 366     TreeTimes[0].CPUTime = GetProcessTime(TreeTimes[0].PID,1,1);
 367     NumberOfTreeTimes = 1;
 368
 369     while (CurrentTreeIndex < NumberOfTreeTimes) {
 370 //DEBUG printf("%d %d is in the tree\n",TreeTimes[CurrentTreeIndex].PID,TreeTimes[CurrentTreeIndex].PPID);
 371 //----Scan for offspring
 372         TreeTimes[CurrentTreeIndex].CPUTime =
 373 GetProcessTime(TreeTimes[CurrentTreeIndex].PID,1,1);
 374         for (OwnedIndex = 0; OwnedIndex < NumberOfOwnedPIDs; OwnedIndex++) {
 375             if (OwnedPIDs[OwnedIndex].PPID == TreeTimes[CurrentTreeIndex].PID) {
 376                 TreeTimes[NumberOfTreeTimes].Active = 1;
 377                 TreeTimes[NumberOfTreeTimes].PID = OwnedPIDs[OwnedIndex].PID;
 378                 TreeTimes[NumberOfTreeTimes].PPID = OwnedPIDs[OwnedIndex].PPID;
 379                 NumberOfTreeTimes++;
 380             }
 381         }
 382 //----Move on to the next process in the tree
 383         CurrentTreeIndex++;
 384     }
 385
 386     return(NumberOfTreeTimes);
 387 }
 388
 389 #endif
 390 #ifdef OSX
 391 //----No /proc for OSX
 392 #endif
 393 //---------------------------------------------------------------------------
 394 //----Send signals and reports if process is known to be gone
 395 int SignalAndReport(int PID,int Signal,int RepeatUntilTerminated,
 396 char * ProcessType) {
 397
 398     String ErrorMessage;
 399     extern int errno;
 400     int Terminated;
 401     int NumberOfLoops;
 402
 403     Terminated = 0;
 404     NumberOfLoops = 0;
 405     do {
 406         NumberOfLoops++;
 407 //DEBUG printf("!!! TreeLimitedRun %d sends signal %d to %s %d\n",getpid(),Signal,ProcessType,PID);fflush(stdout);
 408         if (kill(PID,Signal) != 0) {
 409 //DEBUG printf("The kill errno is %d\n",errno);
 410 //----If process no longer exists record that to avoid killing again
 411             if (errno == ESRCH) {
 412                 Terminated = 1;
 413             } else {
 414                 sprintf(ErrorMessage,
 415 "!!! ERROR: TreeLimitedRun %d cannot signal %s %d with %d",getpid(),ProcessType,
 416 PID,Signal);
 417                 perror(ErrorMessage);
 418             }
 419         }
 420 //----Must do perror after errno, as perror clears errno
 421     } while (RepeatUntilTerminated && !Terminated && NumberOfLoops < 10);
 422
 423     return(Terminated);
 424 }
 425 //---------------------------------------------------------------------------
 426 void ChildKillTree(int TargetIndex,ProcessDataArray TreeTimes,
 427 int NumberInTree,int Signal) {
 428
 429     int ChildIndex;
 430
 431 //DEBUG printf("!!! TreeLimitedRun %d killing tree below PID %d with %d\n",getpid(),TreeTimes[TargetIndex].PID,Signal);fflush(stdout);
 432     for (ChildIndex=0; ChildIndex < NumberInTree; ChildIndex++) {
 433         if (TreeTimes[TargetIndex].PID == TreeTimes[ChildIndex].PPID) {
 434             ChildKillTree(ChildIndex,TreeTimes,NumberInTree,Signal);
 435         }
 436 //TOO SLOW? usleep(100000);
 437     }
 438     if (TreeTimes[TargetIndex].Active) {
 439         if (SignalAndReport(TreeTimes[TargetIndex].PID,Signal,
 440 Signal == SIGKILL,"tree process")) {
 441             TreeTimes[TargetIndex].Active = 0;
 442         }
 443     }
 444 }
 445 //---------------------------------------------------------------------------
 446 int KillTree(uid_t MyRealUID,pid_t FirstBornPID,int Signal) {
 447
 448     int NumberOfTreeTimes;
 449     extern int errno;
 450
 451 #if (defined(LINUX)||defined(SUN))
 452     ProcessDataArray TreeTimes;
 453
 454     if ((NumberOfTreeTimes = GetTreeTimes(MyRealUID,FirstBornPID,TreeTimes)) >
 455 0) {
 456
 457 //----The first born gets it first so that it can curb its descendants nicely
 458         if (TreeTimes[0].Active) {
 459 //DEBUG printf("!!! TreeLimitedRun %d killing top process %d with %d\n",getpid(),TreeTimes[0].PID,Signal);fflush(stdout);
 460 //----TreeTimes[0].PID is FirstBornPID
 461             if (SignalAndReport(TreeTimes[0].PID,Signal,Signal == SIGKILL,
 462 "top process")) {
 463                 TreeTimes[0].Active = 0;
 464             }
 465         }
 466
 467 //----200000 is not enough - EP's eproof script gets killed before it can
 468 //----kill eprover
 469         usleep(500000);
 470 //----Now gently from the bottom up
 471         ChildKillTree(0,TreeTimes,NumberOfTreeTimes,Signal);
 472         usleep(100000);
 473 //----Now viciously from the bottom up
 474         ChildKillTree(0,TreeTimes,NumberOfTreeTimes,SIGKILL);
 475     }
 476 #endif
 477 #ifdef OSX
 478     int Active;
 479
 480     Active = 1;
 481 //----The first born gets it first so that it can curb its descendants nicely
 482     if (SignalAndReport(FirstBornPID,Signal,Signal == SIGKILL,"top process")) {
 483         Active = 0;
 484     }
 485     if (Active) {
 486         usleep(100000);
 487 //----Now viciously
 488         SignalAndReport(FirstBornPID,SIGKILL,1,"only process");
 489     }
 490     NumberOfTreeTimes = 1;
 491 #endif
 492
 493     return(NumberOfTreeTimes);
 494 }
 495 //---------------------------------------------------------------------------
 496 void KillOrphans(uid_t MyRealUID,ProcessDataArray SavePIDs,
 497 int NumberOfSavePIDs) {
 498
 499 #if (defined(LINUX)||defined(SUN))
 500
 501     ProcessDataArray OwnedPIDs;
 502     int NumberOfOwnedPIDs;
 503     int OwnedIndex;
 504     int NumberOfOrphansKilled;
 505     extern int errno;
 506
 507     do {
 508 //----Get the list of processes owned by this user
 509         GetProcessesOwnedByMe(MyRealUID,OwnedPIDs,&NumberOfOwnedPIDs);
 510
 511         NumberOfOrphansKilled = 0;
 512         for (OwnedIndex = 0; OwnedIndex < NumberOfOwnedPIDs; OwnedIndex++) {
 513 //DEBUG printf("!!! TreeLimitedRun %d considers %d with parent %d\n",getpid(),OwnedPIDs[OwnedIndex].PID, OwnedPIDs[OwnedIndex].PPID);fflush(stdout);
 514             if (OwnedPIDs[OwnedIndex].PPID == 1 &&
 515 !PIDInArray(OwnedPIDs[OwnedIndex].PID,SavePIDs,NumberOfSavePIDs)) {
 516 //DEBUG printf("!!! TreeLimitedRun %d kills orphan %d\n",getpid(),OwnedPIDs[OwnedIndex].PID);fflush(stdout);
 517                 if (SignalAndReport(OwnedPIDs[OwnedIndex].PID,SIGQUIT,0,
 518 "orphan")) {
 519                     OwnedPIDs[OwnedIndex].Active = 0;
 520                 }
 521                 if (OwnedPIDs[OwnedIndex].Active) {
 522                     sleep(1);
 523                     SignalAndReport(OwnedPIDs[OwnedIndex].PID,SIGKILL,1,
 524 "orphan");
 525                 }
 526                 NumberOfOrphansKilled++;
 527             }
 528         }
 529         if (NumberOfOrphansKilled > 0) {
 530             printf("Killed %d orphans\n",NumberOfOrphansKilled);
 531         }
 532     } while (NumberOfOrphansKilled > 0);
 533
 534 #endif
 535 #ifdef OSX
 536 //----No orphans known for OSX
 537 #endif
 538 }
 539 //---------------------------------------------------------------------------
 540 void PrintTimes(char* Tag,float TreeCPUTime,float WCTime) {
 541
 542 //----You can print times with more accuracy here
 543     printf("%s: %.1f CPU %.1f WC\n",Tag,TreeCPUTime,WCTime);
 544     fflush(NULL);
 545 }
 546 //---------------------------------------------------------------------------
 547 float WallClockSoFar(struct timeval WCStartTime) {
 548
 549     struct timeval WCEndTime;
 550
 551     gettimeofday(&WCEndTime,NULL);
 552 //DEBUG printf("Started at %ld +%f and ended at %ld +%f\n",
 553 //DEBUG WCStartTime.tv_sec,WCStartTime.tv_usec/MICROSECONDS,
 554 //DEBUG WCEndTime.tv_sec,WCEndTime.tv_usec/MICROSECONDS);
 555
 556     return((WCEndTime.tv_sec - WCStartTime.tv_sec) +
 557 (WCEndTime.tv_usec - WCStartTime.tv_usec)/MICROSECONDS);
 558
 559 }
 560 //---------------------------------------------------------------------------
 561 double AccumulateTreeTime(int TargetIndex,ProcessDataArray TreeTimes,
 562 int NumberInTree) {
 563
 564     int ChildIndex;
 565
 566     TreeTimes[TargetIndex].AccumulatedCPUTime = TreeTimes[TargetIndex].CPUTime;
 567     for (ChildIndex=0; ChildIndex < NumberInTree; ChildIndex++) {
 568         if (TreeTimes[TargetIndex].PID == TreeTimes[ChildIndex].PPID) {
 569             TreeTimes[TargetIndex].AccumulatedCPUTime +=
 570 AccumulateTreeTime(ChildIndex,TreeTimes,NumberInTree);
 571         }
 572     }
 573
 574     return(TreeTimes[TargetIndex].AccumulatedCPUTime);
 575 }
 576 //---------------------------------------------------------------------------
 577 float WatchChildTree(int MyPID,int ChildPID,int CPUTimeLimit,
 578 int DelayBetweenChecks,struct timeval WCStartTime,int PrintEachCheck) {
 579
 580     double TreeTime,LastTreeTime,LostTime;
 581     int NumberInTree;
 582     int KilledInTree;
 583     int Status;
 584     int DeadPID;
 585 #if (defined(LINUX)||defined(SUN))
 586     ProcessDataArray TreeTimes;
 587 #endif
 588 #ifdef OSX
 589     struct rusage ResourceUsage;
 590 #endif
 591
 592     LastTreeTime = 0.0;
 593     LostTime = 0.0;
 594
 595 //----Loop watching times taken. Order is important - get time before
 596 //----checking for interrupt
 597     do {
 598 #if (defined(LINUX)||defined(SUN))
 599 //----Look at the tree
 600         NumberInTree = GetTreeTimes(getuid(),ChildPID,TreeTimes);
 601         TreeTime = AccumulateTreeTime(0,TreeTimes,NumberInTree);
 602 //DEBUG fprintf(stderr,"now %5.2f limit %d\n",TreeTime,CPUTimeLimit);
 603 //----For those with /proc, reap the children. Need to reap late so /proc
 604 //----entries do not disappear
 605         while ((DeadPID = waitpid(-1,&Status,WNOHANG)) > 0) {
 606             NumberInTree--;
 607 //DEBUG fprintf(stderr,"The child %d has died\n",DeadPID);
 608         }
 609 #endif
 610 #ifdef OSX
 611 //----Check if child is gone (-1 if no child, 0 if not dead, PID if dead)
 612         DeadPID = waitpid(-1,&Status,WNOHANG);
 613         if (DeadPID == ChildPID || DeadPID == -1) {
 614             TreeTime = LastTreeTime;
 615             NumberInTree = 0;
 616         } else {
 617 //----Maybe more than 1, but we don't know in OSX version
 618             NumberInTree = 1;
 619         }
 620         if (getrusage(RUSAGE_CHILDREN,&ResourceUsage) != -1) {
 621             TreeTime = ResourceUsage.ru_utime.tv_sec +
 622 ResourceUsage.ru_utime.tv_usec / 1000000 + ResourceUsage.ru_stime.tv_sec +
 623 ResourceUsage.ru_stime.tv_usec / 1000000;
 624         } else {
 625             printf("TreeLimitedRun could not getrusage\n");
 626             TreeTime = LastTreeTime;
 627         }
 628 #endif
 629
 630 //DEBUG fprintf(stderr,"acc time is %.2f\n",TreeTime);
 631         if (TreeTime < LastTreeTime) {
 632             LostTime += LastTreeTime - TreeTime;
 633             printf("WARNING: TreeLimitedRun lost %.2fs, total lost is %.2fs\n",
 634 LastTreeTime - TreeTime,LostTime);
 635         }
 636 //DEBUG printf("lost time is %.2f\n",LostTime);
 637         LastTreeTime = TreeTime;
 638         TreeTime += LostTime;
 639
 640 //----Print each loop if requested
 641         if (PrintEachCheck) {
 642             PrintTimes("WATCH",TreeTime,WallClockSoFar(WCStartTime));
 643         }
 644 //----If we're going to loop, wait a bit first
 645 //----DANGER - if the last descedantprocess dies between GetTreeTimes() and
 646 //----here, it still waits.
 647         if ((CPUTimeLimit == 0 || TreeTime <= CPUTimeLimit) &&
 648 NumberInTree > 0 && !GlobalInterrupted) {
 649             sleep(DelayBetweenChecks);
 650         }
 651     } while ((CPUTimeLimit == 0 || TreeTime <= CPUTimeLimit) &&
 652 NumberInTree > 0 && !GlobalInterrupted);
 653
 654 //----From now on reap normally
 655     if (signal(SIGCHLD,SIGCHLDReaper) == SIG_ERR) {
 656         perror("ERROR: Could not set SIGCHLD handler");
 657         exit(EXIT_FAILURE);
 658     }
 659 //----Reap anyway in case I missed some
 660     SIGCHLDReaper(0);
 661
 662 //----If over time limit, stop them all (XCPU to top guy first)
 663     if (NumberInTree > 0 && TreeTime > CPUTimeLimit) {
 664         KilledInTree = KillTree(getuid(),ChildPID,SIGXCPU);
 665 //DEBUG printf("Killed %d in tree\n",KilledInTree);
 666     }
 667
 668 //----If global interrupted, then send it on
 669     if (NumberInTree > 0 && GlobalInterrupted) {
 670         KilledInTree = KillTree(getuid(),ChildPID,GlobalSignalReceived);
 671 //DEBUG printf("Killed %d in tree\n",KilledInTree);
 672     }
 673
 674     return(TreeTime);
 675 }
 676 //---------------------------------------------------------------------------
 677 int main(int argc,char *argv[]) {
 678
 679     int CPUTimeLimit;
 680     int WCTimeLimit;
 681     int MemoryLimit;
 682     int ArgNumber;
 683     int QuietnessLevel;
 684     int ArgOffset;
 685     pid_t ChildPID;
 686     float TreeCPUTime;
 687     float WCTime;
 688     struct timeval WCStartTime;
 689     int DelayBetweenChecks;
 690     int PrintEachCheck = 0;
 691     ProcessDataArray SavePIDs;
 692     int NumberOfSavePIDs;
 693     int Status;
 694
 695 //----Check the quietness level
 696     if (argc >= 2 && strstr(argv[1],"-q") == argv[1]) {
 697         ArgOffset = 1;
 698         QuietnessLevel = atoi(&argv[ArgOffset][2]);
 699     } else {
 700         QuietnessLevel = 1;
 701         ArgOffset = 0;
 702     }
 703
 704 //----Look for time and print flags
 705     if (argc >= ArgOffset+2 &&
 706 strstr(argv[ArgOffset+1],"-t") == argv[ArgOffset+1]) {
 707         ArgOffset++;
 708         DelayBetweenChecks = atoi(&argv[ArgOffset][2]);
 709     } else {
 710         if (argc >= ArgOffset+2 &&
 711 strstr(argv[ArgOffset+1],"-p") == argv[ArgOffset+1]) {
 712             PrintEachCheck = 1;
 713             ArgOffset++;
 714             DelayBetweenChecks = atoi(&argv[ArgOffset][2]);
 715         } else {
 716             DelayBetweenChecks = DEFAULT_DELAY_BETWEEN_CHECKS;
 717         }
 718     }
 719
 720     if (argc - ArgOffset >= 4) {
 721 //----Redirect stderr to stdout
 722         if (dup2(STDOUT,STDERR) == -1) {
 723             perror("ERROR: Cannot dup STDERR to STDOUT");
 724         }
 725
 726 //----Extract time limits
 727         CPUTimeLimit = atoi(argv[ArgOffset+1]);
 728         WCTimeLimit = atoi(argv[ArgOffset+2]);
 729         if (isdigit((int)argv[ArgOffset+3][0])) {
 730             MemoryLimit = atoi(argv[ArgOffset+3]);
 731             ArgOffset++;
 732         } else {
 733             MemoryLimit = 0;
 734         }
 735
 736         if (QuietnessLevel == 0) {
 737             printf(
 738 "TreeLimitedRun: ----------------------------------------------------------\n");
 739             printf("TreeLimitedRun: %s ",argv[ArgOffset+3]);
 740             for (ArgNumber=ArgOffset+4;ArgNumber<argc;ArgNumber++)
 741                 printf("%s ",argv[ArgNumber]);
 742             printf("\n");
 743             printf("TreeLimitedRun: CPU time limit is %ds\n",CPUTimeLimit);
 744             printf("TreeLimitedRun: WC  time limit is %ds\n",WCTimeLimit);
 745             if (MemoryLimit > 0) {
 746                 printf("TreeLimitedRun: Memory   limit is %dbytes\n",
 747 MemoryLimit);
 748             }
 749 //----Output the PID for possible later use
 750             printf("TreeLimitedRun: PID is %d\n",(int)getpid());
 751             printf(
 752 "TreeLimitedRun: ----------------------------------------------------------\n");
 753             fflush(stdout);
 754         }
 755         SetNoCoreDump();
 756
 757 //----Set handler for when child dies
 758         if (signal(SIGCHLD,SIGCHLDHandler) == SIG_ERR) {
 759             perror("ERROR: Could not set SIGCHLD handler");
 760             exit(EXIT_FAILURE);
 761         }
 762 //----Set handler for global interruptions and alarms
 763         GlobalInterrupted = 0;
 764         GlobalSignalReceived = 0;
 765         if (signal(SIGQUIT,SIGQUITHandler) == SIG_ERR) {
 766             perror("ERROR: Could not set SIGQUIT handler");
 767             exit(EXIT_FAILURE);
 768         }
 769         if (signal(SIGALRM,SIGQUITHandler) == SIG_ERR) {
 770             perror("ERROR: Could not set SIGALRM handler");
 771             exit(EXIT_FAILURE);
 772         }
 773
 774 #if (defined(LINUX)||defined(SUN))
 775 //----Record running processes at start (xeyes, gnome, etc)
 776         GetProcessesOwnedByMe(getuid(),SavePIDs,&NumberOfSavePIDs);
 777 #endif
 778 #ifdef OSX
 779 //----No recording processes for OSX
 780 #endif
 781
 782 //----Fork for ATP process
 783         if ((ChildPID = fork()) == -1) {
 784             perror("ERROR: Cannot fork for ATP system process");
 785             exit(EXIT_FAILURE);
 786         }
 787
 788 //----In child, set limits and execute the ATP system
 789         if (ChildPID == 0) {
 790             if (setvbuf(stdout,NULL,_IONBF,0) != 0) {
 791                 perror("Setting unbuffered");
 792             }
 793 //DEBUG printf("The prover PID will be %d\n",getpid());
 794 //----Set memory limit for child only
 795             if (MemoryLimit > 0) {
 796                 SetMemoryLimit(MemoryLimit);
 797             }
 798
 799 #if (defined(LINUX)||defined(SUN))
 800 //----Systems with /proc are stopped by this program with kill
 801 #endif
 802 #ifdef OSX
 803 //----In OSX case, child must limit itself
 804             if (CPUTimeLimit > 0) {
 805                 SetCPUTimeLimit(CPUTimeLimit);
 806             }
 807 #endif
 808
 809             execvp(argv[ArgOffset+3],argv+ArgOffset+3);
 810             perror("Cannot exec");
 811             exit(EXIT_FAILURE);
 812
 813 //----In parent, set limits and watch the ATP system
 814         } else {
 815             if (WCTimeLimit > 0) {
 816                 alarm(WCTimeLimit);
 817             }
 818 //----Record start time
 819             gettimeofday(&WCStartTime,NULL);
 820             TreeCPUTime = 0;
 821             WCTime = 0;
 822
 823 //----Watch the tree of processes
 824             TreeCPUTime = WatchChildTree(getpid(),ChildPID,CPUTimeLimit,
 825 DelayBetweenChecks,WCStartTime,PrintEachCheck);
 826
 827 //----Record end WC time
 828             WCTime = WallClockSoFar(WCStartTime);
 829
 830 //----See if the time is increased by looking at my children
 831 //----Not sure what this was for
 832 //            ChildTime = GetProcessTime(getpid(),0,1);
 833 //            if (ChildTime > TreeCPUTime) {
 834 //                TreeCPUTime = ChildTime;
 835 //            }
 836
 837             PrintTimes("FINAL WATCH",TreeCPUTime,WCTime);
 838
 839 //----Sweep for orphans
 840             KillOrphans(getuid(),SavePIDs,NumberOfSavePIDs);
 841 //----Reap any remaining
 842             while (wait(&Status) != -1) {
 843                 sleep(1);
 844 //DEBUG printf("!!! Waiting for children that havn't died\n");
 845             }
 846         }
 847     } else {
 848         printf("Usage: %s [-q<quietness>] [-t<check delay>|-p<print check delay>] <CPU limit> <WC limit> [<Memory limit>] <Job>\n",
 849 argv[0]);
 850     }
 851
 852     return(0);
 853 }
 854 //---------------------------------------------------------------------------