void rpn_csh_str()
{
char *string;
void dummy_sigusr1();
signal(SIGUSR1, dummy_sigusr1);
if (!fp) {
/* open a pipe and start csh */
#if defined(vxWorks)
fprintf(stderr, "popen is not supported in vxWorks\n");
exit(1);
#else
fp = popen("csh", "w");
pid = getpid();
#endif
}
if (!(string = pop_string()))
return;
fprintf(fp, "%s\nkill -USR1 %d\n", string, pid);
fflush(fp);
/* pause until SIGUSR1 is received */
sigpause(SIGUSR1);
/* back to default behavior for sigusr1 */
signal(SIGUSR1, SIG_DFL);
}
int main()
{
int return_value = 0;
int result;
return_value = sigpause(-1);
if (return_value == -1) {
if (errno == EINVAL) {
printf ("Test PASSED: sigpause returned -1 and set errno to EINVAL\n");
result = 0;
} else {
printf ("Test FAILED: sigpause did not set errno to EINVAL\n");
result = 1;
}
} else {
printf ("Test FAILED: sigpause did not return -1\n");
if (errno == EINVAL)
printf ("Test FAILED: sigpause did not set errno to EINVAL\n");
result = 1;
}
if (result == 2) {
return PTS_UNRESOLVED;
}
if (result == 1) {
return PTS_FAIL;
}
printf("Test PASSED\n");
return PTS_PASS;
}
void *a_thread_func(void *arg)
{
int return_value = 0;
struct sigaction act;
act.sa_flags = 0;
act.sa_handler = handler;
sigemptyset(&act.sa_mask);
sigaction(SIGTOTEST, &act, 0);
return_value = sigpause(SIGTOTEST);
if (return_value == -1) {
if (errno == EINTR) {
printf ("Test PASSED: sigpause returned -1 and set errno to EINTR\n");
result = 0;
} else {
printf ("Test FAILED: sigpause did not set errno to EINTR\n");
result = 1;
}
} else {
if (errno == EINTR) {
printf ("Test FAILED: sigpause did not return -1\n");
}
printf ("Test FAILED: sigpause did not set errno to EINTR\n");
printf ("Test FAILED: sigpause did not return -1\n");
result = 1;
}
sem = INMAIN;
return NULL;
}
TEST(signal, sighold_sigpause_sigrelse) {
static int sigalrm_handler_call_count;
auto sigalrm_handler = [](int) { sigalrm_handler_call_count++; };
ScopedSignalHandler sigalrm{SIGALRM, sigalrm_handler};
ScopedSignalMask mask;
sigset_t set;
// sighold(SIGALRM) should add SIGALRM to the signal mask ...
ASSERT_EQ(0, sighold(SIGALRM));
ASSERT_EQ(0, sigprocmask(SIG_SETMASK, 0, &set));
EXPECT_TRUE(sigismember(&set, SIGALRM));
// ... preventing our SIGALRM handler from running ...
raise(SIGALRM);
ASSERT_EQ(0, sigalrm_handler_call_count);
// ... until sigpause(SIGALRM) temporarily unblocks it.
ASSERT_EQ(-1, sigpause(SIGALRM));
ASSERT_EQ(EINTR, errno);
ASSERT_EQ(1, sigalrm_handler_call_count);
// But sigpause(SIGALRM) shouldn't permanently unblock SIGALRM.
ASSERT_EQ(0, sigprocmask(SIG_SETMASK, 0, &set));
EXPECT_TRUE(sigismember(&set, SIGALRM));
ASSERT_EQ(0, sigrelse(SIGALRM));
ASSERT_EQ(0, sigprocmask(SIG_SETMASK, 0, &set));
EXPECT_FALSE(sigismember(&set, SIGALRM));
}
void
pause_on_sigusr( int which )
{
#ifndef HAVE_DOSISH_SYSTEM
#ifdef HAVE_SIGPROCMASK
sigset_t mask, oldmask;
assert( which == 1 );
sigemptyset( &mask );
sigaddset( &mask, SIGUSR1 );
sigprocmask( SIG_BLOCK, &mask, &oldmask );
while( !caught_sigusr1 )
sigsuspend( &oldmask );
caught_sigusr1 = 0;
sigprocmask( SIG_UNBLOCK, &mask, NULL );
#else
assert (which == 1);
sighold (SIGUSR1);
while (!caught_sigusr1)
sigpause(SIGUSR1);
caught_sigusr1 = 0;
sigrelse(SIGUSR1); ????
#endif /*!HAVE_SIGPROCMASK*/
#endif
}
int
usleep(int usec)
{
struct itimerval value, dumb;
(void)signal(SIGALRM, usleep_sig);
if(getitimer(ITIMER_REAL, &value) != 0)
{
perror("Error: couldn't get timer");
return(-1);
}
value.it_value.tv_sec = value.it_interval.tv_sec = (long) usec / 1000000;
value.it_value.tv_usec = value.it_interval.tv_usec = (long) usec % 1000000;
if(setitimer(ITIMER_REAL, &value, &dumb) != 0) /* ignore parameter 3 */
{
perror("Error: couldn't set timer");
return(-1);
}
(void)sigpause(SIGALRM);
if(getitimer(ITIMER_REAL, &value) != 0)
{
perror("Error: couldn't get timer");
return(-1);
}
usec = (value.it_value.tv_sec - value.it_interval.tv_sec) * 1000000;
usec += (value.it_value.tv_usec - value.it_interval.tv_usec);
return usec;
}
static void
timerPause(void)
{
#ifdef HAVE_SIGHOLD
sighold(SIGALRM);
if (! signalled) {
sigpause(SIGALRM);
}
#else
int oldmask;
oldmask = sigblock(sigmask(SIGALRM));
if (! signalled) {
sigpause(0);
}
sigsetmask(oldmask);
#endif
}
delayMsec(int time)
{
timer_went_off = 0;
setup_ms_timer(time); /* in msec */
while (!timer_went_off)
sigpause(0);
cleanup_from_timeout();
}
/****************************************************************************
* Private Functions
****************************************************************************/
static void taskmgr_pause_handler(int signo, siginfo_t *info, void *extra)
{
if (signo != SIGTM_PAUSE) {
tmdbg("[TM] Invalid signal. signo = %d\n", signo);
return;
}
sigpause(SIGTM_RESUME);
}
int
sigsuspend (sigset_t *mask)
{
if (!mask) {
errno = EINVAL;
return -1;
}
return sigpause(*mask);
}
void sig_pause(void)
{
#ifdef SD_HAVE_SIGPROCMASK
sigset_t ss;
sigemptyset(&ss);
sigsuspend(&ss);
#else
sigpause(0);
#endif
}
int main()
{
int child_pid, child_pgid;
if ((child_pid = fork()) == 0) {
/* child here */
struct sigaction act;
act.sa_handler=myhandler;
act.sa_flags=0;
sigemptyset(&act.sa_mask);
sigaction(SIGTOTEST, &act, 0);
/* change child's process group id */
setpgrp();
sigpause(SIGABRT);
return 0;
} else {
/* parent here */
int i;
sigignore(SIGTOTEST);
sleep(1);
if ((child_pgid = getpgid(child_pid)) == -1) {
printf("Could not get pgid of child\n");
return PTS_UNRESOLVED;
}
if (killpg(child_pgid, SIGTOTEST) != 0) {
printf("Could not raise signal being tested\n");
return PTS_UNRESOLVED;
}
if (wait(&i) == -1) {
perror("Error waiting for child to exit\n");
return PTS_UNRESOLVED;
}
if (WEXITSTATUS(i)) {
printf("Child exited normally\n");
printf("Test PASSED\n");
return PTS_PASS;
} else {
printf("Child did not exit normally.\n");
printf("Test FAILED\n");
return PTS_FAIL;
}
}
printf("Should have exited from parent\n");
printf("Test FAILED\n");
return PTS_FAIL;
}
void
wait_for_signal(void)
{
int mask, omask;
mask = sigmask(SIGIO) | sigmask(SIGALRM);
omask = sigblock(0);
omask &= ~mask;
if (sigpause(omask) && (errno != EINTR))
msyslog(LOG_ERR, "wait_for_signal: sigspause() failed: %m");
}
main()
{
int n ;
char buff[BUFFSIZE];
signal( SIGIO , sigio_func );
if( fcntl( 0 , F_SETOWN , getpid() ) < 0 ){
return 1;
}
if( fcntl( 0 , F_SETFL , FASYNC ) < 0 ){
return 2;
}
for(;;){
sigblock( sigmask(SIGIO) );
printf( ">");
while( sigflag == 0 ){
sigpause(0);
}
#if 0
if( ( n = read( 0 , buff , BUFFSIZE )) > 0 ){
if( write(1,buff,n) != n ){
return 5;
}
} else {
if( n < 0 ){
return 8;
} else if( n == 0 ){
return 0;
}
}
#endif
{
char *p = readline( "" );
printf( "<%s>\n", p );
}
sigflag = 0;
sigsetmask(0);
}
}
void *timer_function(void *time){
int id;
id = *(int *)time;
while(id<20)
id++;
printf("Timer ran : %d sec \n", id);
printf("Setting alarm in timer thread\n");
set_timer();
for (;;)
sigpause();
printf("Timer wait done\n");
}
int main(void) {
printf ("My pid is %d\n", getpid());
printf (
"Signal managed : SIGTALRM(intern), SIGUSR1(30), SIGUSR2(31)\n");
set_handler (SIGALRM, handler_sigalrm, NULL);
set_handler (SIGUSR1, handler_sigusr1, NULL);
set_handler (SIGUSR2, handler_sigusr2, NULL);
printf ("Start timer\n");
arm_timer (ITIMER_REAL, (long)ALRM_S, (long)ALRM_U, 1);
sigpause (sigmask(SIGALRM) | sigmask(SIGUSR1));
printf ("Done.\n");
exit(0);
}
unsigned int
sleep(unsigned int seconds) {
sig_t ovec;
long omask;
if (seconds == 0) {
return 0;
}
ovec = signal(SIGALRM, _sleephandler);
omask = sigblock(sigmask(SIGALRM));
_ringring = 0;
alarm(seconds);
while (!_ringring) {
sigpause(omask &~ sigmask(SIGALRM));
}
signal(SIGALRM, ovec);
sigsetmask(omask);
return 0;
}
/* Timer: wait for n milliseconds */
static void Timer(int n)
{
long usec;
struct itimerval it;
usec = (long) n * 1000;
memset(&it, 0, sizeof(it));
if (usec>=1000000L) { /* more than 1 second */
it.it_value.tv_sec = usec / 1000000L;
usec %= 1000000L;
}
it.it_value.tv_usec = usec; timerDone=FALSE;
signal(SIGALRM, AlarmOn);
setitimer(ITIMER_REAL, &it, NULL);
while (1) {
sigblock(sigmask(SIGALRM));
if (timerDone) break;
sigpause(0);
}
sigblock(0);
signal(SIGALRM, SIG_DFL);
}
void
runstats(FILE *fd, struct statshandler *sh)
{
u_long off;
int line, omask;
if (sh->interval < 1)
sh->interval = 1;
signal(SIGALRM, catchalarm);
signalled = 0;
alarm(sh->interval);
banner:
sh->printbanner(sh, fd);
fflush(fd);
line = 0;
loop:
if (line != 0) {
sh->getstats(sh, sh->cur);
sh->reportdelta(sh, fd);
sh->update(sh);
} else {
sh->getstats(sh, sh->total);
sh->reporttotal(sh, fd);
}
putc('\n', fd);
fflush(fd);
omask = sigblock(sigmask(SIGALRM));
if (!signalled)
sigpause(0);
sigsetmask(omask);
signalled = 0;
alarm(sh->interval);
line++;
if (line == 21) /* XXX tty line count */
goto banner;
else
goto loop;
/*NOTREACHED*/
}
void rpn_csh()
{
char *ptr;
void dummy_sigusr1();
static char s[1024];
signal(SIGUSR1, dummy_sigusr1);
if (!fp) {
/* open a pipe and start csh */
#if defined(vxWorks)
fprintf(stderr, "popen is not supported in vxWorks\n");
exit(1);
#else
fp = popen("csh", "w");
pid = getpid();
#endif
}
/* loop to print prompt and accept commands */
while (fputs("csh> ", stdout), fgets(s, 100, stdin)) {
/* send user's command along with another than causes subprocess
* to send the SIGUSR1 signal this process
*/
ptr = s;
while (isspace(*ptr))
ptr++;
if (strncmp(ptr, "quit", 4)==0 || strncmp(ptr, "exit", 4)==0)
break;
fprintf(fp, "%s\nkill -USR1 %d\n", s, pid);
fflush(fp);
/* pause until SIGUSR1 is received */
sigpause(SIGUSR1);
}
/* back to default behavior for sigusr1 */
signal(SIGUSR1, SIG_DFL);
}
main()
{
int n;
char buff[BUFFSIZE];
int sigio_func();
signal(SIGIO, sigio_func);
if (fcntl(0, F_SETOWN, getpid()) < 0)
err_sys("F_SETOWN error");
if (fcntl(0, F_SETFL, FASYNC) < 0)
err_sys("F_SETFL FASYNC error");
for ( ; ; ) {
sigblock(sigmask(SIGIO));
while (sigflag == 0)
sigpause(0); /* wait for a signal */
/*
* We're here if (sigflag != 0). Also, we know that the
* SIGIO signal is currently blocked.
*/
if ( (n = read(0, buff, BUFFSIZE)) > 0) {
if (write(1, buff, n) != n)
err_sys("write error");
} else if (n < 0)
err_sys("read error");
else if (n == 0)
exit(0); /* EOF */
sigflag = 0; /* turn off our flag */
sigsetmask(0); /* and reenable signals */
}
}
void
pause_on_sigusr( int which )
{
#if defined(HAVE_SIGPROCMASK) && defined(HAVE_SIGSET_T)
sigset_t mask, oldmask;
assert( which == 1 );
sigemptyset( &mask );
sigaddset( &mask, SIGUSR1 );
sigprocmask( SIG_BLOCK, &mask, &oldmask );
while( !caught_sigusr1 )
sigsuspend( &oldmask );
caught_sigusr1 = 0;
sigprocmask( SIG_UNBLOCK, &mask, NULL );
#else
assert (which == 1);
sighold (SIGUSR1);
while (!caught_sigusr1)
sigpause(SIGUSR1);
caught_sigusr1 = 0;
sigrelse(SIGUSR1);
#endif /*! HAVE_SIGPROCMASK && HAVE_SIGSET_T */
}
void
mkfs(char *fsys, int fi, int fo, const char *mfscopy)
{
long i, mincpc, mincpg, inospercg;
long cylno, rpos, blk, j, emitwarn = 0;
long used, mincpgcnt, bpcg;
off_t usedb;
long mapcramped, inodecramped;
long postblsize, rotblsize, totalsbsize;
int status, fd;
time_t utime;
quad_t sizepb;
int width;
char tmpbuf[100]; /* XXX this will break in about 2,500 years */
time(&utime);
#ifdef FSIRAND
if (!randinit) {
randinit = 1;
srandomdev();
}
#endif
if (mfs) {
int omask;
pid_t child;
mfs_ppid = getpid();
signal(SIGUSR1, parentready);
if ((child = fork()) != 0) {
/*
* Parent
*/
if (child == -1)
err(10, "mfs");
if (mfscopy)
copyroot = FSCopy(©hlinks, mfscopy);
signal(SIGUSR1, started);
kill(child, SIGUSR1);
while (waitpid(child, &status, 0) != child)
;
exit(WEXITSTATUS(status));
/* NOTREACHED */
}
/*
* Child
*/
omask = sigblock(sigmask(SIGUSR1));
while (parentready_signalled == 0)
sigpause(omask);
sigsetmask(omask);
if (filename != NULL) {
unsigned char buf[BUFSIZ];
unsigned long l, l1;
ssize_t w;
fd = open(filename, O_RDWR|O_TRUNC|O_CREAT, 0644);
if(fd < 0)
err(12, "%s", filename);
l1 = fssize * sectorsize;
if (l1 > BUFSIZ)
l1 = BUFSIZ;
for (l = 0; l < fssize * (u_long)sectorsize; l += l1) {
w = write(fd, buf, l1);
if (w < 0 || (u_long)w != l1)
err(12, "%s", filename);
}
membase = mmap(NULL, fssize * sectorsize,
PROT_READ|PROT_WRITE,
MAP_SHARED, fd, 0);
if (membase == MAP_FAILED)
err(12, "mmap");
close(fd);
} else {
membase = mmap(NULL, fssize * sectorsize,
PROT_READ|PROT_WRITE,
MAP_SHARED|MAP_ANON, -1, 0);
if (membase == MAP_FAILED)
errx(13, "mmap (anonymous memory) failed");
}
}
fsi = fi;
fso = fo;
if (Oflag) {
sblock.fs_inodefmt = FS_42INODEFMT;
sblock.fs_maxsymlinklen = 0;
} else {
sblock.fs_inodefmt = FS_44INODEFMT;
sblock.fs_maxsymlinklen = MAXSYMLINKLEN;
}
if (Uflag)
sblock.fs_flags |= FS_DOSOFTDEP;
if (Lflag)
strlcpy(sblock.fs_volname, volumelabel, MAXVOLLEN);
/*
* Validate the given file system size.
* Verify that its last block can actually be accessed.
*/
if (fssize == 0)
printf("preposterous size %lu\n", fssize), exit(13);
wtfs(fssize - (realsectorsize / DEV_BSIZE), realsectorsize,
(char *)&sblock);
/*
* collect and verify the sector and track info
*/
sblock.fs_nsect = nsectors;
sblock.fs_ntrak = ntracks;
if (sblock.fs_ntrak <= 0)
printf("preposterous ntrak %d\n", sblock.fs_ntrak), exit(14);
if (sblock.fs_nsect <= 0)
printf("preposterous nsect %d\n", sblock.fs_nsect), exit(15);
/*
* collect and verify the filesystem density info
*/
sblock.fs_avgfilesize = avgfilesize;
sblock.fs_avgfpdir = avgfilesperdir;
if (sblock.fs_avgfilesize <= 0)
printf("illegal expected average file size %d\n",
sblock.fs_avgfilesize), exit(14);
if (sblock.fs_avgfpdir <= 0)
printf("illegal expected number of files per directory %d\n",
sblock.fs_avgfpdir), exit(15);
/*
* collect and verify the block and fragment sizes
*/
sblock.fs_bsize = bsize;
sblock.fs_fsize = fsize;
if (!POWEROF2(sblock.fs_bsize)) {
printf("block size must be a power of 2, not %d\n",
sblock.fs_bsize);
exit(16);
}
if (!POWEROF2(sblock.fs_fsize)) {
printf("fragment size must be a power of 2, not %d\n",
sblock.fs_fsize);
exit(17);
}
if (sblock.fs_fsize < sectorsize) {
printf("fragment size %d is too small, minimum is %d\n",
sblock.fs_fsize, sectorsize);
exit(18);
}
if (sblock.fs_bsize < MINBSIZE) {
printf("block size %d is too small, minimum is %d\n",
sblock.fs_bsize, MINBSIZE);
exit(19);
}
if (sblock.fs_bsize < sblock.fs_fsize) {
printf("block size (%d) cannot be smaller than fragment size (%d)\n",
sblock.fs_bsize, sblock.fs_fsize);
exit(20);
}
sblock.fs_bmask = ~(sblock.fs_bsize - 1);
sblock.fs_fmask = ~(sblock.fs_fsize - 1);
sblock.fs_qbmask = ~sblock.fs_bmask;
sblock.fs_qfmask = ~sblock.fs_fmask;
for (sblock.fs_bshift = 0, i = sblock.fs_bsize; i > 1; i >>= 1)
sblock.fs_bshift++;
for (sblock.fs_fshift = 0, i = sblock.fs_fsize; i > 1; i >>= 1)
sblock.fs_fshift++;
sblock.fs_frag = numfrags(&sblock, sblock.fs_bsize);
for (sblock.fs_fragshift = 0, i = sblock.fs_frag; i > 1; i >>= 1)
sblock.fs_fragshift++;
if (sblock.fs_frag > MAXFRAG) {
printf("fragment size %d is too small, minimum with block size %d is %d\n",
sblock.fs_fsize, sblock.fs_bsize,
sblock.fs_bsize / MAXFRAG);
exit(21);
}
sblock.fs_nrpos = nrpos;
sblock.fs_nindir = sblock.fs_bsize / sizeof(daddr_t);
sblock.fs_inopb = sblock.fs_bsize / sizeof(struct ufs1_dinode);
sblock.fs_nspf = sblock.fs_fsize / sectorsize;
for (sblock.fs_fsbtodb = 0, i = NSPF(&sblock); i > 1; i >>= 1)
sblock.fs_fsbtodb++;
sblock.fs_sblkno =
roundup(howmany(bbsize + sbsize, sblock.fs_fsize), sblock.fs_frag);
sblock.fs_cblkno = (daddr_t)(sblock.fs_sblkno +
roundup(howmany(sbsize, sblock.fs_fsize), sblock.fs_frag));
sblock.fs_iblkno = sblock.fs_cblkno + sblock.fs_frag;
sblock.fs_cgoffset = roundup(
howmany(sblock.fs_nsect, NSPF(&sblock)), sblock.fs_frag);
for (sblock.fs_cgmask = 0xffffffff, i = sblock.fs_ntrak; i > 1; i >>= 1)
sblock.fs_cgmask <<= 1;
if (!POWEROF2(sblock.fs_ntrak))
sblock.fs_cgmask <<= 1;
sblock.fs_maxfilesize = sblock.fs_bsize * NDADDR - 1;
for (sizepb = sblock.fs_bsize, i = 0; i < NIADDR; i++) {
sizepb *= NINDIR(&sblock);
sblock.fs_maxfilesize += sizepb;
}
/*
* Validate specified/determined secpercyl
* and calculate minimum cylinders per group.
*/
sblock.fs_spc = secpercyl;
for (sblock.fs_cpc = NSPB(&sblock), i = sblock.fs_spc;
sblock.fs_cpc > 1 && (i & 1) == 0;
sblock.fs_cpc >>= 1, i >>= 1)
/* void */;
mincpc = sblock.fs_cpc;
bpcg = sblock.fs_spc * sectorsize;
inospercg = roundup(bpcg / sizeof(struct ufs1_dinode), INOPB(&sblock));
if (inospercg > MAXIPG(&sblock))
inospercg = MAXIPG(&sblock);
used = (sblock.fs_iblkno + inospercg / INOPF(&sblock)) * NSPF(&sblock);
mincpgcnt = howmany(sblock.fs_cgoffset * (~sblock.fs_cgmask) + used,
sblock.fs_spc);
mincpg = roundup(mincpgcnt, mincpc);
/*
* Ensure that cylinder group with mincpg has enough space
* for block maps.
*/
sblock.fs_cpg = mincpg;
sblock.fs_ipg = inospercg;
if (maxcontig > 1)
sblock.fs_contigsumsize = MIN(maxcontig, FS_MAXCONTIG);
mapcramped = 0;
while (CGSIZE(&sblock) > (uint32_t)sblock.fs_bsize) {
mapcramped = 1;
if (sblock.fs_bsize < MAXBSIZE) {
sblock.fs_bsize <<= 1;
if ((i & 1) == 0) {
i >>= 1;
} else {
/*---------------------------------------------------------------------+
| main () |
| ==================================================================== |
| |
| Function: Main program (see prolog for more details) |
| |
+---------------------------------------------------------------------*/
int main(int argc, char **argv)
{
sigset_t mask, /* Initial process signal mask */
newmask, /* Second process signal mask */
oldmask; /* Signal mask returned by sigblock */
pid_t pid = getpid(); /* Process ID (of this process) */
/* Print out program header */
printf("%s: IPC Signals TestSuite program\n\n", *argv);
/*
* Establish signal handler for each signal & reset "valid signals"
* array, and setup alternative stack for processing signals
*/
init_sig_vec();
reset_valid_sig();
#ifdef _LINUX_
// sigstack function is obsolete, use sigaltstack instead
if (sigaltstack(&stack, NULL) < 0)
sys_error("sigaltstack failed", __LINE__);
#else
if (sigstack(&stack, NULL) < 0)
sys_error("sigstack failed", __LINE__);
#endif
/*
* Send SIGILL, SIGALRM & SIGIOT signals to this process:
*
* First indicate which signals the signal handler should expect
* by setting the corresponding valid_sig[] array fields.
*
* Then send the signals to this process.
*
* And finally verify that the signals were caught by the signal
* handler by checking to see if the corresponding valid_sig[] array
* fields were reset.
*/
printf("\tSend SIGILL, SIGALRM, SIGIOT signals to process\n");
valid_sig[SIGILL] = 1;
valid_sig[SIGALRM] = 1;
valid_sig[SIGIOT] = 1;
kill(pid, SIGILL);
kill(pid, SIGALRM);
kill(pid, SIGIOT);
if (valid_sig[SIGILL])
error("failed to receive SIGILL signal!", __LINE__);
if (valid_sig[SIGALRM])
error("failed to receive SIGALRM signal!", __LINE__);
if (valid_sig[SIGIOT])
error("failed to receive SIGIOT signal!", __LINE__);
/*
* Block SIGILL, SIGALRM & SIGIOT signals:
*
* First create the process signal mask by ORing together the
* signal values.
*
* Then change the process signal mask with sigsetmask ().
*
* Verify that the desired signals are blocked from interrupting the
* process, by sending both blocked and unblocked signals to the
* process. Only the unblocked signals should interrupt the process.
*/
printf("\n\tBlock SIGILL, SIGALRM, SIGIOT signals, "
"and resend signals + others\n");
sigemptyset(&mask);
sigaddset(&mask, SIGILL);
sigaddset(&mask, SIGALRM);
sigaddset(&mask, SIGIOT);
#ifdef _LINUX_
sigprocmask(SIG_SETMASK, &mask, NULL);
#else
if (sigsetmask(mask) < 0)
sys_error("setsigmask failed", __LINE__);
#endif
valid_sig[SIGFPE] = 1;
valid_sig[SIGTERM] = 1;
valid_sig[SIGINT] = 1;
kill(pid, SIGILL);
kill(pid, SIGALRM);
kill(pid, SIGIOT);
kill(pid, SIGFPE);
kill(pid, SIGTERM);
kill(pid, SIGINT);
if (valid_sig[SIGFPE])
error("failed to receive SIGFPE signal!", __LINE__);
if (valid_sig[SIGTERM])
error("failed to receive SIGTERM signal!", __LINE__);
if (valid_sig[SIGINT])
error("failed to receive SIGINT signal!", __LINE__);
/*
* Block additional SIGFPE, SIGTERM & SIGINT signals:
*
* Create a signal mask containing the additional signals to block.
*
* Change the process signal mask to block the additional signals
* with the sigprocmask () function.
*
* Verify that all of the desired signals are now blocked from
* interrupting the process. None of the specified signals should
* interrupt the process until the process signal mask is changed.
*/
printf("\n\tBlock rest of signals\n");
sigemptyset(&newmask);
sigaddset(&newmask, SIGFPE);
sigaddset(&newmask, SIGTERM);
sigaddset(&newmask, SIGINT);
sigemptyset(&oldmask);
if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0) {
perror("sigprocmask failed");
exit(-1);
}
if (memcmp(&mask, &oldmask, sizeof(mask)) != 0)
error("value returned by sigblock () does not match the "
"old signal mask", __LINE__);
kill(pid, SIGILL);
kill(pid, SIGALRM);
kill(pid, SIGIOT);
kill(pid, SIGFPE);
kill(pid, SIGTERM);
kill(pid, SIGINT);
/* Wait two seconds just to make sure that none of the specified
* signals interrupt the process (They should all be blocked).
*/
sleep(2);
/* Change the process signal mask:
*
* Now allow the SIGINT signal to interrupt the process.
* Thus by using sigpause (), force the process to suspend
* execution until delivery of an unblocked signal (here SIGINT).
*
* Additionally, verify that the SIGINT signal was received.
*/
valid_sig[SIGINT] = 1;
printf
("\n\tChange signal mask & wait until signal interrupts process\n");
if (sigpause(SIGINT) != -1 || errno != 4)
sys_error("sigpause failed", __LINE__);
if (valid_sig[SIGINT])
error("failed to receive SIGINT signal!", __LINE__);
/* Program completed successfully -- exit */
printf("\nsuccessful!\n");
return (0);
}
int main(int argc, char *argv[])
{
#if !defined(NOALARM)
struct itimerval new_timer, old_timer;
#endif /* !NOALARM */
struct rlimit rlp;
#if defined(USE_SIGACTION)
struct sigaction sigact;
#endif
struct sockaddr_in sadd;
getrlimit(RLIMIT_NOFILE, &rlp);
rlp.rlim_cur = rlp.rlim_max;
setrlimit(RLIMIT_NOFILE, &rlp);
/* First things first, let the client know we're alive */
write(1, SERVER_CONNECT_MSG, strlen(SERVER_CONNECT_MSG));
/* Need this to keep in sync with the client side
*
* <start><ident_id><local_port><sin_family><s_addr><sin_port>
*/
req_size = sizeof(char) + sizeof(ident_identifier) + sizeof(short int)
+ sizeof(sadd.sin_family) + sizeof(sadd.sin_addr.s_addr)
+ sizeof(sadd.sin_port);
/* Set up signal handling */
#if defined( USE_SIGACTION )
#if defined( USE_SIGEMPTYSET )
sigemptyset(&(sigact.sa_mask));
#if !defined( FREEBSD ) && !defined( GLIBC )
sigact.sa_sigaction = 0;
#endif
#else
sigact.sa_mask = 0;
#if defined ( LINUX )
sigact.sa_restorer = (void *) 0;
#endif
#endif /* USE_SIGEMPTYSET */
sigact.sa_handler = catch_sigterm;
sigaction(SIGTERM, &sigact, (struct sigaction *) 0);
#if !defined ( NOALARM )
sigact.sa_handler = catch_sigalrm;
sigaction(SIGALRM, &sigact, (struct sigaction *) 0);
#endif /* !NOALARM */
sigact.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &sigact, (struct sigaction *) 0);
#else /* !USE_SIGACTION */
signal(SIGTERM, catch_sigterm);
#if !defined(NOALARM)
signal(SIGALRM, catch_sigalrm);
#endif /* !NOALARM */
signal(SIGPIPE, SIG_IGN);
#endif /* USE_SIGACTION */
#if !defined(NOALARM)
beats_per_second = 5;
/* Set up a timer to wake us up now and again */
new_timer.it_interval.tv_sec = 0;
new_timer.it_interval.tv_usec = 1000000 / beats_per_second;
new_timer.it_value.tv_sec = 0;
new_timer.it_value.tv_usec = new_timer.it_interval.tv_usec;
if (0 > setitimer(ITIMER_REAL, &new_timer, &old_timer))
{
perror("ident");
}
#endif /* !NOALARM */
#if defined(HAVE_BZERO)
#ifdef SUNOS
bzero((char *)&idents_in_progress[0], MAX_IDENTS_IN_PROGRESS * sizeof(ident_request));
#elif OSF
bzero((void *)&idents_in_progress[0], MAX_IDENTS_IN_PROGRESS * sizeof(ident_request));
#else
bzero(&idents_in_progress[0], MAX_IDENTS_IN_PROGRESS * sizeof(ident_request));
#endif
#else /* !HAVE_BZERO */
memset(&idents_in_progress[0], 0,
MAX_IDENTS_IN_PROGRESS * sizeof(ident_request));
#endif /* HAVE_BZERO */
/* Now enter the main loop */
status = STATUS_RUNNING;
while (status != STATUS_SHUTDOWN)
{
if (1 == getppid())
{
/* If our parent is now PID 1 (init) the talker must have died without
* killing us, so we have no business still being here
*
* time to die...
*/
exit(0);
}
check_requests();
check_connections();
#if !defined(NOALARM)
sigpause(0);
#endif /* !NOALARM */
}
return 0;
}
static void pauseit(void)
{
sigpause(0);
}
/** This method controls the standard timer. After the arrival of a signal it
checks which messages should be sent / received by the clients and handles
them appropriately. */
void
StandardTimer::run()
{
double lcmt = 0.0;
// the sequence of messages will always repeat itself after lcm_st ms.
// the number of messages that should be processed before the sequence
// "quits" thus equals (lcm_st / x) where x is the time interval for the
// specific message
// Example: lcm_st = 300, sim_st = 100, q_simt = 300 / 100 = 3.
// three simulations steps have to occur in one sequence
// in the default case the listed variables will have the following values
// q_simt = 3 (simulation step)
// q_sent = 8 (sending visual information - low quality, narrow width)
// q_rect = 30 (process arrival of messages)
// q_sbt = 3 (sense body step)
// q_svt = 3 (coach look interval)
// c_* will contain the number of processed messages in this sequence
int c_simt = 1, c_sent = 1, c_rect = 1, c_sbt = 1, c_svt = 1,
q_simt = ServerParam::instance().lcmStep() / ServerParam::instance().simStep(),
q_sent = ServerParam::instance().lcmStep() / ServerParam::instance().sendStep()*4,
q_rect = ServerParam::instance().lcmStep() / ServerParam::instance().recvStep(),
q_sbt = ServerParam::instance().lcmStep() / ServerParam::instance().senseBodyStep(),
q_svt = ServerParam::instance().lcmStep() / ServerParam::instance().coachVisualStep();
int c_synch_see = 1;
bool sent_synch_see = false;
// create a timer that will be called every TIMEDELTA msec. Each time
// this timer is called, lcmt is raised and it is checked which message
// should be processed according to the part of the sequence we are in
#ifdef RCSS_WIN
HANDLE gDoneEvent = NULL;
initTimer(gDoneEvent);
#else
struct itimerval itv_prev;
struct sigaction alarm_prev;
initTimer( itv_prev, alarm_prev );
#endif
//for (;;)
while ( getTimeableRef().alive() )
{
#ifdef RCSS_WIN
if ( WaitForSingleObject(gDoneEvent, INFINITE) != WAIT_OBJECT_0 )
printf( "WaitForSingleObject failed (%d)\n", GetLastError() );
#else
if ( ! gotsig )
sigpause( SIGUSR1 );
#endif
gotsig = false;
lock_timedelta = true;
lcmt += timedelta;
timedelta = 0;
lock_timedelta = false;
if ( lcmt >= ServerParam::instance().simStep() * c_simt )
{
c_simt = static_cast< int >( std::floor( lcmt / ServerParam::instance().simStep() ) );
lcmt = ServerParam::instance().simStep() * c_simt;
// the above lines are needed to
// prevent short "catch up" cycles if
// the current cycle was slow
}
// receive messages
if ( lcmt >= ServerParam::instance().recvStep() * c_rect )
{
getTimeableRef().recvFromClients();
c_rect = static_cast< int >( std::floor( lcmt / ServerParam::instance().recvStep() ) );
if ( q_rect <= c_rect )
c_rect = 1;
else
c_rect++;
}
// update after new simulation step
if ( lcmt >= ServerParam::instance().simStep() * c_simt )
{
getTimeableRef().newSimulatorStep();
if ( q_simt <= c_simt )
c_simt = 1;
else
c_simt++;
sent_synch_see = false;
}
// send sense body
if ( lcmt >= ServerParam::instance().senseBodyStep() * c_sbt )
{
getTimeableRef().sendSenseBody();
c_sbt = static_cast< int >( std::floor( lcmt / ServerParam::instance().senseBodyStep() ) );
if ( q_sbt <= c_sbt )
c_sbt = 1;
else
c_sbt++;
}
// send visual messages
if ( lcmt >= ( ServerParam::instance().sendStep() * 0.25 ) * c_sent )
{
getTimeableRef().sendVisuals();
c_sent = static_cast< int >( std::floor( lcmt/(ServerParam::instance().sendStep() * 0.25 ) ) );
if ( q_sent <= c_sent )
c_sent = 1;
else
c_sent++;
}
// send synch visual message
if ( ! sent_synch_see
&& lcmt >= ( ServerParam::instance().simStep() * ( c_synch_see - 1 )
+ ServerParam::instance().synchSeeOffset() ) )
{
//std::cerr << "lcmt=" << lcmt << " c_synch_see=" << c_synch_see << '\n';
getTimeableRef().sendSynchVisuals();
++c_synch_see;
sent_synch_see = true;
}
// send coach look messages
if ( lcmt >= ServerParam::instance().coachVisualStep() * c_svt )
{
getTimeableRef().sendCoachMessages();
c_svt = static_cast< int >( std::floor( lcmt / ServerParam::instance().coachVisualStep() ) );
if ( q_svt <= c_svt )
c_svt = 1;
else
c_svt++;
}
if ( lcmt >= ServerParam::instance().lcmStep() )
{
lcmt = 0;
c_synch_see = 1;
}
}
#ifdef RCSS_WIN
#else
restoreTimer( itv_prev, alarm_prev );
#endif
getTimeableRef().quit();
}
int main(int argc, char *argv[]) {
int parent_pid = getpid();
int worker_pid;
if(argc != 2){
printf(1,"Needs 2 arguments... Try again.\n");
exit();
}
int n = atoi(argv[1]);
if(n > NPROC){
printf(1,"Too many workers, can't handle it!!!! Goodbye...\n");
exit();
}
int i = 0;
sigset(&parent_handler);
printf(1, "workers pids:\n");
for (i = 0; i < n; i++) { //creating n processes
worker_pid = fork();
if (worker_pid < 0)
break;
if (worker_pid == 0) { //child process
sigset(&worker_handler); // init sig_handler of the child process
while (1) {
sigpause();
}
} else {
workers[i].pid = worker_pid;
workers[i].free = 1;
printf(1, "%d\n", worker_pid);
}
}
if (getpid() == parent_pid) {
char buf[128];
for (;;) {
// sleep(1);
printf(1, "please enter a number: ");
read(1, buf, 128);
if (strlen(buf) == 1 && buf[0] == '\n')
continue;
int x = atoi(buf);
if (x < 0){ //Doesn't support negative numbers (or bigger than max_integer)
x = 1;
printf(1,"Primsrv doesn't support your number :( changing it to 1...\n");
}
memset(buf, '\0', 128);
if (x == 0) { //need to exit program
for (i = 0; i < n; i++) {
sigsend(workers[i].pid, x);
}
int pid;
while ((pid = wait()) > -1)
printf(1, "worker %d exit\n", pid);
printf(1, "primsrv exit\n");
break;
} else { //search for idle worker
i = 0;
while (i < n && !workers[i].free) {
i++;
}
if (i == n) {
printf(1, "no idle workers\n");
continue;
} else {
workers[i].free = 0;
workers[i].last_number = x;
sigsend(workers[i].pid, x);
}
}
}
}
exit();
}
int
main(int argc, char *argv[])
{
struct athstatfoo *wf;
const char *ifname;
int c, banner = 1;
ifname = getenv("ATH");
if (ifname == NULL)
ifname = "ath0";
wf = athstats_new(ifname, getfmt("default"));
while ((c = getopt(argc, argv, "bi:lo:z")) != -1) {
switch (c) {
case 'b':
banner = 0;
break;
case 'i':
wf->setifname(wf, optarg);
break;
case 'l':
wf->print_fields(wf, stdout);
return 0;
case 'o':
wf->setfmt(wf, getfmt(optarg));
break;
case 'z':
wf->zerostats(wf);
break;
default:
errx(-1, "usage: %s [-a] [-i ifname] [-l] [-o fmt] [-z] [interval]\n", argv[0]);
/*NOTREACHED*/
}
}
argc -= optind;
argv += optind;
if (argc > 0) {
u_long interval = strtoul(argv[0], NULL, 0);
int line, omask;
if (interval < 1)
interval = 1;
signal(SIGALRM, catchalarm);
signalled = 0;
alarm(interval);
banner:
if (banner)
wf->print_header(wf, stdout);
line = 0;
loop:
if (line != 0) {
wf->collect_cur(wf);
wf->print_current(wf, stdout);
wf->update_tot(wf);
} else {
wf->collect_tot(wf);
wf->print_total(wf, stdout);
}
fflush(stdout);
omask = sigblock(sigmask(SIGALRM));
if (!signalled)
sigpause(0);
sigsetmask(omask);
signalled = 0;
alarm(interval);
line++;
if (line == 21) /* XXX tty line count */
goto banner;
else
goto loop;
/*NOTREACHED*/
} else {
wf->collect_tot(wf);
wf->print_verbose(wf, stdout);
}
return 0;
}
static int start()
{
int lockfd;
int pipe3fd[2];
char temp_buf;
lockfd=ll_daemon_start(LOCKFILE);
if (lockfd <= 0)
{
close(3);
return (lockfd);
}
if (lockfd == 3)
{
lockfd=dup(lockfd); /* Get it out of the way */
if (lockfd < 0)
{
perror("dup");
return (-1);
}
}
if (reserve3(pipe3fd))
{
return (1);
}
fcntl(lockfd, F_SETFD, FD_CLOEXEC);
fcntl(pipe3fd[0], F_SETFD, FD_CLOEXEC);
fcntl(3, F_SETFD, FD_CLOEXEC); /* For the logger */
clog_start_logger("courierfilter");
clog_open_stderr(0);
fcntl(3, F_SETFD, 0);
signal(SIGPIPE, SIG_IGN);
dup2(2, 1);
sighup();
close(0);
open("/dev/null", O_RDONLY);
close(3);
if (read(pipe3fd[0], &temp_buf, 1) != 1)
; /* ignore */
close(pipe3fd[0]);
signal(SIGHUP, sighuphandler);
signal(SIGTERM, sigtermhandler);
ll_daemon_started(PIDFILE, lockfd);
while (!sigterm_received)
{
if (sighup_received)
{
sighup_received=0;
if (reserve3(pipe3fd) == 0)
{
sighup();
close(3);
close(pipe3fd[0]);
}
signal(SIGHUP, sighuphandler);
}
#if HAVE_SIGSUSPEND
{
sigset_t ss;
sigemptyset(&ss);
sigsuspend(&ss);
}
#else
sigpause(0);
#endif
}
while (filterlist)
kill1filter(&filterlist);
unlink(PIDFILE);
return (0);
}