static int rm_shared_mem(key_t shm_id, /* id of shared memory segment to be removed */ char *shm_addr, /* address of shared mem seg to be removed */ int cmd) { /* remove id only or remove id and detach seg */ struct shmid *shmbuf = NULL; /* info about the segment pointed by shmkey */ dprt("pid[%d]: rm_shared_mem(): shm_id = %d shm_addr = %#x cmd = %d\n", getpid(), shm_id, shm_addr, cmd); if (shmctl(shm_id, IPC_RMID, (struct shmid_ds *)shmbuf) == -1) { dprt("pid[%d]: rm_shared_mem(): shmctl unable to remove shm_id[%d]\n", getpid(), shm_id); perror("rm_shared_mem(): shmctl()"); return -1; } if (cmd) { if (shmdt((void *)shm_addr) == -1) { dprt("pid[%d]:rm_shared_mem(): shmdt unable to detach addr = %#x\n", getpid(), shm_addr); perror("rm_shared_mem(): shmdt()"); return -1; } } return 0; }
int main(int argc, /* number of input parameters */ char **argv) { /* pointer to the command line arguments. */ int c; /* command line options */ int num_thrd = MAXT; /* number of threads to create */ int num_reps = MAXR; /* number of repatitions the test is run */ int thrd_ndx; /* index into the array of thread ids */ void *th_status; /* exit status of LWP's */ int map_size; /* size of the file mapped. */ int shmkey = 1969; /* key used to generate shmid by shmget() */ pthread_t thrdid[30]; /* maxinum of 30 threads allowed */ long chld_args[4]; /* arguments to the thread function */ char *map_address = NULL; /* address in memory of the mapped file */ extern int optopt; /* options to the program */ while ((c = getopt(argc, argv, "hl:t:")) != -1) { switch (c) { case 'h': usage(argv[0]); break; case 'l': /* how many repetitions of the test to exec */ if ((num_reps = atoi(optarg)) == 0) OPT_MISSING(argv[0], optopt); else if (num_reps < 0) { fprintf(stdout, "WARNING: bad argument. Using default\n"); num_reps = MAXR; } break; case 't': if ((num_thrd = atoi(optarg)) == 0) OPT_MISSING(argv[0], optopt); else if (num_thrd < 0) { fprintf(stdout, "WARNING: bad argument. Using default\n"); num_thrd = MAXT; } break; default: usage(argv[0]); break; } } chld_args[0] = num_reps; for (thrd_ndx = 0; thrd_ndx < num_thrd; thrd_ndx += 2) { srand(time(NULL) % 100); map_size = (1 + (int)(1000.0 * rand() / (RAND_MAX + 1.0))) * 4096; chld_args[1] = shmkey++; chld_args[2] = map_size; dprt("main(): thrd_ndx = %d map_address = %#x map_size = %d\n", thrd_ndx, map_address, map_size); chld_args[3] = WRITER; if (pthread_create (&thrdid[thrd_ndx], NULL, shmat_rd_wr, chld_args)) { perror("shmat_rd_wr(): pthread_create()"); exit(-1); } chld_args[3] = READER; if (pthread_create (&thrdid[thrd_ndx + 1], NULL, shmat_rd_wr, chld_args)) { perror("shmat_rd_wr(): pthread_create()"); exit(-1); } } sync(); for (thrd_ndx = 0; thrd_ndx < num_thrd; thrd_ndx++) { if (pthread_join(thrdid[thrd_ndx], &th_status) != 0) { perror("shmat_rd_wr(): pthread_join()"); exit(-1); } else { dprt("WE ARE HERE %d\n", __LINE__); if (th_status == (void *)-1) { fprintf(stderr, "thread [%ld] - process exited with errors\n", (long)thrdid[thrd_ndx]); exit(-1); } } } exit(0); }
static void *shmat_rd_wr(void *args) { /* arguments to the thread function */ int shmndx = 0; /* index to the number of attach and detach */ int index = 0; /* index to the number of blocks touched */ int reader = 0; /* this thread is a reader thread if set to 1 */ key_t shm_id = 0; /* shared memory id */ long *locargs = /* local pointer to arguments */ (long *)args; volatile int exit_val = 0; /* exit value of the pthread */ char *read_from_mem; /* ptr to touch each (4096) block in memory */ char *write_to_mem; /* ptr to touch each (4096) block in memory */ char *shmat_addr; /* address of the attached memory */ char buff; /* temporary buffer */ reader = (int)locargs[3]; while (shmndx++ < (int)locargs[0]) { dprt("pid[%d]: shmat_rd_wr(): locargs[1] = %#x\n", getpid(), (int)locargs[1]); /* get shared memory id */ if ((shm_id = shmget((int)locargs[1], (int)locargs[2], IPC_CREAT | 0666)) == -1) { dprt("pid[%d]: shmat_rd_wr(): shmget failed\n", getpid()); perror("do_shmat_shmadt(): shmget()"); PTHREAD_EXIT(-1); } fprintf(stdout, "pid[%d]: shmat_rd_wr(): shmget():" "success got segment id %d\n", getpid(), shm_id); /* get shared memory segment */ if ((shmat_addr = shmat(shm_id, NULL, 0)) == (void *)-1) { rm_shared_mem(shm_id, shmat_addr, 0); fprintf(stderr, "pid[%d]: do_shmat_shmadt(): shmat_addr = %#lx\n", getpid(), (long)shmat_addr); perror("do_shmat_shmadt(): shmat()"); PTHREAD_EXIT(-1); } dprt("pid[%d]: do_shmat_shmadt(): content of memory shmat_addr = %s\n", getpid(), shmat_addr); fprintf(stdout, "pid[%d]: do_shmat_shmadt(): got shmat address = %#lx\n", getpid(), (long)shmat_addr); if (!reader) { /* write character 'Y' to that memory area */ index = 0; write_to_mem = shmat_addr; while (index < (int)locargs[2]) { dprt("pid[%d]: do_shmat_shmatd(): write_to_mem = %#x\n", getpid(), write_to_mem); *write_to_mem = 'Y'; index++; write_to_mem++; sched_yield(); } } else { /* read from the memory area */ index = 0; read_from_mem = shmat_addr; while (index < (int)locargs[2]) { buff = *read_from_mem; index++; read_from_mem++; sched_yield(); } } sched_yield(); /* remove the shared memory */ if (rm_shared_mem(shm_id, shmat_addr, 1) == -1) { fprintf(stderr, "pid[%d]: do_shmat_shmatd(): rm_shared_mem(): faild to rm id\n", getpid()); PTHREAD_EXIT(-1); } } PTHREAD_EXIT(0); }
static void * crte_mk_rm(void *args) { int dircnt; /* index to the number of subdirectories */ int fd; /* file discriptor of the files genetated */ int filecnt; /* index to the number of ".c" files created */ int numchar[2]; /* number of characters written to buffer */ char *dirname; /* name of the directory/idirectory tree */ char *tmpdirname; /* name of a temporary directory, for swaping */ char *cfilename; /* name of the ".c" file created */ char *mkfilename; /* name of the makefile - which is "makefile" */ char *hostname; /* hostname of the client machine */ char *prog_buf; /* buffer containing contents of the ".c" file*/ char *make_buf; /* buffer the contents of the makefile */ char *pwd; /* contains the current working directory */ long *locargptr = /* local pointer to arguments */ (long *)args; volatile int exit_val = 0; /* exit value of the pthreads */ if ((dirname = malloc(sizeof(char) * 2048)) == NULL) /* just paranoid */ { perror("crte_mk_rm(): dirname malloc()"); PTHREAD_EXIT(-1); } if ((tmpdirname = malloc(sizeof(char) * 2048)) == NULL) { perror("crte_mk_rm(): tmpdirname malloc()"); PTHREAD_EXIT(-1); } if ((cfilename = malloc(sizeof(char) * 2048)) == NULL) { perror("crte_mk_rm(): cfilename malloc()"); PTHREAD_EXIT(-1); } if ((mkfilename = malloc(sizeof(char) * 2048)) == NULL) { perror("crte_mk_rm(): mkfilename malloc()"); PTHREAD_EXIT(-1); } if ((prog_buf = malloc(sizeof(char) * 4096)) == NULL) { perror("crte_mk_rm(): prog_buf malloc()"); PTHREAD_EXIT(-1); } if ((pwd = malloc(PATH_MAX)) == NULL) { perror("crte_mk_rm(): pwd malloc()"); PTHREAD_EXIT(-1); } if ((hostname = malloc(sizeof(char) * 1024)) == NULL) { perror("crte_mk_rm(): hostname malloc()"); PTHREAD_EXIT(-1); } if (gethostname(hostname, 255) == -1) { perror("crte_mk_rm(): gethostname()"); PTHREAD_EXIT(-1); } if (!getcwd(pwd, PATH_MAX)) { perror("crte_mk_rm(): getcwd()"); PTHREAD_EXIT(-1); } numchar[0] = sprintf(prog_buf, "main()\n{\n\t printf(\"hello world\");\n}\n"); for (dircnt = 0; dircnt < (int)locargptr[0]; dircnt++) { /* First create the base directory, then create the subdirectories */ if (dircnt == 0) sprintf(dirname, "%s.%ld", hostname, gettid()); else { sprintf(tmpdirname, "%s/%ld.%d", dirname, gettid(), dircnt); sprintf(dirname, "%s", tmpdirname); } sync(); dprt("pid[%d] creating directory: %s\n", gettid(), dirname); if (mkdir(dirname, 0777) == -1) { perror("crte_mk_rm(): mkdir()"); PTHREAD_EXIT(-1); } } sync(); usleep(10); for (dircnt = 0; dircnt < (int)locargptr[0]; dircnt++) { if (dircnt == 0) sprintf(dirname, "%s/%s.%ld", pwd, hostname, gettid()); else { sprintf(tmpdirname, "%s/%ld.%d", dirname, gettid(), dircnt); sprintf(dirname, "%s", tmpdirname); } sync(); if ((make_buf = malloc(sizeof(char) * 4096)) == NULL) { perror("crte_mk_rm(): make_buf malloc()"); PTHREAD_EXIT(-1); } sprintf(mkfilename, "%s/makefile", dirname); { /* HACK! I could not write "%.c" to the makefile */ /* there is probably a correct way to do it */ char *dotc = malloc(10); dotc = ".c"; sync(); usleep(10); if (dircnt == (locargptr[0] - 1)) { numchar[1] = sprintf(make_buf, "CFLAGS := -O -w -g\n" "SUBDIRS = %ld.%d\n" "SRCS=$(wildcard *.c)\n" "TARGETS=$(patsubst %%%s,\%%,$(SRCS))\n" "all:\t $(TARGETS)\n" "clean:\n" "\trm -f $(TARGETS)\n", gettid(), dircnt + 1, dotc); } else { numchar[1] = sprintf(make_buf, "CFLAGS := -O -w -g\n" "SUBDIRS = %ld.%d\n" "SRCS=$(wildcard *.c)\n" "TARGETS=$(patsubst %%%s,\%%,$(SRCS))\n\n\n" "all:\t $(TARGETS)\n" "\t@for i in $(SUBDIRS); do $(MAKE) -C $$i ; done\n\n" "clean:\n" "\trm -f $(TARGETS)\n" "\t@for i in $(SUBDIRS); do $(MAKE) -C $$i clean ; done\n", gettid(), dircnt + 1, dotc); } }
static int rm_file_dir( int numsdir, /* how many subdirs to remove */ int numfiles, /* number of files to remove per dir */ char *hname, /* hostname of the client machine */ char *base_dir) /* directory where the test is located*/ { int filecnt; /* index to the num of files to remove*/ int dircnt; /* index into directory tree */ int sindex = numsdir; /* num subdirectory tree to remove */ char *dirname; /* name of the directory to chdir() */ char *tmpdirname; /* temp name for directory, for swap */ char *filename; /* name of the cfile to remove */ char *subdir; /* name of the sub dir to remove */ if ((dirname = malloc(sizeof(char) * 2048)) == NULL) /* just paranoid */ { perror("crte_mk_rm(): dirname malloc()"); return 1; } if ((tmpdirname = malloc(sizeof(char) * 2048)) == NULL) /* just paranoid */ { perror("crte_mk_rm(): tmpdirname malloc()"); return 1; } if ((filename = malloc(sizeof(char) * 2048)) == NULL) /* just paranoid */ { perror("crte_mk_rm(): filename malloc()"); return 1; } if ((subdir = malloc(sizeof(char) * 2048)) == NULL) /* just paranoid */ { perror("crte_mk_rm(): subdir malloc()"); return 1; } dprt("pid[%d]: base directory: %s\n", gettid(), base_dir); while (sindex) { /* get the name of the last directory created. */ for (dircnt = 0; dircnt < sindex; dircnt++) { if (dircnt == 0) sprintf(dirname, "%s/%s.%ld", base_dir, hname, gettid()); else { sprintf(tmpdirname, "%s/%ld.%d", dirname, gettid(), dircnt); sprintf(dirname, "%s", tmpdirname); } sync(); } dprt("pid[%d]: cd'ing to last created dir: %s\n", gettid(), dirname); sindex--; /* remove all the ".c" files and makefile in this directory */ for (filecnt = 0; filecnt < numfiles; filecnt++) { sprintf(filename, "%s/%ld.%d.%d.c", dirname, gettid(), dircnt - 1, filecnt); dprt("pid[%d]: removing file: %s\n", gettid(), filename); if (unlink(filename)) { dprt("pid[%d]: failed removing file: %s\n", gettid(), filename); perror("rm_file_dir(): unlink()"); free(tmpdirname); free(dirname); free(filename); free(subdir); return 1; } sync(); } sprintf(filename, "%s/%s", dirname, "makefile"); dprt("pid[%d]: removing %s\n", gettid(), filename); if (unlink(filename)) { perror("rm_file_dir() cound not remove makefile unlink()"); free(tmpdirname); free(dirname); free(filename); free(subdir); return 1; } sync(); /* the last directory does not have any more sub directories */ /* nothing to remove. */ dprt("pid[%d]: in directory count(dircnt): %d\n", gettid(), dircnt); dprt("pid[%d]: last directory(numsdir): %d\n", gettid(), numsdir); if (dircnt < numsdir) { /* remove the sub directory */ sprintf(subdir, "%s/%ld.%d", dirname, gettid(), dircnt); dprt("pid[%d]: removing subdirectory: %s\n", gettid(), subdir); if (rmdir(subdir) == -1) { perror("rm_file_dir() rmdir()"); free(tmpdirname); free(dirname); free(filename); free(subdir); return 1; } sync(); } } free(tmpdirname); free(dirname); free(filename); free(subdir); return 0; }
static int init_compile( int what_todo, /* do a compile or clean */ char *base_dir, /* base directory of the test */ char *hname) /* hostname of the machine */ { int status; /* return status of execve process */ pid_t pid; /* pid of the process that does compile */ char *dirname; /* location where compile is initated */ char *command; /* make or make clean command. */ if ((dirname = malloc(sizeof(char) * 2048)) == NULL) /* just paranoid */ { perror("init_compile(): dirname malloc()"); return 1; } if ((command = malloc(sizeof(char) * 1024)) == NULL) /* just paranoid */ { perror("init_compile(): dirname malloc()"); return 1; } what_todo ? sprintf(command, "make -s") : sprintf(command, "make -s clean"); sprintf(dirname, "%s/%s.%ld", base_dir, hname, gettid()); if (chdir(dirname) == -1) { dprt("pid[%d]: init_compile(): dir name = %s\n", gettid(), dirname); perror("init_compile() chdir()"); free(dirname); return 1; } dprt("pid[%d]: init_compile(): command = %s\n", gettid(), command); if ((pid = fork()) == -1) { perror("init_compile(): fork()"); return 1; } if (!pid) { char *argv[4]; argv[0] = "/bin/sh"; argv[1] = "-c"; argv[2] = command; argv[3] = 0; if (execv("/bin/sh", argv) == -1) { perror("init_compile(): execv()"); return 1; } } do { if (waitpid(pid, &status, 0) == -1) { if (errno != EINTR) { fprintf(stderr, "init_compile(): waitpid() failed\n"); return 1; } } else { if (chdir(base_dir) == -1) { dprt("pid[%d]: init_compile(): dir = %s\n", gettid(), dirname); perror("init_compile(): chdir()"); return 1; } dprt("pid[%d]: init_compile(): status = %d\n", status); dprt("we are here %d\n", __LINE__); return status; } } while (1); }
CLIENT * getkwarnd_handle(void) { void *localhandle; struct netconfig *nconf; struct netconfig *tpconf; struct timeval wait_time; struct utsname u; static char *hostname; static bool_t first_time = TRUE; /* * Total timeout (in seconds) talking to kwarnd. */ #define TOTAL_TIMEOUT 5 if (kwarn_clnt) return (kwarn_clnt); if (!(localhandle = setnetconfig())) return (NULL); tpconf = NULL; if (first_time == TRUE) { if (uname(&u) == -1) { (void) endnetconfig(localhandle); return ((CLIENT *)NULL); } if ((hostname = strdup(u.nodename)) == (char *)NULL) { (void) endnetconfig(localhandle); return ((CLIENT *)NULL); } first_time = FALSE; } while (nconf = getnetconfig(localhandle)) { if (strcmp(nconf->nc_protofmly, NC_LOOPBACK) == 0) { if (nconf->nc_semantics == NC_TPI_COTS_ORD) { kwarn_clnt = clnt_tp_create(hostname, KWARNPROG, KWARNVERS, nconf); if (kwarn_clnt) { dprt("got COTS_ORD\n"); break; } } else { tpconf = nconf; } } } if ((kwarn_clnt == NULL) && (tpconf)) { /* Now, try the connection-oriented loopback transport */ kwarn_clnt = clnt_tp_create(hostname, KWARNPROG, KWARNVERS, tpconf); #ifdef DEBUG if (kwarn_clnt) { dprt("got COTS\n"); } #endif /* DEBUG */ } (void) endnetconfig(localhandle); /* * This bit of code uses an as yet unimplemented argument to * clnt_control(). CLSET_SVC_PRIV specifies that the underlying * loopback transport should be checked to ensure it is * connected to a process running as root. If so, the clnt_control() * call returns TRUE. If not, it returns FALSE. */ #ifdef CLSET_SVC_PRIV if (clnt_control(kwarn_clnt, CLSET_SVC_PRIV, NULL) != TRUE) { clnt_destroy(kwarn_clnt); kwarn_clnt = NULL; return (NULL); { #endif if (kwarn_clnt == NULL) return (NULL); kwarn_clnt->cl_auth = authsys_create("", getuid(), 0, 0, NULL); if (kwarn_clnt->cl_auth == NULL) { clnt_destroy(kwarn_clnt); kwarn_clnt = NULL; return (NULL); } wait_time.tv_sec = TOTAL_TIMEOUT; wait_time.tv_usec = 0; (void) clnt_control(kwarn_clnt, CLSET_TIMEOUT, (char *)&wait_time); return (kwarn_clnt); } void resetkwarnd_handle(void) { auth_destroy(kwarn_clnt->cl_auth); clnt_destroy(kwarn_clnt); kwarn_clnt = NULL; }
/* * This is the meat and potatoes of the program. Spawn creates a tree * of processes with Dval depth and Bval breadth. Each parent will spawn * Bval children. Each child will store information about themselves * in shared memory. The leaf nodes will communicate the existence * of one another through message queues, once each leaf node has * received communication from all of her siblings she will reduce * the semaphore count and exit. Meanwhile all parents are waiting * to hear from their children through the use of semaphores. When * the semaphore count reaches zero then the parent knows all the * children have talked to one another. Locking of the connter semaphore * is provided by the use of another (binary) semaphore. */ int spawn(int val) { extern int sem_count; /* used to keep track of childern */ extern int sem_lock; /* used to lock access to sem_count semaphore */ int i; /* Breadth counter */ static int level = 0; /* level counter */ int lvlflg = 0; /* level toggle, limits parental spawning to one generation */ int pslot = 0; #ifdef __64LDT__ pid_t pid; /* pid of child process */ #else int pid; /* pid of child process */ #endif Pinfo *pinfo; /* pointer to process information in shared mem */ int semval; /* value of semaphore ( equals BVAL initially */ static int tval = 1; /* tree node value of child. */ char foo[1024]; level++; for (i = 1; i <= BVAL; i++) { tval = (val * BVAL) + i; if (!lvlflg) { pid = fork(); if (!pid) { /* CHILD */ if (AUSDEBUG) { sprintf(foo, "%sslot%d", SLOTDIR, tval); debugfp = fopen(foo, "a+"); } pinfo = put_proc_info(tval); debugout ("pid: %-6d ppid: %-6d lev: %-2d i: %-2d val: %-3d\n", pinfo->pid, pinfo->ppid, level, i, tval); set_timer(); /* set up signal handlers and initialize pgrp */ if (level < DVAL) { if (spawn(tval) == -1) { pslot = semoper(tval, sem_lock, -1); semarg.val = 0; /* to fix problem with 4th arg of semctl in 64 bits MARIOG */ semval = semctl(sem_count, pslot, GETVAL, semarg); semarg.val = --semval; /* to fix problem with 4th arg of semctl in 64 bits MARIOG */ semctl(sem_count, pslot, SETVAL, semarg); semarg.val = 1; /* to fix problem with 4th arg of semctl in 64 bits MARIOG */ semctl(sem_lock, pslot, SETVAL, semarg); } lvlflg++; } else { /* leaf node */ notify(tval); return (-1); } } #ifdef __64LDT__ else if (pid > 0 && i >= BVAL) { /* PARENT */ #else else if (pid > (pid_t) 0 && i >= BVAL) { /* PARENT */ #endif pslot = semoper(tval, sem_count, 0); pslot = semoper(pslot, sem_lock, -1); semarg.val = 0; /* to fix problem with 4th arg of semctl in 64 bits MARIOG */ semval = semctl(sem_count, pslot, GETVAL, semarg); semarg.val = --semval; /* to fix problem with 4th arg of semctl in 64 bits MARIOG */ semctl(sem_count, pslot, SETVAL, semarg); semarg.val = 1; /* to fix problem with 4th arg of semctl in 64 bits MARIOG */ semctl(sem_lock, pslot, SETVAL, semarg); (shmaddr + val)->msg++; } #ifdef __64LDT__ else if (pid < (pid_t) 0) { #else else if (pid < 0) { #endif perror("spawn: fork failed"); severe ("spawn: fork failed, exiting with errno %d\n", errno); exit(1); } else (shmaddr + val)->msg++; } } return (pslot); } /* * Allocate message queues. */ void setup_msgqueue(void) { extern int msgid; extern int msgerr; msgid = msgget(IPC_PRIVATE, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP); if (msgid == -1) { perror("msgget msgid failed"); fprintf(stderr, " SEVERE : msgget msgid failed: errno %d\n", errno); exit(1); } msgerr = msgget(IPC_PRIVATE, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP); if (msgerr == -1) { perror("msgget msgerr failed"); fprintf(stderr, " SEVERE : msgget msgerr failed: errno %d\n", errno); exit(1); } } /* * Set up and initialize all semaphores */ void setup_semaphores(void) { extern int sem_count; extern int sem_lock; int i; int rc; prtln(); sem_lock = semget(IPC_PRIVATE, nodesum - 1, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP); dprt("nodesum = %d, sem_lock = %d\n", nodesum, sem_lock); prtln(); if (sem_lock == -1) { perror("semget failed for sem_lock"); fprintf(stderr, " SEVERE : semget failed for sem_lock, errno: %d\n", errno); rm_shmseg(); exit(1); } prtln(); sem_count = semget(IPC_PRIVATE, nodesum - 1, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP); if (sem_count == -1) { perror("semget failed for sem_count"); fprintf(stderr, " SEVERE : semget failed for sem_count, errno: %d\n", errno); rm_shmseg(); exit(1); } prtln(); for (i = 0; i < (nodesum - 1); i++) { semarg.val = 1; /* to fix problem with 4th arg of semctl in 64 bits MARIOG */ rc = semctl(sem_lock, i, SETVAL, semarg); prtln(); if (rc == -1) { perror("semctl failed for sem_lock failed"); fprintf(stderr, " SEVERE : semctl failed for sem_lock, errno: %d\n", errno); rm_shmseg(); exit(1); } semarg.val = BVAL; /* to fix problem with 4th arg of semctl in 64 bits MARIOG */ rc = semctl(sem_count, i, SETVAL, semarg); prtln(); if (rc == -1) { perror("semctl failed for sem_lock failed"); fprintf(stderr, " SEVERE : semctl failed for sem_lock, errno: %d\n", errno); rm_shmseg(); exit(1); } } } /* * Set up and allocate shared memory. */ void setup_shm(void) { extern int nodesum; /* global shared memory id */ extern int shmid; /* global shared memory id */ extern Pinfo *shmaddr; int i, j; /* counters */ Pinfo *shmad = NULL; /* ptr to start of shared memory. */ Pinfo *pinfo = NULL; /* ptr to struct in shared memory. */ debugout("size = %d, size (in hex) = %#x nodes: %d\n", sizeof(Pinfo) * nodesum + (nodesum * BVAL * sizeof(int)), sizeof(Pinfo) * nodesum + (nodesum * BVAL * sizeof(int)), nodesum); /* Get shared memory id */ shmid = shmget(IPC_PRIVATE, sizeof(Pinfo) * nodesum + (nodesum * BVAL * sizeof(int)), IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP); if (shmid < 0) { perror("shmget failed"); fprintf(stderr, " SEVERE : shmget failed: errno %d\n", errno); exit(1); } /* allocate shared memory */ if ((shmad = shmat(shmid, (char *)shmad, 0)) == MAP_FAILED) { printf("SEVERE : shmat failed\n"); exit(1); } else { shmctl(shmid, IPC_RMID, NULL); } /* set all fields in shared memory to -1 */ for (pinfo = shmad, i = 0; i < nodesum; i++, pinfo++) { #ifdef __64LDT__ pinfo->pid = (pid_t) - 1; pinfo->ppid = (pid_t) - 1; #else pinfo->pid = -1; pinfo->ppid = -1; #endif pinfo->msg = -1; pinfo->err = -1; /* Changed 10/9/97 */ /* pinfo->list = (int *)((ulong)shmad + nodesum * sizeof(Pinfo) + (sizeof(int) * BVAL * i)); */ pinfo->list = (int *)((long)shmad + nodesum * sizeof(Pinfo) + (sizeof(int) * BVAL * i)); for (j = 0; j < BVAL; j++) *(pinfo->list + j) = -1; } shmaddr = shmad; } /* * Set up Signal handler and which signals to catch */ void set_signals(void *sighandler()) { int i; int rc; struct sigaction action; /* list of signals we want to catch */ static struct signalinfo { int signum; char *signame; } siginfo[] = { { SIGHUP, "SIGHUP"}, { SIGINT, "SIGINT"}, { SIGQUIT, "SIGQUIT"}, { SIGABRT, "SIGABRT"}, { SIGBUS, "SIGBUS"}, { SIGSEGV, "SIGSEGV"}, { SIGALRM, "SIGALRM"}, { SIGUSR1, "SIGUSR1"}, { SIGUSR2, "SIGUSR2"}, { -1, "ENDSIG"} }; char tmpstr[1024]; action.sa_handler = (void *)sighandler; #ifdef _LINUX sigfillset(&action.sa_mask); #else SIGINITSET(action.sa_mask); #endif action.sa_flags = 0; /* Set the signal handler up */ #ifdef _LINUX sigaddset(&action.sa_mask, SIGTERM); #else SIGADDSET(action.sa_mask, SIGTERM); #endif for (i = 0; siginfo[i].signum != -1; i++) { #ifdef _LINUX sigaddset(&action.sa_mask, siginfo[i].signum); #else SIGADDSET(action.sa_mask, siginfo[i].signum); #endif rc = sigaction(siginfo[i].signum, &action, NULL); if (rc == -1) { sprintf(tmpstr, "sigaction: %s\n", siginfo[i].signame); perror(tmpstr); fprintf(stderr, " SEVERE : Could not set %s signal action, errno=%d.", siginfo[i].signame, errno); exit(1); } } }