void ServPanelist ( Connection panelist, struct sockaddr_in client) { int psd, index=0; pid_t childpid; int *status; socklen_t t = sizeof(panelist.server); signal(SIGPIPE, PIPEhandler); for(;;){ psd = accept(panelist.socket_s, (struct sockaddr *) &client, &t); EchoServe(psd, client, GETUSERNAME); childpid = fork(); if ( childpid == 0) { signal (SIGQUIT, SIG_IGN); signal (SIGINT, SIG_IGN); signal (SIGTSTP,SIG_IGN); if (signal(SIGUSR1, displayHandle) == SIG_ERR) { fprintf(stderr, "cannot set handler for SIGUSR1\n"); } if (signal(SIGUSR2, SendMessage) == SIG_ERR) { fprintf(stderr, "cannot set handler for SIGUSR2\n"); } close (panelist.socket_s); EchoServe(psd, client, SERVPANEL); } else{ signal (SIGQUIT, SIG_IGN); signal (SIGINT, SIG_IGN); signal (SIGTSTP,SIG_IGN); cout << "\nNew Panel Client: (" << inet_ntoa(client.sin_addr) << ":" << ntohs(client.sin_port) << ") [" << client_msg << "]" << endl; cout << "Forked Panel Handler, PID = " << childpid << endl; *sharedInt_index = *sharedInt_index + 1 ; index = *sharedInt_index; //cout << "new parti " << index <<endl; list_participants[index].client_type = PARTICIPANT_PAN; list_participants[index].pid = childpid; list_participants[index].port = client.sin_port; list_participants[index].address = client.sin_addr; list_participants[index].buf_stream = psd; strcpy(list_participants[index].user_name, client_msg); // current date/time based on current system list_participants[index].time_in = time (NULL); } //Handle the child signal just end. Meaning of someone left the room. Pipe broken. int pid=wait(&status); //#define PARTICIPANT_AUD 1 //#define PARTICIPANT_PAN 2 //checkParticipant(index,PARTICIPANT_PAN); } }
/*------------------------------------------------------------------------ * rdsprocess - High-priority background process to repeatedly extract * an item from the request queue and send the request to * the remote disk server *------------------------------------------------------------------------ */ void rdsprocess ( struct rdscblk *rdptr /* Ptr to device control block */ ) { struct rd_msg_wreq msg; /* Message to be sent */ /* (includes data area) */ struct rd_msg_rres resp; /* Buffer to hold response */ /* (includes data area) */ int32 retval; /* Return value from rdscomm */ char *idto; /* Ptr to ID string copy */ char *idfrom; /* Ptr into ID string */ struct rdbuff *bptr; /* Ptr to buffer at the head of */ /* the request queue */ struct rdbuff *nptr; /* Ptr to next buffer on the */ /* request queue */ struct rdbuff *pptr; /* Ptr to previous buffer */ struct rdbuff *qptr; /* Ptr that runs along the */ /* request queue */ int32 i; /* Loop index */ while (TRUE) { /* Do forever */ /* Wait until the request queue contains a node */ wait(rdptr->rd_reqsem); bptr = rdptr->rd_rhnext; /* Use operation in request to determine action */ switch (bptr->rd_op) { case RD_OP_READ: /* Build a read request message for the server */ msg.rd_type = htons(RD_MSG_RREQ); /* Read request */ msg.rd_blk = htonl(bptr->rd_blknum); msg.rd_status = htons(0); msg.rd_seq = 0; /* Rdscomm fills in an entry */ idto = msg.rd_id; memset(idto, NULLCH, RD_IDLEN);/* Initialize ID to zero */ idfrom = rdptr->rd_id; while ( (*idto++ = *idfrom++) != NULLCH ) { /* Copy ID */ ; } /* Send the message and receive a response */ retval = rdscomm((struct rd_msg_hdr *)&msg, sizeof(struct rd_msg_rreq), (struct rd_msg_hdr *)&resp, sizeof(struct rd_msg_rres), rdptr ); /* Check response */ if ( (retval == SYSERR) || (retval == TIMEOUT) || (ntohs(resp.rd_status) != 0) ) { panic("Failed to contact remote disk server"); } /* Copy data from the reply into the buffer */ for (i=0; i<RD_BLKSIZ; i++) { bptr->rd_block[i] = resp.rd_data[i]; } /* Unlink buffer from the request queue */ nptr = bptr->rd_next; pptr = bptr->rd_prev; nptr->rd_prev = bptr->rd_prev; pptr->rd_next = bptr->rd_next; /* Insert buffer in the cache */ pptr = (struct rdbuff *) &rdptr->rd_chnext; nptr = pptr->rd_next; bptr->rd_next = nptr; bptr->rd_prev = pptr; pptr->rd_next = bptr; nptr->rd_prev = bptr; /* Initialize reference count */ bptr->rd_refcnt = 1; /* Signal the available semaphore */ signal(rdptr->rd_availsem); /* Send a message to waiting process */ send(bptr->rd_pid, (uint32)bptr); /* If other processes are waiting to read the */ /* block, notify them and remove the request */ qptr = rdptr->rd_rhnext; while (qptr != (struct rdbuff *)&rdptr->rd_rtnext) { if (qptr->rd_blknum == bptr->rd_blknum) { bptr->rd_refcnt++; send(qptr->rd_pid,(uint32)bptr); /* Unlink request from queue */ pptr = qptr->rd_prev; nptr = qptr->rd_next; pptr->rd_next = bptr->rd_next; nptr->rd_prev = bptr->rd_prev; /* Move buffer to the free list */ qptr->rd_next = rdptr->rd_free; rdptr->rd_free = qptr; signal(rdptr->rd_availsem); break; } qptr = qptr->rd_next; } break; case RD_OP_WRITE: /* Build a write request message for the server */ msg.rd_type = htons(RD_MSG_WREQ); /* Write request*/ msg.rd_blk = htonl(bptr->rd_blknum); msg.rd_status = htons(0); msg.rd_seq = 0; /* Rdscomb fills in an entry */ idto = msg.rd_id; memset(idto, NULLCH, RD_IDLEN);/* Initialize ID to zero */ idfrom = rdptr->rd_id; while ( (*idto++ = *idfrom++) != NULLCH ) { /* Copy ID */ ; } for (i=0; i<RD_BLKSIZ; i++) { msg.rd_data[i] = bptr->rd_block[i]; } /* Unlink buffer from request queue */ nptr = bptr->rd_next; pptr = bptr->rd_prev; pptr->rd_next = nptr; nptr->rd_prev = pptr; /* Insert buffer in the cache */ pptr = (struct rdbuff *) &rdptr->rd_chnext; nptr = pptr->rd_next; bptr->rd_next = nptr; bptr->rd_prev = pptr; pptr->rd_next = bptr; nptr->rd_prev = bptr; /* Declare that buffer is eligible for reuse */ bptr->rd_refcnt = 0; signal(rdptr->rd_availsem); /* Send the message and receive a response */ retval = rdscomm((struct rd_msg_hdr *)&msg, sizeof(struct rd_msg_wreq), (struct rd_msg_hdr *)&resp, sizeof(struct rd_msg_wres), rdptr ); /* Check response */ if ( (retval == SYSERR) || (retval == TIMEOUT) || (ntohs(resp.rd_status) != 0) ) { panic("failed to contact remote disk server"); } break; case RD_OP_SYNC: /* Send a message to the waiting process */ send(bptr->rd_pid, OK); /* Unlink buffer from the request queue */ nptr = bptr->rd_next; pptr = bptr->rd_prev; nptr->rd_prev = bptr->rd_prev; pptr->rd_next = bptr->rd_next; /* Insert buffer into the free list */ bptr->rd_next = rdptr->rd_free; rdptr->rd_free = bptr; signal(rdptr->rd_availsem); break; } sleepms(1); } }
int main(int argc, char **argv) { #ifdef WINDOWS HANDLE event; char cmdline[128]; if (argc == 1) { /* parent process */ STARTUPINFO si = { sizeof(STARTUPINFO) }; PROCESS_INFORMATION pi; HANDLE job, job2, job3; JOBOBJECT_EXTENDED_LIMIT_INFORMATION limit = {0,}; DWORD exitcode = (DWORD)-1; /* For synchronization we create an inherited event */ SECURITY_ATTRIBUTES sa = {sizeof(sa), NULL, TRUE/*inherit*/}; event = CreateEvent(&sa, FALSE/*manual reset*/, FALSE/*start unset*/, NULL); if (event == NULL) print("Failed to create event"); _snprintf(cmdline, BUFFER_SIZE_ELEMENTS(cmdline), "%s %p", argv[0], event); print("creating child #1\n"); if (!CreateProcess(argv[0], cmdline, NULL, NULL, TRUE/*inherit handles*/, 0, NULL, NULL, &si, &pi)) print("CreateProcess failure\n"); WaitForSingleObject(event, INFINITE); print("terminating child #1 by NtTerminateProcess\n"); TerminateProcess(pi.hProcess, 42); WaitForSingleObject(pi.hProcess, INFINITE); GetExitCodeProcess(pi.hProcess, &exitcode); print("child #1 exit code = %d\n", exitcode); if (!ResetEvent(event)) print("Failed to reset event\n"); print("creating child #2\n"); if (!CreateProcess(argv[0], cmdline, NULL, NULL, TRUE/*inherit handles*/, CREATE_SUSPENDED, NULL, NULL, &si, &pi)) print("CreateProcess failure\n"); job = CreateJobObject(NULL, "drx-test job"); AssignProcessToJobObject(job, pi.hProcess); ResumeThread(pi.hThread); CloseHandle(pi.hThread); WaitForSingleObject(event, INFINITE); print("terminating child #2 by NtTerminateJobObject\n"); TerminateJobObject(job, 123456); CloseHandle(job); WaitForSingleObject(pi.hProcess, INFINITE); GetExitCodeProcess(pi.hProcess, &exitcode); print("child #2 exit code = %d\n", exitcode); if (!ResetEvent(event)) print("Failed to reset event\n"); print("creating child #3\n"); if (!CreateProcess(argv[0], cmdline, NULL, NULL, TRUE/*inherit handles*/, CREATE_SUSPENDED, NULL, NULL, &si, &pi)) print("CreateProcess failure\n"); job = CreateJobObject(NULL, "drx-test job"); AssignProcessToJobObject(job, pi.hProcess); limit.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE; if (!SetInformationJobObject(job, JobObjectExtendedLimitInformation, &limit, sizeof(limit))) print("SetInformationJobObject failed\n"); ResumeThread(pi.hThread); CloseHandle(pi.hThread); WaitForSingleObject(event, INFINITE); print("terminating child #3 by closing job handle\n"); CloseHandle(job); WaitForSingleObject(pi.hProcess, INFINITE); GetExitCodeProcess(pi.hProcess, &exitcode); print("child #3 exit code = %d\n", exitcode); /* Test DuplicateHandle (DrMem i#1401) */ print("creating child #4\n"); if (!CreateProcess(argv[0], cmdline, NULL, NULL, TRUE/*inherit handles*/, CREATE_SUSPENDED, NULL, NULL, &si, &pi)) print("CreateProcess failure\n"); job = CreateJobObject(NULL, "drx-test job"); AssignProcessToJobObject(job, pi.hProcess); limit.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE; if (!SetInformationJobObject(job, JobObjectExtendedLimitInformation, &limit, sizeof(limit))) print("SetInformationJobObject failed\n"); if (!DuplicateHandle(GetCurrentProcess(), job, GetCurrentProcess(), &job2, 0, FALSE, DUPLICATE_SAME_ACCESS)) print("DuplicateHandle failed\n"); if (!DuplicateHandle(GetCurrentProcess(), job, GetCurrentProcess(), &job3, 0, FALSE, DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS)) print("DuplicateHandle failed\n"); ResumeThread(pi.hThread); CloseHandle(pi.hThread); WaitForSingleObject(event, INFINITE); print("terminating child #4 by closing both job handles\n"); CloseHandle(job2); CloseHandle(job3); WaitForSingleObject(pi.hProcess, INFINITE); GetExitCodeProcess(pi.hProcess, &exitcode); print("child #4 exit code = %d\n", exitcode); } else { /* child process */ int iter = 0; if (sscanf(argv[1], "%p", &event) != 1) { print("Failed to obtain event handle from %s\n", argv[1]); return -1; } if (!SetEvent(event)) print("Failed to set event\n"); /* spin until parent kills us or we time out */ while (iter++ < 12) { Sleep(5000); } } CloseHandle(event); #else /* WINDOWS */ int pipefd[2]; pid_t cpid; char buf = 0; if (pipe(pipefd) == -1) { perror("pipe"); exit(1); } print("creating child\n"); cpid = fork(); if (cpid == -1) { perror("fork"); exit(1); } else if (cpid > 0) { /* parent */ int status; close(pipefd[1]); /* close unused write end */ if (read(pipefd[0], &buf, sizeof(buf)) <= 0) { perror("pipe read failed"); exit(1); } print("terminating child by sending SIGKILL\n"); kill(cpid, SIGKILL); wait(&status); /* wait for child */ close(pipefd[0]); print("child exit code = %d\n", status); } else { /* child */ int iter = 0; close(pipefd[0]); /* close unused read end */ write(pipefd[1], &buf, sizeof(buf)); close(pipefd[1]); /* spin until parent kills us or we time out */ while (iter++ < 12) { sleep(5); } } #endif /* UNIX */ return 0; }
bool SynchronizableMulti::wait(int id, int q, bool front, long seconds) { return wait(id, q, front, seconds, 0); }
void obtain_measurement() { AnalogIn temperature_sensor(p15); uint16_t sensor_value; // value read from the analog in float temperature; // to store the value after the conversion from mV float voltage; // conversion from integer to mV char float_converted[50]; // to store the result of the conversion myled = 1; // turn on, something to transmit sensor_value = temperature_sensor.read_u16(); voltage = (sensor_value / 65536.0 ) * 3.3; temperature = (voltage - .5) * 100; sprintf(float_converted, "%f", temperature); rn42.putc('*'); wait(0.1); rn42.putc(' '); wait(0.1); rn42.putc('2'); wait(0.1); rn42.putc(' '); wait(0.1); rn42.putc(float_converted[0]); wait(0.1); rn42.putc(float_converted[1]); wait(0.1); rn42.putc(float_converted[2]); wait(0.1); rn42.putc(float_converted[3]); wait(0.1); rn42.putc(float_converted[4]); wait(0.1); rn42.putc(' '); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc(' '); wait(0.1); rn42.putc('*'); myled = 0; }
/* *收到SIGCHLD信号之后的回调函数 */ static void wait_child(int sig_type) { int status; pid_t pid = wait(&status); del_from_PL(pid); }
int main() { /* Make sure there is process-shared capability. */ #ifndef PTHREAD_PROCESS_SHARED fprintf(stderr,"process-shared attribute is not available for testing\n"); return PTS_UNSUPPORTED; #endif static pthread_barrier_t* barrier; pthread_barrierattr_t ba; int pshared = PTHREAD_PROCESS_SHARED; char shm_name[] = "tmp_pthread_barrierattr_getpshared"; int shm_fd; int pid; int loop; int serial = 0; int rc; int status = 0; struct sigaction act; /* Set up parent to handle SIGALRM */ act.sa_flags = 0; act.sa_handler = sig_handler; sigfillset(&act.sa_mask); sigaction(SIGALRM, &act, 0); /* Initialize a barrier attributes object */ if(pthread_barrierattr_init(&ba) != 0) { printf("Error at pthread_barrierattr_init()\n"); return PTS_UNRESOLVED; } /* Set the pshard value to private to shared */ if(pthread_barrierattr_setpshared(&ba, pshared) != 0) { printf("Error at pthread_barrierattr_setpshared()\n"); return PTS_UNRESOLVED; } if(pthread_barrierattr_getpshared(&ba, &pshared) != 0) { printf("Test FAILED: Error at pthread_barrierattr_getpshared()\n"); return PTS_FAIL; } if(pshared != PTHREAD_PROCESS_SHARED) { printf("Test FAILED: Incorrect pshared value %d\n", pshared); return PTS_FAIL; } /* Create shared object */ shm_unlink(shm_name); shm_fd = shm_open(shm_name, O_RDWR|O_CREAT|O_EXCL, S_IRUSR|S_IWUSR); if(shm_fd == -1) { perror("Error at shm_open()"); return PTS_UNRESOLVED; } if(ftruncate(shm_fd, sizeof(pthread_barrier_t)) != 0) { perror("Error at ftruncate()"); shm_unlink(shm_name); return PTS_UNRESOLVED; } /* Map the shared memory object to my memory */ barrier = mmap(NULL, sizeof(pthread_barrier_t), PROT_READ|PROT_WRITE, MAP_SHARED, shm_fd, 0); if(barrier == MAP_FAILED) { perror("Error at first mmap()"); shm_unlink(shm_name); return PTS_UNRESOLVED; } /* Initialize a barrier */ if((pthread_barrier_init(barrier, &ba, 2)) != 0) { printf("Error at pthread_barrier_init()\n"); return PTS_UNRESOLVED; } /* Cleanup */ if((pthread_barrierattr_destroy(&ba)) != 0) { printf("Error at pthread_barrierattr_destroy()\n"); return PTS_UNRESOLVED; } /* Fork a child process */ pid = fork(); if(pid == -1) { perror("Error at fork()"); return PTS_UNRESOLVED; } else if(pid == 0) { /* Child */ /* Map the shared object to child's memory */ barrier = mmap(NULL, sizeof(pthread_barrier_t), PROT_READ|PROT_WRITE, MAP_SHARED, shm_fd, 0); if(barrier == MAP_FAILED) { perror("child: Error at first mmap()"); return PTS_UNRESOLVED; } } else { printf("parent pid : %d, child pid : %d\n", getpid(), pid); printf("parent: send me SIGALRM 2 secs later in case I am blocked\n"); alarm(2); } for(loop = 0; loop < LOOP_NUM; loop++) { rc = pthread_barrier_wait(barrier); if(rc != 0 && rc != PTHREAD_BARRIER_SERIAL_THREAD) { printf("Test FAILED: %d: pthread_barrier_wait() got unexpected " "return code : %d\n" , getpid(), rc); exit(PTS_FAIL); } else if(rc == PTHREAD_BARRIER_SERIAL_THREAD) { serial++; printf("process %d: get PTHREAD_BARRIER_SERIAL_THREAD\n" , getpid()); } } if(pid > 0) { /* parent */ if( wait(&status) != pid) { printf("parent: error at waitpid()\n"); return PTS_UNRESOLVED; } if(!WIFEXITED(status)) { printf("Child exited abnormally\n"); return PTS_UNRESOLVED; } if((WEXITSTATUS(status) + serial) != LOOP_NUM) { printf("status = %d\n", status); printf("serial = %d\n", serial); printf("Test FAILED: One of the two processes should get " "PTHREAD_BARRIER_SERIAL_THREAD\n"); return PTS_FAIL; } /* Cleanup */ if(pthread_barrier_destroy(barrier) != 0) { printf("Error at pthread_barrier_destroy()"); return PTS_UNRESOLVED; } if((shm_unlink(shm_name)) != 0) { perror("Error at shm_unlink()"); return PTS_UNRESOLVED; } printf("Test PASSED\n"); return PTS_PASS; } if(pid == 0) { exit(serial); } return PTS_UNRESOLVED; }
int wait_and_end(int i) { wait( i + 1, SC_NS); cout << "Thread " << i << " ending." << endl; return 0; }
void wait(F&& ...f) { using swallow = int[]; (void)swallow{(wait(std::forward<F>(f)), 0)...}; }
/*---------------------------------------------------------------------+ | main | | ==================================================================== | | | | Function: ... | | | +---------------------------------------------------------------------*/ int main(int argc, char **argv) { char *filename = NULL; FILE *statfile; pid_t pid = 0; int fd; int rc; clock_t start_time; /* start & stop times */ clock_t stop_time; float elapsed_time; #ifdef __linux__ time_t timer_info; #else struct tms timer_info; /* time accounting info */ #endif if ((filename = getenv("KERNEL")) == NULL) { errno = ENODATA; sys_error("environment variable KERNEL not set", __FILE__, __LINE__); } /* Process command line arguments... */ parse_args(argc, argv); if (verbose) printf("%s: Scheduler TestSuite program\n\n", *argv); if (debug) { printf("\tpriority type: %s\n", priority_type); printf("\tpriority: %d\n", priority); printf("\tlogfile: %s\n", logfile); } /* Adjust the priority of this process if the real time flag is set */ if (!strcmp(priority_type, "fixed")) { #ifndef __linux__ if (setpri(0, DEFAULT_PRIORITY) < 0) sys_error("setpri failed", __FILE__, __LINE__); #else if (setpriority(PRIO_PROCESS, 0, 0) < 0) sys_error("setpri failed", __FILE__, __LINE__); #endif } else { if (nice((priority - 50) - (nice(0) + 20)) < 0 && errno != 0) sys_error("nice failed", __FILE__, __LINE__); } /* Read from raw I/O device and record elapsed time... */ start_time = time(&timer_info); /* Open and lock file file... */ fd = open_file(filename, O_RDWR); if (!lock_file(fd, F_WRLCK, filename)) /* set exclusive lock */ error("lock_file failed", __FILE__, __LINE__); /* If fork flag set, fork a real process */ if (fork_flag) pid = fork_realtime(argv); /* Read file */ if (debug) { printf("\tprocess id %d successfully locked %s\n", getpid(), filename); printf("\tprocess id %d starting to read %s\n", getpid(), filename); } if (!read_file(fd, filename)) error("read_file failed", __FILE__, __LINE__); /* Stop the timer and calculate the elapsed time */ stop_time = time(&timer_info); elapsed_time = (float)(stop_time - start_time) / 100.0; /* Write the elapsed time to the temporary file... */ if ((statfile = fopen(logfile, "w")) == NULL) sys_error("fopen failed", __FILE__, __LINE__); fprintf(statfile, "%f\n", elapsed_time); if (debug) printf("\n\telapsed time: %f\n", elapsed_time); if (fclose(statfile) < 0) sys_error("fclose failed", __FILE__, __LINE__); /* Unlock file at latest possible time to prevent real time child from * writing throughput results before user process parent */ unlock_file(fd, filename); close(fd); if (debug) printf("\tprocess id %d completed read and unlocked file\n", getpid()); /* The parent waits for child process to complete before exiting * so the driver will not read the throughput results file before * child writes to the file */ if (pid != 0) { /* if parent process ... *//* wait for child process */ if (debug) printf ("parent waiting on child process %d to complete\n", pid); while ((rc = wait(NULL)) != pid) if (rc == -1) sys_error("wait failed", __FILE__, __LINE__); /* DARA: which one to use 1st -- hangs 2nd -- ERROR message while (wait((void *) 0) != pid) ; while ((rc=wait ((void *) 0)) != pid) if (rc == -1) sys_error ("wait failed", __FILE__, __LINE__); */ } /* Exit with success! */ if (verbose) printf("\nsuccessful!\n"); return (0); }
static void vfstest_s5fs_vm(void) { int fd, newfd, ret; char buf[2048]; struct stat oldstatbuf, newstatbuf; void *addr; syscall_success(mkdir("s5fs", 0)); syscall_success(chdir("s5fs")); /* Open some stuff */ syscall_success(fd = open("oldchld", O_RDWR | O_CREAT, 0)); syscall_success(mkdir("parent", 0)); /* link/unlink tests */ syscall_success(link("oldchld", "newchld")); /* Make sure stats match */ syscall_success(stat("oldchld", &oldstatbuf)); syscall_success(stat("newchld", &newstatbuf)); test_assert(0 == memcmp(&oldstatbuf, &newstatbuf, sizeof(struct stat)), NULL); /* Make sure contents match */ syscall_success(newfd = open("newchld", O_RDWR, 0)); syscall_success(ret = write(fd, TESTSTR, strlen(TESTSTR))); test_assert(ret == (int)strlen(TESTSTR), NULL); syscall_success(ret = read(newfd, buf, strlen(TESTSTR))); test_assert(ret == (int)strlen(TESTSTR), NULL); test_assert(0 == strncmp(buf, TESTSTR, strlen(TESTSTR)), "string is %.*s, expected %s", strlen(TESTSTR), buf, TESTSTR); syscall_success(close(fd)); syscall_success(close(newfd)); /* Remove one, make sure the other remains */ syscall_success(unlink("oldchld")); syscall_fail(mkdir("newchld", 0), EEXIST); syscall_success(link("newchld", "oldchld")); /* Link/unlink error cases */ syscall_fail(link("oldchld", "newchld"), EEXIST); syscall_fail(link("oldchld", LONGNAME), ENAMETOOLONG); syscall_fail(link("parent", "newchld"), EISDIR); /* only rename test */ /*syscall_success(rename("oldchld", "newchld"));*/ /* mmap/munmap tests */ syscall_success(fd = open("newchld", O_RDWR, 0)); test_assert(MAP_FAILED != (addr = mmap(0, strlen(TESTSTR), PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0)), NULL); /* Check contents of memory */ test_assert(0 == memcmp(addr, TESTSTR, strlen(TESTSTR)), NULL); /* Write to it -> we shouldn't pagefault */ memcpy(addr, SHORTSTR, strlen(SHORTSTR)); test_assert(0 == memcmp(addr, SHORTSTR, strlen(SHORTSTR)), NULL); /* mmap the same thing on top of it, but shared */ test_assert(MAP_FAILED != mmap(addr, strlen(TESTSTR), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, fd, 0), NULL); /* Make sure the old contents were restored (the mapping was private) */ test_assert(0 == memcmp(addr, TESTSTR, strlen(TESTSTR)), NULL); /* Now change the contents */ memcpy(addr, SHORTSTR, strlen(SHORTSTR)); /* mmap it on, private, on top again */ test_assert(MAP_FAILED != mmap(addr, strlen(TESTSTR), PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_FIXED, fd, 0), NULL); /* Make sure it changed */ test_assert(0 == memcmp(addr, SHORTSTR, strlen(SHORTSTR)), NULL); /* Fork and try changing things */ if (!fork()) { /* Child changes private mapping */ memcpy(addr, TESTSTR, strlen(TESTSTR)); exit(0); } /* Wait until child is done */ syscall_success(wait(0)); /* Make sure it's actually private */ test_assert(0 == memcmp(addr, SHORTSTR, strlen(SHORTSTR)), NULL); /* Unmap it */ syscall_success(munmap(addr, 2048)); /* mmap errors */ test_assert(MAP_FAILED == mmap(0, 1024, PROT_READ, MAP_PRIVATE, 12, 0), NULL); test_assert(MAP_FAILED == mmap(0, 1024, PROT_READ, MAP_PRIVATE, -1, 0), NULL); test_assert(MAP_FAILED == mmap(0, 1024, PROT_READ, 0, fd, 0), NULL); test_assert(MAP_FAILED == mmap(0, 1024, PROT_READ, MAP_FIXED, fd, 0), NULL); test_assert(MAP_FAILED == mmap(0, 1024, PROT_READ, MAP_FIXED | MAP_PRIVATE, fd, 0), NULL); test_assert(MAP_FAILED == mmap(0, 1024, PROT_READ, MAP_PRIVATE, fd, 0x12345), NULL); test_assert(MAP_FAILED == mmap((void *) 0x12345, 1024, PROT_READ, MAP_PRIVATE | MAP_FIXED, fd, 0), NULL); test_assert(MAP_FAILED == mmap(0, 0, PROT_READ, MAP_PRIVATE, fd, 0), NULL); test_assert(MAP_FAILED == mmap(0, -1, PROT_READ, MAP_PRIVATE, fd, 0), NULL); test_assert(MAP_FAILED == mmap(0, 1024, PROT_READ, MAP_PRIVATE | MAP_FIXED, fd, 0), NULL); syscall_success(close(fd)); syscall_success(fd = open("newchld", O_RDONLY, 0)); test_assert(MAP_FAILED == mmap(0, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0), NULL); syscall_success(close(fd)); /* TODO ENODEV (mmap a terminal) EOVERFLOW (mmap SO MUCH of /dev/zero that fpointer would overflow) */ /* Also should test opening too many file descriptors somewhere */ /* munmap errors */ syscall_fail(munmap((void *) 0x12345, 15), EINVAL); syscall_fail(munmap(0x0, 15), EINVAL); syscall_fail(munmap(addr, 0), EINVAL); syscall_fail(munmap(addr, -1), EINVAL); /* brk tests */ /* Set the break, and use the memory in question */ test_assert((void *) - 1 != (addr = sbrk(128)), NULL); memcpy(addr, TESTSTR, 128); test_assert(0 == memcmp(addr, TESTSTR, 128), NULL); /* Make sure that the brk is being saved properly */ test_assert((void *)((unsigned long) addr + 128) == sbrk(0), NULL); /* Knock the break back down */ syscall_success(brk(addr)); /* brk errors */ syscall_fail(brk((void *)(&"brk")), ENOMEM); syscall_fail(brk((void *) 1), ENOMEM); syscall_fail(brk((void *) &addr), ENOMEM); syscall_success(chdir("..")); }
void application::wait_until_quit() { try { auto wait_ptr_copy = my->_quit_promise; wait_ptr_copy->wait(); } FC_RETHROW_EXCEPTIONS( warn, "" ) }
int main(int argc, char* argv[]) { struct sockaddr_in client; //Validate input if (argc != 2) { cout << "Usage: panserver <portnumber>" << endl; return -1; } // initialize shared memory initSharedMem(); // Initialize the ports panel.server.sin_port = htons(atoi(argv[1])); audience.server.sin_port = htons(atoi(argv[1])+1); /** Create socket on which to send and receive */ if ( panel.CreatSocket() < 0 ) // create panel socket return -1; if ( audience.CreatSocket() < 0 ) // create panel socket return -1; reusePort(panel.socket_s); //reuse the binding port when execute program if ( panel.BindConnection() < 0 ) // Check for binding errors return -1; reusePort(audience.socket_s);//reuse the binding port when execute program if ( audience.BindConnection() < 0 ) // Check for binding errors return -1; /** get panel port information and prints it out */ if ( panel.GetSocketName() ) // check socket name validity return -1; /** get audience port information and prints it out */ if ( audience.GetSocketName() ) // check socket name validity return -1; /** accept TCP connections from clients and fork a process to serve each */ listen(panel.socket_s,10); listen(audience.socket_s,10); signal(SIGPIPE, PIPEhandler); for(;;){ audience_pid = fork(); signal (SIGINT, SIG_IGN); signal (SIGTSTP,SIG_IGN); /* This is the audience server */ if ( audience_pid == 0) { cout << "Forked AUDIENCE Server, PID=" << getpid() << endl; ServPanelist(panel, client); } else { panel_pid = fork (); signal (SIGINT, SIG_IGN); signal (SIGTSTP,SIG_IGN); //signal(SIGPIPE, PIPEhandler); if ( panel_pid == 0) { cout << "Forked PANEL Server, PID=" << getpid() << endl; ServAudience(audience, client); } else { //list people in the room cout << "AUDIENCE server started at port: (" << ntohs(audience.server.sin_port) << ")" << endl; cout << "PANELIST server started at port: (" << ntohs(panel.server.sin_port) << ")" << endl; } wait(NULL); } sleep(2); wait(NULL); } }
void ServAudience ( Connection audience, struct sockaddr_in client) { int psd, childpid, index=0; socklen_t t = sizeof(audience.server); int *status; for(;;){ psd = accept(audience.socket_s, (struct sockaddr *) &client, &t); EchoServe(psd, client, GETUSERNAME); childpid = fork(); if ( childpid == 0) { signal (SIGTSTP,SIG_IGN); if (signal(SIGUSR1, displayHandle) == SIG_ERR) { fprintf(stderr, "cannot set handler for SIGUSR1\n"); } // getting interrupt to send an audience message if (signal(SIGUSR2, SendMessage) == SIG_ERR) { fprintf(stderr, "cannot set handler for SIGUSR2\n"); } close (audience.socket_s); EchoServe(psd, client, SERVAUDIENCE); } else{ signal (SIGTSTP,SIG_IGN); cout << "\nNew audience Client: (" << inet_ntoa(client.sin_addr) << ":" << ntohs(client.sin_port) << ") [" << client_msg << "]" << endl; cout << "Forked audience Handler, PID = " << childpid << endl; *sharedInt_index = *sharedInt_index + 1 ; index = *sharedInt_index; //cout << "new parti " << index <<endl; list_participants[index].client_type = PARTICIPANT_AUD; list_participants[index].pid = childpid; list_participants[index].port = client.sin_port; list_participants[index].address = client.sin_addr; list_participants[index].buf_stream = psd; strcpy(list_participants[index].user_name, client_msg); // current date/time based on current system list_participants[index].time_in = time (NULL); //if Q&A session opened send a message if (*QAsessionFlag == 1) { cout << "We are in Q&A session now!" << endl; sprintf(client_msg,"%s", "We are in Q&A session now!"); if ( send(list_participants[index].buf_stream, client_msg, strlen(client_msg), 0) < 0) perror("Error when sending message Q&A to client "); } } //Handle the child signal just end. Meaning of someone left the room. Pipe broken. int pid=wait(&status); //#define PARTICIPANT_AUD 1 //#define PARTICIPANT_PAN 2 //checkParticipant(index,PARTICIPANT_AUD); } }
void HariMain(void) { int win, timer, i, j, fx, laserwait, lx = 0, ly; int ix, iy, movewait0, movewait, idir; int invline, score, high, point; char winbuf[336 * 261 * osak_getbuflen()], invstr[32 * 6], s[12], keyflag[4], *p; static char invstr0[32] = " abcd abcd abcd abcd abcd "; win = api_openwin(winbuf, 336, 261, -1, "invader"); api_boxfilwin(win, 6, 27, 329, 254, 0); timer = api_alloctimer(); api_inittimer(timer, 128); high = 0; putstr(win, winbuf, 22, 0, 7, "HIGH:00000000"); restart: score = 0; point = 1; putstr(win, winbuf, 4, 0, 7, "SCORE:00000000"); movewait0 = 20; fx = 18; putstr(win, winbuf, fx, 13, 6, "efg"); wait(100, timer, keyflag); next_group: wait(100, timer, keyflag); ix = 7; iy = 1; invline = 6; for (i = 0; i < 6; i++) { for (j = 0; j < 27; j++) { invstr[i * 32 + j] = invstr0[j]; } putstr(win, winbuf, ix, iy + i, 2, invstr + i * 32); } keyflag[0] = 0; keyflag[1] = 0; keyflag[2] = 0; ly = 0; /* 非表示 */ laserwait = 0; movewait = movewait0; idir = +1; wait(100, timer, keyflag); for (;;) { if (laserwait != 0) { laserwait--; keyflag[2 /* space */] = 0; } wait(4, timer, keyflag); /* 自機の処理 */ if (keyflag[0 /* left */] != 0 && fx > 0) { fx--; putstr(win, winbuf, fx, 13, 6, "efg "); keyflag[0 /* left */] = 0; } if (keyflag[1 /* right */] != 0 && fx < 37) { putstr(win, winbuf, fx, 13, 6, " efg"); fx++; keyflag[1 /* right */] = 0; } if (keyflag[2 /* space */] != 0 && laserwait == 0) { laserwait = 15; lx = fx + 1; ly = 13; } /* インベーダ移動 */ if (movewait != 0) { movewait--; } else { movewait = movewait0; if (ix + idir > 14 || ix + idir < 0) { if (iy + invline == 13) { break; /* GAME OVER */ } idir = - idir; putstr(win, winbuf, ix + 1, iy, 0, " "); iy++; } else { ix += idir; } for (i = 0; i < invline; i++) { putstr(win, winbuf, ix, iy + i, 2, invstr + i * 32); } } /* レーザー処理 */ if (ly > 0) { if (ly < 13) { if (ix < lx && lx < ix + 25 && iy <= ly && ly < iy + invline) { putstr(win, winbuf, ix, ly, 2, invstr + (ly - iy) * 32); } else { putstr(win, winbuf, lx, ly, 0, " "); } } ly--; if (ly > 0) { putstr(win, winbuf, lx, ly, 3, "h"); } else { point -= 10; if (point <= 0) { point = 1; } } if (ix < lx && lx < ix + 25 && iy <= ly && ly < iy + invline) { p = invstr + (ly - iy) * 32 + (lx - ix); if (*p != ' ') { /* hit ! */ score += point; point++; // sprintf(s, "%08d", score); setdec8(s, score); putstr(win, winbuf, 10, 0, 7, s); if (high < score) { high = score; putstr(win, winbuf, 27, 0, 7, s); } for (p--; *p != ' '; p--) { } for (i = 1; i < 5; i++) { p[i] = ' '; } putstr(win, winbuf, ix, ly, 2, invstr + (ly - iy) * 32); for (; invline > 0; invline--) { for (p = invstr + (invline - 1) * 32; *p != 0; p++) { if (*p != ' ') { goto alive; } } } /* 全部やっつけられた */ movewait0 -= movewait0 / 3; goto next_group; alive: ly = 0; } } } } /* GAME OVER */ putstr(win, winbuf, 15, 6, 1, "GAME OVER"); wait(0, timer, keyflag); for (i = 1; i < 14; i++) { putstr(win, winbuf, 0, i, 0, " "); } goto restart; }
int main(int ac, char **av) { char iter[20]; int count, i, nchild, status; pid_t pid; int lc; char *msg; if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL) tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); setup(); if (ac != 5) usage(); for (lc = 0; TEST_LOOPING(lc); lc++) { Tst_count = 0; prog = av[0]; iterations = atoi(av[1]); fname1 = av[2]; fname2 = av[3]; count = atoi(av[4]); #ifdef DEBUG tst_resm(TINFO, "Entered %s %d %s %s %d -- pid = %d", prog, iterations, fname1, fname2, count, getpid()); #endif if (iterations == 0) { tst_resm(TPASS, "Test DONE, pid %d, -- %s %d %s %s", getpid(), prog, iterations, fname1, fname2); tst_exit(); } if (!count) { sprintf(iter, "%d", iterations - 1); av[0] = fname1; av[1] = iter; av[2] = fname1; av[3] = fname2; av[4] = "0"; av[5] = 0; ev[0] = 0; #ifdef DEBUG tst_resm(TINFO, "doing execve(%s, av, ev)", fname1); tst_resm(TINFO, "av[0,1,2,3,4] = %s, %s, %s, %s, %s", av[0], av[1], av[2], av[3], av[4]); #endif (void)execve(fname1, av, ev); tst_resm(TFAIL, "Execve fail, %s, errno=%d", fname1, errno); } nchild = count * 2; sprintf(iter, "%d", iterations); for (i = 0; i < count; i++) { pid = FORK_OR_VFORK(); if (pid == -1) { perror("fork failed"); exit(1); } else if (pid == 0) { av[0] = fname1; av[1] = iter; av[2] = fname1; av[3] = fname2; av[4] = "0"; av[5] = 0; ev[0] = 0; (void)execve(fname1, av, ev); perror("execve failed"); exit(2); } #ifdef DEBUG tst_resm(TINFO, "Main - started pid %d", pid); #endif if (wait(&status) == -1) tst_brkm(TBROK|TERRNO, cleanup, "wait failed"); if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) tst_resm(TFAIL, "child exited abnormally"); pid = FORK_OR_VFORK(); if (pid == -1) { perror("Fork failed"); exit(1); } else if (pid == 0) { av[0] = fname2; av[1] = iter; av[2] = fname2; av[3] = fname1; av[4] = "0"; av[5] = 0; ev[0] = 0; execve(fname2, av, ev); perror("execve failed"); exit(2); } #ifdef DEBUG tst_resm(TINFO, "Main - started pid %d", pid); #endif if (wait(&status) == -1) tst_brkm(TBROK|TERRNO, cleanup, "wait failed"); if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) tst_resm(TFAIL, "child exited abnormally"); } if (wait(&status) != -1) tst_brkm(TBROK, cleanup, "leftover children haven't exited yet"); } cleanup(); tst_exit(); }
int main(int argc, char **argv) { char buf[100]; int i, pid, p[2]; int fd; fd = open("/dev/tty",O_RDWR,0); if ((i = pipe(p,0)) < 0) panic("pipe: %e", i); if ((pid = fork()) < 0) panic("fork: %e", i); if (pid == 0) { printf("[%08x] pipereadeof close %d\n", getpid(), p[1]); close(p[1]); printf("[%08x] pipereadeof readn %d\n", getpid(), p[0]); i = readn(p[0], buf, sizeof buf-1); if (i < 0) panic("read: %e", i); buf[i] = 0; if (strcmp(buf, msg) == 0) printf("\npipe read closed properly\n"); else printf("\ngot %d bytes: %s\n", i, buf); exit(); } else { printf("[%08x] pipereadeof close %d\n", getpid(), p[0]); close(p[0]); printf("[%08x] pipereadeof write %d\n", getpid(), p[1]); if ((i = write(p[1], msg, strlen(msg))) != strlen(msg)) panic("write: %e", i); close(p[1]); } wait(pid); if ((i = pipe(p,0)) < 0) panic("pipe: %e", i); if ((pid = fork()) < 0) panic("fork: %e", i); if (pid == 0) { close(p[0]);int r = 0; while (1) { if ((write(p[1], "x", 1)) != 1) { break; } } printf("\npipe write closed properly\n"); exit(); } close(p[0]); close(p[1]); wait(pid); printf("pipe tests passed\n"); return 0; }
rpc_result_object rpc_mclient::call(const std::string& m, const A0& a0) { call_(m, msgpack::type::tuple<const A0&>(a0)); return wait(m); }
void shmem_int4_wait_f(ompi_fortran_integer4_t *var, ompi_fortran_integer4_t *value) { MCA_SPML_CALL(wait((void*)var, SHMEM_CMP_NE, (void*)value, SHMEM_FINT4)); }
void RGBDGrabber :: stop() { setShouldExit(); newEvent(); wait(); }
int main(int argc, char **argv, char *envp[]) { FILE *fp; int i=0; int p1, p2; int status; pid_t pid; char *envstring, **eval; /*strncpy(this_file, __FILE__, (strlen(__FILE__) - 2)); this_file[(strlen(__FILE__) - 2)] = '\0'; strcat(this_file, ".cgi"); */ strcpy(this_file, "trial_chisq.cgi"); if (USE_CGI) { xcgi_init(argc, argv); xcgi_header("html"); } p1 = atoi(xcgi_param_value_named("p1")); p2 = atoi(xcgi_param_value_named("p2")); printf( "<html>\n<head>\n<title>trial chisq</title>\n" "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=iso-8859-1\">" "<meta http-equiv=\"expires\" content=\"now\">\n" "<meta http-equiv=\"pragma\" content=\"no-cache\">\n" "<style type=\"text/css\">\n" "<!--\n" " body, h1, h2, h3, h4, h5, h6 { font-family: Verdana, sans-serif;}\n" " body { font-size: 80%%; }\n" " tr.colheader { font-weight: bold; width: 0%% }\n" " td { font-size: 80%%; vertical-align: top}\n" // " div.small { font-size: 80%%; }\n" " .nowrap {white-space: nowrap}\n" "-->\n" "</style>\n" "</head>\n"); printf("<body bgcolor=\"#fffff0\">\n"); printf("<h3>GIFPLOT!</h3>"); printf( "<form name=\"plotform\" method=\"post\" action=\"%s\">\n", this_file); printf( "<table>\n" "<tr><td>p1</td><td width=\"100%\"><input name=\"p1\" type=\"text\" size=\"4\" maxlength=\"4\"></td></tr>\n" "<tr><td>p2</td><td width=\"100%\"><input name=\"p2\" type=\"text\" size=\"4\" maxlength=\"4\"></td></tr>\n" "<tr><td> </td><td><input type=\"submit\" name=\"submit\" value=\"Go\"></td></tr>\n" "</table></form>\n"); printf("<hr>\n"); printf("blah blah p1 = %d, p2 = %d", p1, p2); putenv("LD_LIBRARY_PATH=/usr/local/pgplot"); while (NULL != fopen(LOCK_FILE, "r")) { fprintf(stderr, "lock file exists. waiting 1 sec\n"); sleep(1); if (i++ == 5) { printf("<p>ERROR - contact core programmers</p></body></html>"); exit(-1); } } unlink(GIF_FILE); // ??? // what if prog bombs out before removing lock? // need to check date of lock file, if older than certain period (a longer period than // the program should take to execute, remove it fp = fopen(LOCK_FILE, "w"); if (NULL == fp) fprintf(stderr, "error - couldn't open lock file: %s", sys_errlist[errno]); fclose(fp); //sleep(4); if (fork() == 0) execlp("/user/cp/cjb/jim/gifplot/trial_chisq_exec_f_out", "trial_chisq", (char *)0); wait(&status); //plot_(); unlink(LOCK_FILE); if (NULL == fopen(LOCK_FILE, "r")) { fprintf(stderr, "error2 - "); fprintf(stderr, sys_errlist[errno]); fprintf(stderr, "<p>lock file removed.</p>"); } printf("<img src=\"p.gif\" alt=\"Image.\"></img>\n"); printf("<hr>\n"); printf("</body></html>"); if (USE_CGI) xcgi_exit(); return(0); }
void scheduler_FIFO(){ int i,j,k,timeout,pid,status; int * processes_running; PROG_T prog; char cmd[50]; i = 0; p_sem(); for(i=0;i<NUM_TAB;i++){ if((pshm[i].nreq < 0)&&(pshm[i].status == FINISHED)){ pshm[i].nreq = 0; p_sem2(); /*printf("Liberando antes: %d\n",proc_livres);*/ proc_livres += pshm[i].num_proc; /*printf("Liberando depois: %d\n",proc_livres);*/ v_sem2(); }else if((pshm[i].nreq > 0)&&(pshm[i].status == RUNNING)){ timeout = checkTime(i); if(timeout){ sprintf(cmd,"pkill -P %d",pshm[i].pid); system(cmd); kill(pshm[i].pid,SIGKILL); pshm[i].nreq = 0; pshm[i].status = FINISHED; p_sem2(); proc_livres += pshm[i].num_proc; v_sem2(); } } } v_sem(); p_sem(); i = chooseReq(); if((pshm[i].nreq > 0)&&(pshm[i].status == PENDING)&&(pshm[i].num_proc <= proc_livres)){ p_sem2(); /*printf("Alocando antes: %d\n",proc_livres);*/ proc_livres -= pshm[i].num_proc; /*printf("Alocando depois: %d\n",proc_livres);*/ v_sem2(); prog.n_params = countParams(pshm[i].proc); getArgs(pshm[i],&prog); pshm[i].status = RUNNING; pid = fork(); if(pid<0){ printf("Erro no fork dispatcher\n"); exit(-1); }else if(!pid){ /*Processo dispatcher*/ processes_running = (int*)calloc(pshm[i].num_proc,sizeof(int)); for(j=0;j<pshm[i].num_proc;j++){ processes_running[j] = fork(); if(processes_running[j] < 0){ printf("Erro no fork worker\n"); exit(-1); }else if(processes_running[j] == 0){ /*Processos worker*/ execv(prog.nome,prog.params); }else{ /*Processo dispatcher*/ for(k=0;k<pshm[i].num_proc;k++){ wait(&status); if((k == pshm[i].num_proc-1)&&(j==pshm[i].num_proc-1)){ pshm[i].status = FINISHED; pshm[i].nreq = -1; exit(0); } } } } }else{ pshm[i].pid = pid; } } v_sem(); for(i=0;i<NUM_TAB;i++){ if(pshm[i].status == FINISHED){ waitpid(pshm[i].pid,&status,WNOHANG); } } }
void send_reply() { char sample[10]; myled = 1; if (flags.flag_operation_code == 0b01) { // the reply contains just the current state rn42.putc('*'); wait(0.1); rn42.putc(' '); wait(0.1); rn42.putc('2'); wait(0.1); rn42.putc(' '); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc(' '); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc(' '); wait(0.1); rn42.putc('*'); } else if (flags.flag_operation_code == 0b10) { // the reply contains state and battery level sprintf(sample, "%f", 34.45); //conversion battery level wait(0.1); rn42.putc('*'); wait(0.1); rn42.putc(' '); wait(0.1); rn42.putc('2'); wait(0.1); rn42.putc(' '); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc('#'); wait(0.1); rn42.putc(' '); wait(0.1); rn42.putc(sample[0]); wait(0.1); rn42.putc(sample[1]); wait(0.1); rn42.putc(sample[2]); wait(0.1); rn42.putc(sample[3]); wait(0.1); rn42.putc(sample[4]); wait(0.1); rn42.putc(' '); wait(0.1); rn42.putc('*'); } myled = 0; }
int sys_wait(void) { return wait(); }
int main(int argc, char **argv) { int i = 0; pid_t pid; pid_t *childpids = NULL; sigset_t sigset; int status = 0; int ret = 0; checkopt(argc,argv); if (initialize()) { warn("initialize failed"); report_result("2\n"); exit(EXIT_FAILURE); } if (sigemptyset(&sigset) < 0) { warn("sigemptyset failed"); report_result("2\n"); exit(EXIT_FAILURE); } childpids = (pid_t *)malloc((nprocs) * sizeof(pid_t)); if (childpids == NULL) { warn("alloc for child pids failed"); report_result("2\n"); exit(EXIT_FAILURE); } memset(childpids, 0, (nprocs) * sizeof(pid_t)); report_result("0\n"); sigsuspend(&sigset); for (; i < nprocs; i++) { pid = fork(); if (pid == -1) { while (--i >= 0) kill(childpids[i], SIGKILL); warn("fork test tasks failed"); report_result("2\n"); exit(EXIT_FAILURE); } else if (!pid) { ret = cpu_hog(); exit(ret); } childpids[i] = pid; } report_result("0\n"); while (!end) { if (sigemptyset(&sigset) < 0) ret = -1; else sigsuspend(&sigset); if (ret || end) { for(i = 0; i < nprocs; i++) { kill(childpids[i], SIGUSR2); } break; } else { for(i = 0; i < nprocs; i++) { kill(childpids[i], SIGUSR1); } } } for (i = 0; i < nprocs; i++) { wait(&status); if (status) ret = EXIT_FAILURE; } return ret; }
int main(int argc, char *argv[]) { char logfile[BUFFSIZE], filesdir[BUFFSIZE], collectcmd[BUFFSIZE], lscmd[BUFFSIZE], datfile[BUFFSIZE], imgfile[BUFFSIZE]; FILE *master, *page; FILE *sysout; char pageline[BUFFSIZE], buff[BUFFSIZE], scmd[BUFFSIZE], pagefile[BUFFSIZE]; char pageurl[BUFFSIZE], fullurl[BUFFSIZE], *url; char urldone; pid_t wgetchild; time_t waitstart; char *data; unsigned masterlength, masterloc; unsigned pageadds; long tester; int p; int firstentry; if (argc != 3 && argc != 4) { printf("Usage: web-collage <file> <program>\n"); exit(-2); } /* Fill out the commands with name */ sprintf(logfile, LOG_FILE, argv[1]); sprintf(filesdir, FILES_DIR, argv[1]); sprintf(collectcmd, COLLECT_CMD, argv[1], argv[1]); sprintf(lscmd, LS_CMD, argv[1]); sprintf(datfile, DAT_FILE, argv[1]); sprintf(imgfile, IMG_FILE, argv[1]); /* does the temp directory already exist? */ mkdir(filesdir, S_IRWXU); /* Open File */ if (!(master = fopen(datfile, "r"))) { printf("Creating File...\n"); master = fopen(datfile, "w+"); if (!master) { perror("creating master file"); exit(-1); } fprintf(master, "%s\n", argv[3]); /* First URL */ fclose(master); } else fclose(master); printf("Reading File...\n"); srand48(time(NULL)); master = waitreadmaster(datfile, 0, 0, 0); /* READ Lock! */ fseek(master, 0, SEEK_END); masterlength = ftell(master); freemaster(datfile, master, 0, 0); /* Unlock! */ int iter = 0; while (iter++ < 3) { /* Get random URL */ masterloc = lrand48() % masterlength; firstentry = 0; /* READ Lock! */ master = waitreadmaster(datfile, masterloc, masterloc, BUFFSIZE); fgets(pageurl, BUFFSIZE, master); /* skip to line after random char */ do if (!fgets(pageurl, BUFFSIZE - strlen(collectcmd) - 1, master)) { rewind(master); firstentry = 1; fgets(pageurl, BUFFSIZE - strlen(collectcmd) - 1, master); } while (pageurl[0] == '\t' || pageurl[0] == '\n'); if (!firstentry) { /* Invalidate URL */ /* READ->WRITE Lock! */ master = waitreadtowrite(datfile, master, masterloc, BUFFSIZE); fseek(master, -(strlen(pageurl) + 0), SEEK_CUR); voidline(master); } freemaster(datfile, master, masterloc, BUFFSIZE); /* Unlock! */ pageurl[strlen(pageurl) - 1] = '\0'; printf("\nGetting %s\n", pageurl); /* Get webpage, checking for any redirection */ sprintf(scmd, "%s \"%s\"", collectcmd, pageurl); waitstart = time(NULL); if (!(wgetchild = fork())) { system(scmd); exit(0); } while (validpid(wgetchild) && waitstart + 5 > time(NULL)); if (validpid(wgetchild)) kill(wgetchild, 9); wait(NULL); sysout = fopen(logfile, "r"); if (!sysout) continue; /* File does not exist */ while (fgets(buff, BUFFSIZE, sysout)) { printf("%s", buff); if (!strncmp(buff, "Location:", 9)) { if (strchr(buff + 10, ' ')) *strchr(buff + 10, ' ') = '\0'; strcpy(pageurl, buff + 10); } } fclose(sysout); unlink(logfile); /* Collect new links */ sysout = popen(lscmd, "r"); if (!sysout) { perror("searching files directory"); exit(-3); } strcpy(pagefile, filesdir); if (fgets(pagefile + strlen(pagefile), BUFFSIZE, sysout) != NULL) { pagefile[strlen(pagefile) - 1] = '\0'; /* remove newline */ page = fopen(pagefile, "r"); addfilename(pageurl, BUFFSIZE, pagefile); pageadds = 0; /* Write Additional URLs */ rewind(master); if (findlikes(page) || (rand() % KEEP_PROB)) { /* possibly just throw away */ while (nexttag(pageline, BUFFSIZE, page)) if (url = geturl(pageline)) { if (strncasecmp(url, "http://", 7)) { if (!getpath(fullurl, BUFFSIZE, url, pageurl)) continue; } else strcpy(fullurl, url); /* search for place in file to place */ urldone = 0; if (strlen(fullurl) > BUFFSIZE / 2) continue; /* too big, don't add */ if (rand() % (pageadds + 1) > KEEP_PROB) continue; /* add fewer urls as more on page */ if (strstr(fullurl, ".com") && rand() % DROP_PROB) continue; /* only chance to add a .com link */ if ((strstr(fullurl, "yahoo.com") || strstr(fullurl, "www.google.com")) && rand() % DROP_PROB) continue; /* almost no yahoo.com's, www.google.com's */ for (p = 0; p < DISLIKE_CNT; p++) if (strstr(fullurl, dislikes[p])) /* just skip */ continue; /* READ Lock! */ master = waitreadmaster(datfile, 0, 0, 0); while (fgets(buff, BUFFSIZE, master)) { if (!strncmp(buff, fullurl, strlen(fullurl)) || (!strncmp(buff, fullurl, strchr(buff + strlen("http://"), '/') - buff) && !(rand() % HOST_CROWD))) { urldone = 1; freemaster(datfile, master, 0, 0); /* Unlock! */ break; } if (buff[0] == '\t' || buff[0] == '\n') if (strlen(buff) >= strlen(fullurl) + 1) { masterloc = ftell(master); freemaster(datfile, master, 0, 0); /* Unlock! */ printf("Adding %s\n", fullurl); pageadds++; /* WRITE Lock! */ waitwritemaster(datfile, masterloc - strlen(buff), masterloc - strlen(buff), BUFFSIZE); fprintf(master, "%s\n", fullurl); if (strlen(buff) >= strlen(fullurl) + 2) fputc('\t', master); fseek(master, 0, SEEK_END); masterlength = ftell(master); freemaster(datfile, master, masterloc - strlen(buff), BUFFSIZE); /* Unlock! */ urldone = 1; break; } } if (!urldone) { if (ftell(master) > MAX_SIZE) { /* too big, just remove entries */ fseek(master, lrand48() % ftell(master), SEEK_SET); fgets(buff, BUFFSIZE, master); urldone = 1; /* flag that was greater than MAX_SIZE */ } masterloc = ftell(master); freemaster(datfile, master, 0, 0); /* Unlock! */ printf("Adding %s\n", fullurl); pageadds++; /* WRITE Lock! */ waitwritemaster(datfile, masterloc, masterloc - 2, BUFFSIZE); fprintf(master, "%s\n", fullurl); if (urldone) voidline(master); fseek(master, 0, SEEK_END); masterlength = ftell(master); freemaster(datfile, master, masterloc - 2, BUFFSIZE); /* Unlock! */ } } } fclose(page); /* Move file to final destination */ sprintf(scmd, "%s \"%s\" \"%s\"", argv[2], argv[1], pagefile); system(scmd); sleep(WAIT_TIME); sprintf(scmd, "touch %sREMOVE.tmp", filesdir); system(scmd); sprintf(scmd, "rm %s*", filesdir); system(scmd); } pclose(sysout); } }
void run() { // Continue execution of the stopped child process. std::cerr << "Resuming execution" << std::endl; CHECK(ptrace(PT_CONTINUE, pid, (caddr_t)1, 0)); wait(NULL); }
int MapUpdater::deactivate() { wait(); return m_executor.deactivate(); }
static int check_pids(struct tag_pgrp *running, int *num_active, int keep_active, FILE * logfile, FILE * failcmdfile, struct orphan_pgrp *orphans, int fmt_print, int *failcnt, int quiet_mode) { int w; pid_t cpid; int stat_loc; int ret = 0; int i; time_t t; char *status; int signaled = 0; struct tms tms1, tms2; clock_t tck; check_orphans(orphans, 0); tck = times(&tms1); if (tck == -1) { fprintf(stderr, "pan(%s): times(&tms1) failed. errno:%d %s\n", panname, errno, strerror(errno)); } cpid = wait(&stat_loc); tck = times(&tms2); if (tck == -1) { fprintf(stderr, "pan(%s): times(&tms2) failed. errno:%d %s\n", panname, errno, strerror(errno)); } if (cpid < 0) { if (errno == EINTR) { if (Debug) fprintf(stderr, "pan(%s): wait() interrupted\n", panname); } else if (errno != ECHILD) { fprintf(stderr, "pan(%s): wait() failed. errno:%d %s\n", panname, errno, strerror(errno)); } } else if (cpid > 0) { if (WIFSIGNALED(stat_loc)) { w = WTERMSIG(stat_loc); status = "signaled"; if (Debug & Dexit) fprintf(stderr, "child %d terminated with signal %d\n", cpid, w); --*num_active; signaled = 1; } else if (WIFEXITED(stat_loc)) { w = WEXITSTATUS(stat_loc); status = "exited"; if (Debug & Dexit) fprintf(stderr, "child %d exited with status %d\n", cpid, w); --*num_active; if (w != 0) ret++; } else if (WIFSTOPPED(stat_loc)) { /* should never happen */ w = WSTOPSIG(stat_loc); status = "stopped"; ret++; } else { /* should never happen */ w = 0; status = "unknown"; ret++; } for (i = 0; i < keep_active; ++i) { if (running[i].pgrp == cpid) { if ((w == 130) && running[i].stopping && (strcmp(status, "exited") == 0)) { /* The child received sigint, but * did not trap for it? Compensate * for it here. */ w = 0; ret--; /* undo */ if (Debug & Drunning) fprintf(stderr, "pan(%s): tag=%s exited 130, known to be signaled; will give it an exit 0.\n", panname, running[i].cmd->name); } time(&t); if (logfile != NULL) { if (!fmt_print) fprintf(logfile, "tag=%s stime=%d dur=%d exit=%s stat=%d core=%s cu=%d cs=%d\n", running[i].cmd->name, (int) (running[i].mystime), (int) (t - running[i].mystime), status, w, (stat_loc & 0200) ? "yes" : "no", (int) (tms2.tms_cutime - tms1.tms_cutime), (int) (tms2.tms_cstime - tms1.tms_cstime)); else { if (w != 0) ++*failcnt; fprintf(logfile, "%-30.30s %-10.10s %-5d\n", running[i].cmd->name, ((w != 0) ? "FAIL" : "PASS"), w); } fflush(logfile); } if ((failcmdfile != NULL) && (w !=0)) { fprintf(failcmdfile, "%s %s\n", running[i].cmd->name, running[i].cmd->cmdline); } if (running[i].stopping) status = "driver_interrupt"; if (test_out_dir) { if (!quiet_mode) write_test_start(running+i); copy_buffered_output(running + i); unlink(running[i].output); } if (!quiet_mode) write_test_end(running+i, "ok", t, status, stat_loc, w, &tms1, &tms2); /* If signaled and we weren't expecting * this to be stopped then the proc * had a problem. */ if (signaled && !running[i].stopping) ret++; running[i].pgrp = 0; if (zoo_clear(zoofile, cpid)) { fprintf(stderr, "pan(%s): %s\n", panname, zoo_error); exit(1); } /* Check for orphaned pgrps */ if ((kill(-cpid, 0) == 0) || (errno == EPERM)) { if (zoo_mark_cmdline(zoofile, cpid, "panorphan", running[i].cmd->cmdline)) { fprintf(stderr, "pan(%s): %s\n", panname, zoo_error); exit(1); } mark_orphan(orphans, cpid); /* status of kill doesn't matter */ kill(-cpid, SIGTERM); } break; } } } return ret; }
static void dumpBacktrace( unsigned int depth ) { if ( depth == 0 ) depth = 20; #if ((defined(linux) || defined(__linux__)) && !defined(ANDROID)) || defined(__FreeBSD__) // Below there is a bunch of operations that are not safe in multi-threaded // environment (dup()+close() combo, wait(), juggling with file descriptors). // Maybe some problems could be resolved with dup2() and waitpid(), but it seems // that if the operations on descriptors are not serialized, things will get nasty. // That's why there's this lovely mutex here... static QMutex mutex; QMutexLocker locker( &mutex ); int stderr_fd = -1; if ( access( "/usr/bin/c++filt", X_OK ) < 0 ) { myPrint( "Stacktrace (c++filt NOT FOUND):\n" ); } else { int fd[2]; if ( pipe( fd ) == 0 && fork() == 0 ) { close( STDIN_FILENO ); // close stdin // stdin from pipe if ( dup( fd[0] ) != STDIN_FILENO ) { QgsDebugMsg( "dup to stdin failed" ); } close( fd[1] ); // close writing end execl( "/usr/bin/c++filt", "c++filt", static_cast< char * >( nullptr ) ); perror( "could not start c++filt" ); exit( 1 ); } myPrint( "Stacktrace (piped through c++filt):\n" ); stderr_fd = dup( STDERR_FILENO ); close( fd[0] ); // close reading end close( STDERR_FILENO ); // close stderr // stderr to pipe int stderr_new = dup( fd[1] ); if ( stderr_new != STDERR_FILENO ) { if ( stderr_new >= 0 ) close( stderr_new ); QgsDebugMsg( "dup to stderr failed" ); } close( fd[1] ); // close duped pipe } void **buffer = new void *[ depth ]; int nptrs = backtrace( buffer, depth ); backtrace_symbols_fd( buffer, nptrs, STDERR_FILENO ); delete [] buffer; if ( stderr_fd >= 0 ) { int status; close( STDERR_FILENO ); int dup_stderr = dup( stderr_fd ); if ( dup_stderr != STDERR_FILENO ) { close( dup_stderr ); QgsDebugMsg( "dup to stderr failed" ); } close( stderr_fd ); wait( &status ); } #elif defined(Q_OS_WIN) void **buffer = new void *[ depth ]; SymSetOptions( SYMOPT_DEFERRED_LOADS | SYMOPT_INCLUDE_32BIT_MODULES | SYMOPT_UNDNAME ); SymInitialize( GetCurrentProcess(), "http://msdl.microsoft.com/download/symbols;http://download.osgeo.org/osgeo4w/symstore", TRUE ); unsigned short nFrames = CaptureStackBackTrace( 1, depth, buffer, nullptr ); SYMBOL_INFO *symbol = ( SYMBOL_INFO * ) qgsMalloc( sizeof( SYMBOL_INFO ) + 256 ); symbol->MaxNameLen = 255; symbol->SizeOfStruct = sizeof( SYMBOL_INFO ); IMAGEHLP_LINE *line = ( IMAGEHLP_LINE * ) qgsMalloc( sizeof( IMAGEHLP_LINE ) ); line->SizeOfStruct = sizeof( IMAGEHLP_LINE ); for ( int i = 0; i < nFrames; i++ ) { DWORD dwDisplacement; SymFromAddr( GetCurrentProcess(), ( DWORD64 )( buffer[ i ] ), 0, symbol ); symbol->Name[ 255 ] = 0; if ( SymGetLineFromAddr( GetCurrentProcess(), ( DWORD64 )( buffer[i] ), &dwDisplacement, line ) ) { myPrint( "%s(%d) : (%s) frame %d, address %x\n", line->FileName, line->LineNumber, symbol->Name, i, symbol->Address ); } else { myPrint( "%s(%d) : (%s) unknown source location, frame %d, address %x [GetLastError()=%d]\n", __FILE__, __LINE__, symbol->Name, i, symbol->Address, GetLastError() ); } } qgsFree( symbol ); qgsFree( line ); #else Q_UNUSED( depth ); #endif }