/* * *   Copyright (c) International Business Machines  Corp., 2001 * *   This program is free software;  you can redistribute it and/or modify *   it under the terms of the GNU General Public License as published by *   the Free Software Foundation; either version 2 of the License, or *   (at your option) any later version. * *   This program is distributed in the hope that it will be useful, *   but WITHOUT ANY WARRANTY;  without even the implied warranty of *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See *   the GNU General Public License for more details. * *   You should have received a copy of the GNU General Public License *   along with this program;  if not, write to the Free Software *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *//* * FILE        : openfile.c * DESCRIPTION : Create files and open simultaneously * HISTORY: *   03/21/2001 Paul Larson (plars@us.ibm.com) *     -Ported *   11/01/2001 Mnaoj Iyer (manjo@austin.ibm.com) *     - Modified. *     added #inclide <unistd.h> * */#include <pthread.h>#include <stdio.h>#include <stdlib.h>#include <stdint.h>#include <unistd.h>#include "test.h"#include "usctest.h"char *TCID = "openfile01";    /* Test program identifier.    */int TST_TOTAL = 1;#define MAXFILES        32768#define MAXTHREADS      10/* Control Structure */struct cb {    pthread_mutex_t m;    pthread_cond_t init_cv;    pthread_cond_t thr_cv;    int thr_sleeping;} c;/* Global Variables */int numthreads = 10, numfiles = 10;int debug = 0;char *filename = "FILETOOPEN";void setup(void){    tst_tmpdir();}void cleanup(void){    tst_rmdir();}/* Procedures */void *threads(void *thread_id);/* ************************************************************************** *                              MAIN PROCEDURE                            * ************************************************************************** */int main(int argc, char *argv[]){    int i, opt, badopts = 0;    FILE *fd;    pthread_t th_id;    char msg[80] = "";    extern char *optarg;    while ((opt = getopt(argc, argv, "df:t:h")) != EOF) {        switch ((char)opt) {        case ‘d‘:            debug = 1;            break;        case ‘f‘:            numfiles = atoi(optarg);            if (numfiles <= 0)                badopts = 1;            break;        case ‘t‘:            numthreads = atoi(optarg);            if (numthreads <= 0)                badopts = 1;            break;        case ‘h‘:        default:            printf("Usage: openfile [-d] -f FILES -t THREADS\n");            _exit(1);        }    }    if (badopts) {        printf("Usage: openfile [-d] -f FILES -t THREADS\n");        _exit(1);    }    setup();    /* Check if numthreads is less than MAXFILES */    if (numfiles > MAXFILES) {        sprintf(msg, "%s\nCannot use %d files", msg, numfiles);        sprintf(msg, "%s, used %d files instead\n", msg, MAXFILES);        numfiles = MAXFILES;    }    /* Check if numthreads is less than MAXTHREADS */    if (numthreads > MAXTHREADS) {        sprintf(msg, "%s\nCannot use %d threads", msg, numthreads);        sprintf(msg, "%s, used %d threads instead\n", msg, MAXTHREADS);        numthreads = MAXTHREADS;    }    /* Create files */    if ((fd = fopen(filename, "w")) == NULL) {        tst_resm(TFAIL, "Could not create file");        cleanup();    }    /* Initialize thread control variables, lock & condition */    pthread_mutex_init(&c.m, NULL);    pthread_cond_init(&c.init_cv, NULL);    pthread_cond_init(&c.thr_cv, NULL);    c.thr_sleeping = 0;    /* Grab mutex lock */    if (pthread_mutex_lock(&c.m)) {        tst_resm(TFAIL, "failed to grab mutex lock");        fclose(fd);        unlink(filename);        cleanup();    }    printf("Creating Reading Threads\n");    /* Create threads */    for (i = 0; i < numthreads; i++)        if (pthread_create(&th_id, (pthread_attr_t *) NULL, threads,                   (void *)(uintptr_t) i)) {            tst_resm(TFAIL,                 "failed creating a pthread; increase limits");            fclose(fd);            unlink(filename);            cleanup();        }    /* Sleep until all threads are created */    while (c.thr_sleeping != numthreads)        if (pthread_cond_wait(&c.init_cv, &c.m)) {            tst_resm(TFAIL,                 "error while waiting for reading threads");            fclose(fd);            unlink(filename);            cleanup();        }    /* Wake up all threads */    if (pthread_cond_broadcast(&c.thr_cv)) {        tst_resm(TFAIL, "failed trying to wake up reading threads");        fclose(fd);        unlink(filename);        cleanup();    }    /* Release mutex lock */    if (pthread_mutex_unlock(&c.m)) {        tst_resm(TFAIL, "failed to release mutex lock");        fclose(fd);        unlink(filename);        cleanup();    }    tst_resm(TPASS, "Threads are done reading");    fclose(fd);    unlink(filename);    cleanup();    _exit(0);}/* ************************************************************************** *                OTHER PROCEDURES                * ************************************************************************** */void close_files(FILE * fd_list[], int len){    int i;    for (i = 0; i < len; i++) {        fclose(fd_list[i]);    }}/* threads: Each thread opens the files specified */void *threads(void *thread_id_){    int thread_id = (uintptr_t) thread_id_;    char errmsg[80];    FILE *fd_list[MAXFILES];    int i;    /* Open files */    for (i = 0; i < numfiles; i++) {        if (debug)            printf("Thread  %d : Opening file number %d \n",                   thread_id, i);        if ((fd_list[i] = fopen(filename, "rw")) == NULL) {            sprintf(errmsg, "FAIL - Couldn‘t open file #%d", i);            perror(errmsg);            if (i > 0) {                close_files(fd_list, i - 1);            }            unlink(filename);            pthread_exit((void *)1);        }    }    /* Grab mutex lock */    if (pthread_mutex_lock(&c.m)) {        perror("FAIL - failed to grab mutex lock");        close_files(fd_list, numfiles);        unlink(filename);        pthread_exit((void *)1);    }    /* Check if you should wake up main thread */    if (++c.thr_sleeping == numthreads)        if (pthread_cond_signal(&c.init_cv)) {            perror("FAIL - failed to signal main thread");            close_files(fd_list, numfiles);            unlink(filename);            pthread_exit((void *)1);        }    /* Sleep until woken up */    if (pthread_cond_wait(&c.thr_cv, &c.m)) {        perror("FAIL - failed to wake up correctly");        close_files(fd_list, numfiles);        unlink(filename);        pthread_exit((void *)1);    }    /* Release mutex lock */    if (pthread_mutex_unlock(&c.m)) {        perror("FAIL - failed to release mutex lock");        close_files(fd_list, numfiles);        unlink(filename);        pthread_exit((void *)1);    }    /* Close file handles and exit */    close_files(fd_list, numfiles);    unlink(filename);    pthread_exit((void *)0);}