Multithreaded C program to calculate CPU usage of cgroups

//TODO: localize?

pthread_join(systr, NULL); //join the system utilization thread
        if (systemUtilization > (long double)cpus) { //sanity check for HT
            systemUtilization = (long double)cpus;
        }
        printf("sys=%Lf\n", systemUtilization); //print info
        printf("cgrType2=%f\n", 0.0);
        printf("cgrType1=%f\n", 0.0);
        printf("cgrOther=%Lf\n", systemUtilization);
        pthread_mutex_destroy(&total_lock); //clean up mutex lock
        pthread_cond_destroy(&ok_to_add);

char* make_pid_path(char procid[], char procType[])
{
    const char* pathHead = "/sys/fs/cgroup/cpuacct/";
    const char* pathTail = "/cpuacct.stat";
    char* pidPath = (char*) malloc(
        strlen(pathHead) + strlen(pathTail) + strlen(procid) + 1);//+1 for the zero-terminator
    if (pidPath == NULL) {
        perror("Could not allocate memory for str\n");
        return NULL;
    }
    else {
        strcpy(pidPath, "/sys/fs/cgroup/cpuacct/"); //create the path to the cgroup info
        strcat(pidPath, procid);
        strcat(pidPath, "/cpuacct.stat");
    }


    return pidPath;
}

bool parse_cGroup_CPU_sample(char* pidPath, const char* pass, long double result[2])
{
    FILE* fp = fopen(pidPath, "r");
    if (fp == NULL) {
        perror(pidPath);
        return (-1);
    }
    else {
        if (fscanf(fp, "%*4s %Lf %*6s %Lf", &result[0], &result[1]) != 2) {
            char error_buffer[256];
            sprintf(error_buffer, "Could not parse %s cgroup CPU sample!\n", pass);
            perror(error_buffer);
            return false;
        }
        fclose(fp);
    }

    return true;
}

long double getLoadAverage(char* pidPath)
{
    long double a[2], b[2];
    long double loadavg = 0.0;

    for (int i = 0; i < ITERATIONS; i++) {
        if (!parse_cGroup_CPU_sample(pidPath, "first", a))
        {
            return -1;
        }
        else
        {
            sleep(1);
        }
        if (!parse_cGroup_CPU_sample(pidPath, "second", b))
        {
            return -1;
        }

        loadavg += ((b[0] + b[1]) - (a[0] + a[1])); //delta
    }

    loadavg = (loadavg / (clk * ITERATIONS)); //calculate the CPU use by delta divided by clock ticks per one second times iterations

    return loadavg;
}

int sampleCGroup(char procid[], char procType[]) {
    //open the cgroup cpustat file for the job based on the procid arg
    char* pidPath = make_pid_path(procid, procType);
    if (pidPath == NULL)
    {
        return -1;
    }

    long double loadavg = getLoadAverage(pidPath);
    
    free(pidPath); //free the memory allocated to the path variable
    if (loadavg < 0)
    {
        return -1;
    }

    //CRITICAL SECTION BEGIN
    pthread_mutex_lock(&total_lock); //lock mutex
    while (sumFlag == 0) {
        pthread_cond_wait(&ok_to_add, &total_lock); //wait on ok to add signal
    }

    pcreExecRet = pcre_exec(reCompiled,
        pcreExtra,
        procType,
        strlen(procType),          // length of string
        0,                      // Start looking at this point
        0,                      // OPTIONS
        subStrVec,
        30);                    // Length of subStrVec

    if (pcreExecRet > 0) {
        sum1 += loadavg;
    }
    else if (pcreExecRet == PCRE_ERROR_NOMATCH) {
        sum2 += loadavg;
    }
    else {
        sum2 += loadavg; //assume type2 if this fails
        perror("Could not determine type!\n");
    }

    sumFlag = 1;

    pthread_cond_signal(&ok_to_add); //signal that it is o

void report_utilization_and_clean_up_mutex(int cpus)
{
    pthread_join(systr, NULL); //join the system utilization thread
    if (systemUtilization > (long double)cpus) { //sanity check for HT
        systemUtilization = (long double)cpus;
    }
    printf("sys=%Lf\n", systemUtilization); //print info
    printf("cgrType2=%f\n", 0.0);
    printf("cgrType1=%f\n", 0.0);
    printf("cgrOther=%Lf\n", systemUtilization);
    pthread_mutex_destroy(&total_lock); //clean up mutex lock
    pthread_cond_destroy(&ok_to_add);
}

void testOperationNotSupported()
{
    int osVersion = getOSVersion();
    if (osVersion <= 10) {
        systemUtilization = getSystemUtilization();
        printf("sys=%Lf\n", systemUtilization); //cgroups are not supported on certain OS versions, so print the overall utilization and exit, otherwise, try to run
        pthread_mutex_destroy(&total_lock); //clean up mutex lock
        pthread_cond_destroy(&ok_to_add);
        exit(EXIT_SUCCESS);
    }
}

void performPcreOperations(int cpus)
{
    aStrRegex = "proc_type1"; //type1
    reCompiled = pcre_compile(aStrRegex, 0, &pcreErrorStr, &pcreErrorOffset, NULL); //compile the regex
    if (reCompiled == NULL) {
        printf("ERROR: Could not compile '%s': %s\n", aStrRegex, pcreErrorStr);
        report_utilization_and_clean_up_mutex(cpus);
        exit(EXIT_FAILURE);
    }
    // Optimize the regex
    pcreExtra = pcre_study(reCompiled, 0, &pcreErrorStr);
    /* pcre_study() returns NULL for both errors and when it can not optimize the regex.  The last argument is how one checks for
     errors (it is NULL if everything works, and points to an error string otherwise. */
    if (pcreErrorStr != NULL) {
        printf("ERROR: Could not study '%s': %s\n", aStrRegex, pcreErrorStr);
        report_utilization_and_clean_up_mutex(cpus);
        exit(EXIT_FAILURE);
    } /* end if */
}

struct job_struct* getJobs(int cpus, int* jobCount)
{
    char buff[1024];
    struct job_struct* jobs = (job_struct*)calloc(cpus, sizeof(*jobs)); //initially size the array to be the number of CPUs
    if (jobs == NULL)
    {
        fprintf(stderr, "Failed to allocate %d job structures in main()\n", cpus);
        exit(EXIT_FAILURE);
    }

    *jobCount = 0;

    FILE* fp = popen("/var/bin/getProcs", "r"); //open getProcs to list the procs, this returns the cgroup ID and the type
    if (fp == NULL) {
        perror("/var/bin/getProcs");
        report_utilization_and_clean_up_mutex(cpus);
        return (EXIT_FAILURE);
    }

    int ljobCount = 0;
    while (fgets(buff, sizeof(buff), fp) != NULL) {
        sscanf(buff, "%[^,],%[^,]", jobs[ljobCount].procid, jobs[ljobCount].procType);
        ljobCount++;
    }

    *jobCount = ljobCount;

    return jobs;
}

int main(void) {
    int jobCount = 0;

    testOperationNotSupported();

    int cpus = getCPUCount();
    clk = CLK_TIME_PER_SECOND;

    struct job_struct* jobs = getJobs(cpus, &jobCount);

    sumFlag = 1; //condition variable for mutex