Whatever Goes...

		The evil of feof!!!

	"feof" tortures me for long time! Because I simply don't understand what I read! Do you see the stupid bug following?

What do you know the meaning of "feof"? It only gives the true value when you TRY to PASS the end of file, not BEFORE! I think,

probably very few people will make this kind of stupid mistake like me. However, I just post it here for a memorandom!

#include <stdio.h>
#include <stdlib.h>

char* fileName="yourFile.txt";
const int BufferSize=20;
char buffer[BufferSize+1];

int main()
{
	FILE* stream;
	char ch;
	char* ptr;
	int counter=0;
	if ((stream=fopen(fileName, "r"))==NULL)
	{
		printf("Cannot open file %s\n", fileName);
		exit(1);
	}
	while (!feof(stream))
	{
		ch=fgetc(stream);
		buffer[counter++]=ch;
		if (counter==BufferSize)
		{
			buffer[counter]='\0';
			printf("now output string of length %d : %s\n", BufferSize, buffer);
			counter=0;
		}
	}
	if (counter!=0)
	{
		buffer[counter]='\0';
		printf("now output last line of length %d : %s\n", counter, buffer);
	}
	printf("however this is not end!!! What I mean is that there is a big bug");
	printf(" which I always ignore: There is an evil character at end of this line");
	printf(" let me show you in ASCII number, and pay attention to last one!\n");
	ptr=buffer;
	while (*ptr!='\0')
	{
		printf("char:%c = ASCII: %d\n", *ptr, *ptr);
		ptr++;
	}
	return 0;
}

If you don't see any problem, just look at the running result below:

now output string of length 20 : The feof routine (im
now output string of length 20 : plemented both as a
now output string of length 20 : function and as a ma
now output string of length 20 : cro) determines whet
now output string of length 20 : her the end of strea
now output string of length 20 : m has been reached.
now output string of length 20 : When end of file is
now output string of length 20 : reached, read operat
now output string of length 20 : ions return an end-o
now output string of length 20 : f-file indicator unt
now output string of length 20 : il the stream is clo
now output string of length 20 : sed or until rewind,
now output string of length 20 : fsetpos, fseek, or
now output string of length 20 : clearerr is called a
now output last line of length 10 : gainst it
however this is not end!!! What I mean is that there is a big bug which I always ignore: There is an
evil character at end of this line let me show you in ASCII number, and pay attention to last one!
char:g = ASCII: 103
char:a = ASCII: 97
char:i = ASCII: 105
char:n = ASCII: 110
char:s = ASCII: 115
char:t = ASCII: 116
char: = ASCII: 32
char:i = ASCII: 105
char:t = ASCII: 116
char: = ASCII: -1
Press any key to continue

***********************************

After quite a few years later, I take a look at what I was doing before. The problem can be fixed by using 

if ((ch=fgetc(stream))!=EOF) break;

The "feof" is not a "peek" operation, but you have to do the actual fgetc or fread. There is no "peek". i.e. no reading 

but only testing. No such thing at all!

*************************************

            The latency of disk head moves...

So, everybody who already has taken computer architecture course knows that the average latency time for disk arm to move to the target track is 1/3 of time it moves across all tracks. But how to calculate this? Honestly I don't know. I write a simple program to simulate and convince myself. However, there is one pre-condition for all kinds of "average waiting time" problems no matter whether the waiting elements are processes or tasks or threads or whatever. The length of queue must be stable otherwise there is no average waiting time at all.  Just imagine the queue is continuing to increase as the output is much slower than input. Can you predict the average waiting time? Increasing to infinite?  That is why I write the second version to test under different the incoming rate. The result is exactly 1/3 if the tasks are sparse and few.

This is a very simple question. However, as you know, as I have little knowledge of integral,  (amazing?) it becomes a very difficult problem for me.

After lunch I visit Mr. Zhu and understand the way of integral. The "latency" has nothing to do with "waiting time". They are completely different things!!! Latency is simply the time needed to reach the point by moving disk head. We simply don't have to consider the waiting time for each task.

proof:

center                                                                                                     edge

|---------------n tracks-------------|

|-----------------------------------------------------N tracks ------------------------------------------------|

1. Assume disk head is at position with h% number of tracks away from center of disk. That is, if the track number is N, disk head is at a position with n tracks away from center. And h=n/N %.

2. For any task in a position of x% of total tracks away from center, the disk head will take abs(h-x) of time

to reach it. The time of abs(h-x) is actually the major factor of latency.

3. Since the task is equally likely to be any position in the disk, we can use integral to calculate the latency

as following:  (Let's define S(exp, upper, lower)dx as integral(S) for expression(exp) from "lower" to "upper")

Latency(h) = S(h-x, 0, h)dx + S(x-h, h, 1)dx = h^2 - h +1/2

4. Now we want to integral for disk head along all tracks:

Latency in average = S(h^2 -h +1/2, 0, 1) = 1/3

Minimize DFA

> Blum(a German Prof.) Algorithm like Hopcroft Alg. :
>
> DFA-->DFA(min)
> Input: reduced DFA M = (Q,Sigma, delta, q0,F).
> Output: minimal DFA M´ = (Q´, Sigma, delta´,qo´,F´).
> Method:
>    (1)  t:=2; Q1:= F; Q2 := Q\F.
>   (2)  while there is i <= t, a <- Sigma
>         with delta(Qi, a) /<= Qj for all j <= t
>          do
>         1.  choose so one i <= t, a <-Sigma and j <= t
>              with delta(Qi, a) intersection Qj /= {}.
>         2.  Q(t+1) := {q <- Qi | delta (q, a) <- Qj};
>             Qi  := Qi\ Q(t+1);
>              t := t+1
>     od.
>  (3) Q´ : ={Q1,Q2,...,Qt};
>       q0´ := [q0];
>       F´:= {[q] <-Q´ |q <- F};
>      delta´( [q],a) := [delta(q,a)]
>      for all q <-Q, a<-Sigma.
>
 

Fascinating!!
Is this algorithm called Blum algorithm? I never heard aobut that. Maybe in
North America, they are called in different names. Anyway, the notation of
pseudo code puzzled me for a while and finally I thought I figured out,
please verify if it is the idea:
1. The first step is to separate DFA into two collections, one contains the
final state F and the other one is its complement.
2. Continual iterating with all collections to find any two collections A,B,
such that for any particular sigma character 'a', NOT all the arches of  'a'
from collection A goes to other collection B. (It means the states in
collection A have some arches of 'a' pointing to other collection other than
B. ) And we try to divide the collection A into two sub-collection such that
the states in A with arches with label 'a'  pointing to B is a new
sub-collection  C, and A - C is another collection.
3. Finally we got our reduced DFA such that the final states is the
collection of collections such that they contains original final state F.
The transition functions, or delta, or arches, are such that the domain is
the closure of states q, or those collections which contains q, and the
range is the closure of state delta(q,a), in other words, the collections
which contains state of
delta(q,a).

Is my understanding right?
 

My miserable life in Concordia...

#include <stdio.h>
#include <stdlib.h>
#include <setjmp.h>

typedef int Exception;

jmp_buf jumpBuf;

#define CourseNumber 4

#define E_chem205 1
#define E_comp326 2
#define E_comp444 3
#define E_stat250 4

char* courseName[CourseNumber]=
{
	"chem205", "comp326", "comp444", "stat250"
};

typedef  void CourseFunc(void);


void chem205();
void comp326();
void comp444();
void stat250();

//function pointer array
CourseFunc* myCourse[CourseNumber]=
{
	chem205, comp326, comp444, stat250
};


int main()
{
	int week,course;
	Exception exp;
	//I have to suffer 13 weeks for a term
	for (week=0; week<13; week++)
	{
		printf("****************\nnow it is week %d\n****************************\n", week+1);
		for (course=0; course<CourseNumber; course++)
		{
			myCourse[course]();
			if ((exp=setjmp(jumpBuf))!=0)
			{
				if (exp==E_comp444)
				{
					printf("I don't believe you, just quit\n");
					exit(E_comp444);
				}
				else
				{
					printf("I know you are suffering from %s,", courseName[exp-1]);
					printf("you still have to hold on\n*************************\n");
					//do nothing but continue
				}
			}
			
		}
	}
	return 0;
}


//there is 80% chance, I would complain----throw an expception for protest
void chem205()
{
	if (rand()%100<80)
	{
		printf("chemstry has too many compound name to memorize\n");
		printf("I want to throw an exception\n");
		longjmp(jumpBuf, E_chem205);
	}
	printf("I continue studying chem205\n");
}

//there is 60% chance, I would complain----throw an expception for protest
void stat250()
{
	if (rand()%100<60)
	{
		printf("statistic has too many integral caculus\n");
		printf("I want to throw an exception\n");
		longjmp(jumpBuf, E_stat250);
	}
	printf("I continue studying stat250\n");
}

//there is 90% chance, I would complain----throw an expception for protest
void comp326()
{
	if (rand()%100<90)
	{
		printf("computer architecture is really boring\n");
		printf("I want to throw an exception\n");
		longjmp(jumpBuf, E_comp326);
	}
	printf("I continue studying comp326\n");
}

//there is 10% chance, I would complain----throw an expception for protest
void comp444()
{
	if (rand()%100<10)
	{
		printf("system software design is exciting\n");
		printf("if I throw exception, I know I would quit all\n");
		longjmp(jumpBuf, E_comp444);
	}
	printf("I continue studying comp444 should I complain about anything?\n");
}	

****************
now it is week 1
****************************
I continue studying chem205
computer architecture is really boring
I want to throw an exception
I know you are suffering from comp326,you still have to hold on
*************************
I continue studying comp444 should I complain about anything?
statistic has too many integral caculus
I want to throw an exception
I know you are suffering from stat250,you still have to hold on
*************************
****************
now it is week 2
****************************
I continue studying chem205
computer architecture is really boring
I want to throw an exception
I know you are suffering from comp326,you still have to hold on
*************************
I continue studying comp444 should I complain about anything?
I continue studying stat250
****************
now it is week 3
****************************
chemstry has too many compound name to memorize
I want to throw an exception
I know you are suffering from chem205,you still have to hold on
*************************
computer architecture is really boring
I want to throw an exception
I know you are suffering from comp326,you still have to hold on
*************************
I continue studying comp444 should I complain about anything?
statistic has too many integral caculus
I want to throw an exception
I know you are suffering from stat250,you still have to hold on
*************************
****************
now it is week 4
****************************
I continue studying chem205
computer architecture is really boring
I want to throw an exception
I know you are suffering from comp326,you still have to hold on
*************************
I continue studying comp444 should I complain about anything?
statistic has too many integral caculus
I want to throw an exception
I know you are suffering from stat250,you still have to hold on
*************************
****************
now it is week 5
****************************
chemstry has too many compound name to memorize
I want to throw an exception
I know you are suffering from chem205,you still have to hold on
*************************
computer architecture is really boring
I want to throw an exception
I know you are suffering from comp326,you still have to hold on
*************************
I continue studying comp444 should I complain about anything?
statistic has too many integral caculus
I want to throw an exception
I know you are suffering from stat250,you still have to hold on
*************************
****************
now it is week 6
****************************
chemstry has too many compound name to memorize
I want to throw an exception
I know you are suffering from chem205,you still have to hold on
*************************
computer architecture is really boring
I want to throw an exception
I know you are suffering from comp326,you still have to hold on
*************************
I continue studying comp444 should I complain about anything?
statistic has too many integral caculus
I want to throw an exception
I know you are suffering from stat250,you still have to hold on
*************************
****************
now it is week 7
****************************
I continue studying chem205
computer architecture is really boring
I want to throw an exception
I know you are suffering from comp326,you still have to hold on
*************************
I continue studying comp444 should I complain about anything?
statistic has too many integral caculus
I want to throw an exception
I know you are suffering from stat250,you still have to hold on
*************************
****************
now it is week 8
****************************
chemstry has too many compound name to memorize
I want to throw an exception
I know you are suffering from chem205,you still have to hold on
*************************
computer architecture is really boring
I want to throw an exception
I know you are suffering from comp326,you still have to hold on
*************************
I continue studying comp444 should I complain about anything?
statistic has too many integral caculus
I want to throw an exception
I know you are suffering from stat250,you still have to hold on
*************************
****************
now it is week 9
****************************
chemstry has too many compound name to memorize
I want to throw an exception
I know you are suffering from chem205,you still have to hold on
*************************
computer architecture is really boring
I want to throw an exception
I know you are suffering from comp326,you still have to hold on
*************************
I continue studying comp444 should I complain about anything?
I continue studying stat250
****************
now it is week 10
****************************
I continue studying chem205
computer architecture is really boring
I want to throw an exception
I know you are suffering from comp326,you still have to hold on
*************************
I continue studying comp444 should I complain about anything?
statistic has too many integral caculus
I want to throw an exception
I know you are suffering from stat250,you still have to hold on
*************************
****************
now it is week 11
****************************
chemstry has too many compound name to memorize
I want to throw an exception
I know you are suffering from chem205,you still have to hold on
*************************
computer architecture is really boring
I want to throw an exception
I know you are suffering from comp326,you still have to hold on
*************************
I continue studying comp444 should I complain about anything?
statistic has too many integral caculus
I want to throw an exception
I know you are suffering from stat250,you still have to hold on
*************************
****************
now it is week 12
****************************
I continue studying chem205
computer architecture is really boring
I want to throw an exception
I know you are suffering from comp326,you still have to hold on
*************************
I continue studying comp444 should I complain about anything?
statistic has too many integral caculus
I want to throw an exception
I know you are suffering from stat250,you still have to hold on
*************************
****************
now it is week 13
****************************
chemstry has too many compound name to memorize
I want to throw an exception
I know you are suffering from chem205,you still have to hold on
*************************
computer architecture is really boring
I want to throw an exception
I know you are suffering from comp326,you still have to hold on
*************************
I continue studying comp444 should I complain about anything?
statistic has too many integral caculus
I want to throw an exception
I know you are suffering from stat250,you still have to hold on
*************************

How to convince myself that forked process share the file status table with parent process?

1. "exec.o" open a file and fork a child process. The child process then "exec" a new program "hello.o" which accept the file descriptor passed by

forked process as command line parameter. The new program then write more into the file referenced by the passed file descriptor.

2. In order to prove parent process and child process have the shared file status table, I asked parent process to write more lines after it forked a

child process. By doing this, the file offset should be different from the moment when it forked the child. But the child process write into file and the

content are seamless aligned. i.e. the file offset of both parent and child are exactly same.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>

int main(int argc, char* argv[])
{
	pid_t pid;
	int fd;
	int n=10;
	char buf[20];
	char nameBuf[30];
	char fileName[]="this is string buf";
	while (n>0)
	{
		sprintf(nameBuf, "tempParent%d", n);
		if (open(nameBuf, O_CREAT, S_IRUSR|S_IWUSR)<0)
		{
			printf("open error for parent\n");
		}
		n--;
	}

	if ((fd=open(argv[1], O_CREAT|O_WRONLY|O_SYNC|O_TRUNC,
		S_IRUSR|S_IWUSR|S_IRGRP))<0)
	{
		printf("open error,\n");
		exit(7);
	}
	//
	//printf("sizeof(%s)=%d\n", fileName, sizeof(fileName));
	if (write(fd, fileName, strlen(fileName))!=strlen(fileName))
	{
		printf("probably write error\n");
	}
	printf("fd is still %d\n", fd);
	if ((pid=fork())<0)
	{
		printf("fork error\n");
		exit(1);
	}
	if (pid==0)
	{
		sleep(5);
		//while (n>0)
		{
			printf("I am child and printing\n");
		}
		sprintf(buf, "%d", fd);
		//printf("argv[2]=%s\n", argv[2]);
		printf("argv[2]=%s and buf=%s\n", argv[2], buf);
		//only 
		//strcpy(nameBuf, "./");
		//strcat(nameBuf, argv[2]);
		n=4;
		while (n>0)
		{
			sprintf(nameBuf, "%s%d", "temp", n);
			if (open(nameBuf, O_CREAT, S_IRUSR|S_IWUSR)<0)
			{
				printf("open error\n");
			}
			n--;
		}
		if (execlp(argv[2], argv[2], buf, NULL)<0)
		{
			printf("exec error\n");
			exit(3);
		}
		printf("will you see this?\n");
	}
	else
	{
		printf("fd is still %d\n", fd);
		//printf("I am parent and I will write more while child is sleeping...\n");
		strcpy(buf, "some more from parent");
		printf("fd=%d, strlen(buf)=%d\n", fd, strlen(buf));
		if (write(fd, buf, strlen(buf))!=strlen(buf))
		{
			printf("write error from parent\n");
		}
		lseek(fd, 0, SEEK_SET);
		close(fd);	
		exit(0);
	}
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>

int main(int argc, char* argv[])
{
	int fd;
	char* string="this is child";
	printf("%s and argv[1]=%s\n", string, argv[1]);
	sscanf(argv[1], "%d", &fd);
	printf("fd=%d and string=%s", fd, string);
	printf("file offset is %d\n", lseek(fd, 0, SEEK_CUR));
	if (write(fd, string, strlen(string))!=strlen(string))
	{
		printf("error or write\n");
		exit(7);
	}
	return 0;
}

[root@sec05 mywork]# ./exec.o ./result.txt ./hello.o
fd is still 13
fd is still 13
fd=13, strlen(buf)=21
[root@sec05 mywork]# I am child and printing
argv[2]=./hello.o and buf=13
this is child and argv[1]=13
fd=13 and string=this is childfile offset is 0

This is what is inside file "result.txt". Pls note that by calling "lseek" in parent process, it causes child process overwrite contents written by parent.

this is childg bufsome more from parent

    To convince myself the signal works and also practice function pointers and pointer to function pointers

#include <signal.h>
#include <stdlib.h>

#define SigErr  (void(*)(int))-1
#define SigDef  (void(*)(int)) 0
#define SigUsr   (void(*)(int))1

void myHandler(int sigNo);
typedef void (*FuncPtr)(int);


FuncPtr regists(FuncPtr sigHandler, int sigNo);

typedef void (**FuncPtrPtr)(int); 

int main()
{
	//FuncPtrPtr ptr;
	FuncPtr* ptr;
	FuncPtr result;
	int n=0;
	
	result=regists(myHandler, SIGUSR1);
	ptr=&result;

	printf("result is 1:%d\n", result);
	//result(SIGUSR1);
	result=regists(myHandler, SIGUSR1);
	printf("register again and result should be my handler :%d\n", result);
	(*ptr)(SIGUSR1);
	//result(SIGUSR2);
	result=regists(myHandler, SIGUSR2);
	


	printf("pid=%d\n", getpid());
	for ( ; ; )
	{
		printf("no. %d\n", n);
		n++;
		pause();
	}
	return 0;
}

FuncPtr regists(FuncPtr sigHandler, int sigNo)
{
	FuncPtr result;
        if ((result=signal(sigNo, sigHandler))==SigDef)
        {
                printf("default handling\n");
        }
        else
        {       
                if (result==SigErr)
                {
                        printf("error of register\n");
                }
                else
                {
                        if (result==SigUsr)
                        {
                                printf("signal user\n");
                        }
                        else
                        {
				//should never be here
                                printf("lets see what handler is:%d\n", result);
                                result(sigNo);
                        }
                }  
        }
	return result;
}


void myHandler(int sigNo)
{
	printf("the signal is %d\n", sigNo);
}

The running result is like following:

[qingz_hu@alamanni ~/mywork] % gcc signal.c -o signal.exe
[qingz_hu@alamanni ~/mywork] % ./signal.exe
default handling
result is 1:0
lets see what handler is:134513992
the signal is 10
register again and result should be my handler :134513992
the signal is 10
default handling
pid=31720
no. 0

[qingz_hu@alamanni ~/mywork] %
[qingz_hu@alamanni ~/mywork] %
[qingz_hu@alamanni ~/mywork] %
[qingz_hu@alamanni ~/mywork] %
[qingz_hu@alamanni ~/mywork] %
[qingz_hu@alamanni ~/mywork] % clear
[qingz_hu@alamanni ~/mywork] % ./signal.exe &
[1] 31775
[qingz_hu@alamanni ~/mywork] % default handling
result is 1:0
lets see what handler is:134513992
the signal is 10
register again and result should be my handler :134513992
the signal is 10
default handling
pid=31775
no. 0

[qingz_hu@alamanni ~/mywork] % kill -USR1 31775
the signal is 10
no. 1
[qingz_hu@alamanni ~/mywork] % kill -USR2 31775
the signal is 12
no. 2
[qingz_hu@alamanni ~/mywork] % kill -USR1 31775
the signal is 10
no. 3
[qingz_hu@alamanni ~/mywork] % kill -USR2 31775
the signal is 12
no. 4
[qingz_hu@alamanni ~/mywork] % kill -20 31775

[1] + Suspended ./signal.exe
[qingz_hu@alamanni ~/mywork] %
 

The function pointer array is manipulated like this: Actually it puzzles me several hours by figuring out how to declare a function pointer of which the

return type is a function and the parameter includes a function pointer.

i.e. HandleType regists(int num, HandleType funcPtr);  is a declaration of this kind of function, but how to declare a type for this function.

I must admit it is extremely confusing for me to do this without "typedef" a HandleType first. (Actually I don't know how after many times trials.)

#include <stdlib.h>


typedef void (*HandleType)(int);

typedef HandleType  (*FuncPtr1)(int, HandleType);


HandleType regists(int num, HandleType funcPtr); 

void display();

void handler1(int num);
void handler2(int num);
void handler3(int num);
void handler4(int num);
void handler5(int num);

HandleType funcArray[5]=
{
	handler1, handler2, handler3, handler4, handler5
};

int main()
{
	FuncPtr1 ptr1;
	int i;
	//FuncPtr2 ptr2;
	HandleType result;
	printf("initial condition of funcArray\n");
	display();
	ptr1=regists;
	result=handler5;
	printf("let's register handler5 at the beginning and shift all\n");
	for (i=0; i<5; i++)
	{
		result=ptr1(i, result);
	}
	printf("after register, it should be like round robin\n");
	display();
	return 0;
}
	

void handler1(int num)
{
	printf("This is handler 1 and handling %d\n", num);
}

void handler2(int num)
{
	printf("This is handler 2 and handling %d\n", num);
}

void handler3(int num)
{
	printf("This is handler 3 and handling %d\n", num);
}

void handler4(int num)
{
	printf("This is handler 4 and handling %d\n", num);
}

void handler5(int num)
{
	printf("This is handler 5 and handling %d\n", num);
}

void display()
{
	int i;
	for (i=0; i<5; i++)
	{
		funcArray[i](i);
	}
}

HandleType regists(int num, HandleType funcPtr)
{
	HandleType result;
	printf("this is a function takes parameter of integer and a function pointer\n");
	printf("it also returns a function pointer\n");
	result=funcArray[num];
	funcArray[num]=funcPtr;
	return result;	
}

This is the running result:

[qingz_hu@alamanni ~/mywork] % ./funcptr.exe
initial condition of funcArray
This is handler 1 and handler handling 0
This is handler 2 and handler handling 1
This is handler 3 and handler handling 2
This is handler 4 and handler handling 3
This is handler 5 and handler handling 4
this is a function takes parameter of integer and a function pointer
it also returns a function pointer
this is a function takes parameter of integer and a function pointer
it also returns a function pointer
this is a function takes parameter of integer and a function pointer
it also returns a function pointer
this is a function takes parameter of integer and a function pointer
it also returns a function pointer
this is a function takes parameter of integer and a function pointer
it also returns a function pointer
after register, it should be like round robin
This is handler 5 and handler handling 0
This is handler 1 and handler handling 1
This is handler 2 and handler handling 2
This is handler 3 and handler handling 3
This is handler 4 and handler handling 4

bad programming habit

memory address space

pre-emptable and interruptable?

My second assignment:

Questions:

1. File permission bits are generally easy to understand. However, directory
permissions are a little less intuitive. Explain how the executable bit is used
for directories and why it is different than the read bit.
2. When we open a file, we have the option of specifying the O_SYNC flag. We
can also obtain synchronization functionality by using the sync system call.
What is the difference between the two and what effect do they have on the
data located in the C library buffers. Explain.
3. The chdir system call can be used to modify the current working directory.
Say that we use chdir within a program to move to a completely new
directory. Our program then creates another process (say with fork) that
shares the same cwd. After our program terminates, however, and we get our
command prompt back, we’re still in the same directory that we were in
before we ran our program. Why does this happen?
4. With respect to the standard C libraries, explain how it is possible to do a lineoriented
write (e.g., fputs) that does not cause a line of data to be sent to the
kernel.
5. We saw with fopen that this C library call invokes the system call open (and
adds some extra functionality). Now, the OS provides a positioning function
called lseek. The C libraries provide a positioning function called fseek. So is
fseek a wrapper for lseek or is it possible to invoke fseek without lseek ever
being called?

6. There are two types of libraries: static and shared. The book suggests that
shared libraries make our executables smaller. Let’s say that the standard C
libraries could be compiled as either static or shared libraries. With respect to
the diagram on page 168 (the process space), explain the effect of using the
static version versus the shared version.
7. We said that the file system tries to ensure that directory inodes are spread
more or less evenly across block groups. This sounds nice but, really, why is
it useful?
8. Let’s say that we are using an ext2 file system that uses a block size of 1024
bytes. We create a file that contains 856,000 bytes. How will the file’s inode
keep track of these blocks? Be specific here and show the math.
9. I have just purchased a new hard disk that holds 80 GB of data and I have set
up a partition that is 30 GB in size. I install the ext2fs in this partition,
specifying a block size of 2048 bytes. What is the maximum number of data
blocks that I can store in a block group with this configuration?

1. If only the “read” bit is set for a directory, then it can only be listed with the file names contained in the directory. (i.e. “ls directory-name”. And even the switch “-l” cannot be added since only the name of “dirent” can be retrieved. In order to retrieve more information like access time, size etc, the directory needs to be “executed” by some system call like “stat” etc.) Without setting the “execution bit”, all the files inside the directory cannot be executed and even the directory itself cannot be executed. Then we cannot open any file and even cannot list detailed information of contained files in directory.
2. By specifying “O_SYNC” flag, every write call will only return until all data are written to O.S. I/O buffer and this is an atomic operation compared with invoking “sync” system call. i.e. Between “write” call and “sync”, there maybe context switch happened between processes and with flag “O_SYNC” this won’t happen. System calls like “write”, “read” are un-buffered call and they don’t use C library buffer. Instead they write directly into system I/O buffer. There is no direct relation between system call and C library buffer except that usually C library file API uses system calls for implementation. So, when C library function like “fread”, “fwrite” is called, internally system call like “read” and “write” is often called and C library buffer may be read and written.
3. Our current working directory is one of environment parameter recorded in system data file, i.e. “passwd” file. And the shell always direct user to its “CWD” in user prompt. So, even in the program, “chdir” is called, after the program finishes, the shell will still retrieve user’s current working directory information from environment parameter file and direct user prompt into its CWD indicated by environment parameter.   
4. In C library there is an internal buffer to hold data ready to be written into operating system I/O buffer. Usually this buffer has a fairly large size compared with length of a common line, say with size of 256. Therefore when “fputs” is called, say a line of string shorter than size of buffer is written into this internal buffer. As long as the buffer is not full, C library will not flush contents in buffer to system I/O buffer.
5. In C library, a structure called FILE is used to maintain file-related information. One of its fields is used to record current offset of file operation. Therefore when “fseek” is called, C library just calculates the offset field of FILE structure without invoking “lseek” call. i.e. when user want to forward n bytes from current position, library just call “read” (n/buffer_size +1) times to read contents into internal buffer. More possibly when the number of bytes user wants to move is smaller than size of internal buffer, C library just modify the current pointer pointing to the position of internal buffer without making any system call.
6. When we use static linking to compile our executable file, compiler will compile all functions and variables in library into our executable file. That is to say, when the program is loaded into memory the code in library will also be part of “text”, “initialized” ,“uninitialized” segment since these functions and variables are treated no difference from other codes. Of course when program is running, those library functions are also part of stack frame of process in the “stack” segment. The function and variables in library are also part of memory space in our program. Therefore the size of run-time process is much large. In contrast, when we use dynamic linking, the functions in library will be represented only as external symbol which will only be linked and resolved at run-time by dynamic loading and linking done by operating system. Since functions and variables in library will ONLY be symbols in “text” segment in executable files when stored in disk and memory pointers resolved by loader_and_linker when program is loaded into memory, the size of executable is much smaller compared with static linking. At run-time, functions and variables in library are not even located in memory space of process. i.e. Their address is not treated as relative offset from beginning address of our program module. So the size of run-time is also reduced.
7. This is to make file access performance better. When users access directory, their real purpose is to try to access files contained in directory or retrieve information of those files, i.e., read, write contents in file or browse information like size, access time of files. By “principle of locality”, if directory and files in it are located in same block group, the O.S. can achieve a better performance in a sense that I/O operation is quite a time-consuming operation. In order to allow directory and its containing files in same block groups, it is necessary for file system NOT to store directories’ inodes into one particular block group. Otherwise when number of files contained in each directory increases, one block group will be unable to hold those data blocks and inodes of new files. Therefore to cope with increase of number of files in each directory, file system usually needs to allocate directory inodes averagely across whole block groups.
8. In the inode of a file, there is one field called data block pointer which consists of 15 data block pointers. The first 12 of them are direct pointers of which each points to one data block. The rest 3 of them are indirect, double indirect and triple indirect pointers.

Number of pointers in one block: 1024 / 4 = 256(pointers/block)

a)  856000/1024=835.9(blocks)   //it exceeds 12 direct pointers

b)  (836-12)/256 = 3.22 >1     //it exceeds indirect pointer

c)  (836-12-256) /256 = 2.2 <256    //it falls within double indirect pointer

As shown above, 12 direct pointer and indirect and double indirect pointer are used to bookkeeping total 836 data blocks. Assuming the index of data block starts from 0, when the index of data block is smaller than 12, the index of block is the index of direct data pointer. When the index of block is within range between 12 and 12+256-1=267, the address is in the pointer block pointed by indirect data block pointer. When index of block is in range between 268 and 836, the address of data block can be retrieved by following double indirect data block pointer.

  9.  30G/2K/(2K x 8) = 960(blocks)

    Signal!Signal!!Signal!!!

#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <time.h>
int count=0;
int signalCount=0;
void handler(int no);

void childCount(int no);

const int ChildNumber=10;
int main()
{
	int i;
	pid_t pid;
	srand(time(0));
	if (signal(SIGUSR1, handler)==SIG_ERR)
	{
		printf("error of signal\n");
	}
	if (signal(SIGCHLD, childCount)==SIG_ERR)
	{
		printf("error of signal\n");
	}		
	for (i=ChildNumber; i>0; i--)
	{
		if ((pid=fork())==0)
		{
			sleep(i);
			i=rand()%i;
			printf("child %d sends signal %d times\n", getpid(), i);
			while(i>0)
			{
				kill(getppid(), SIGUSR1);
				i--;
			}
			exit(0);
		}
	}
	sleep(ChildNumber);
	while (count<ChildNumber)
	{
		pause();
	}
	return 0;

}

void childCount(int no)
{
	count++;
	printf("%d child dies\n", count);
}


void handler(int no)
{
	signalCount++;
	printf("user1 signal number %d\n", signalCount);
}

This is the running result when redirected to a file:

child 32303 sends signal 0 times
child 32302 sends signal 1 times
child 32301 sends signal 0 times
child 32300 sends signal 3 times
child 32299 sends signal 1 times
child 32298 sends signal 3 times
child 32297 sends signal 2 times
child 32296 sends signal 7 times
child 32295 sends signal 0 times
child 32294 sends signal 1 times
1 child dies
user1 signal number 1
2 child dies
3 child dies
user1 signal number 2
4 child dies
user1 signal number 3
5 child dies
user1 signal number 4
6 child dies
user1 signal number 5
7 child dies
user1 signal number 6
user1 signal number 7
user1 signal number 8
8 child dies
9 child dies
user1 signal number 9
10 child dies
 

This is the running result when executed from command line. The display has some subtle difference, but the big picture is similar:

child 32463 sends signal 0 times

1 child dies

child 32462 sends signal 1 times

user1 signal number 1

2 child dies

user1 signal number 1

child 32461 sends signal 0 times

3 child dies

child 32460 sends signal 1 times

user1 signal number 2

4 child dies

user1 signal number 2

child 32459 sends signal 4 times

user1 signal number 3

5 child dies

user1 signal number 3

child 32458 sends signal 3 times

user1 signal number 4

6 child dies

user1 signal number 4

child 32457 sends signal 4 times

user1 signal number 5

7 child dies

user1 signal number 5

child 32456 sends signal 5 times

user1 signal number 6

8 child dies

user1 signal number 6

child 32455 sends signal 6 times

user1 signal number 7

9 child dies

user1 signal number 7

child 32454 sends signal 9 times

user1 signal number 8

10 child dies

user1 signal number 8

The behaviour of  sigsuspend(sigset_t*) (A personal reminder)

1. When you fork a new child, the child inherits the signal mask except signal handler. This makes senses since signal handler is just a function existing in parent address space.

2. No matter whatever signal you block, signal mask will be reset by parameter of sigsuspend(sigset_t*). This is stated very clearly, but I simply didn't get it or believe it until I tried by myself.

3. When sigsuspend() is interrupted, it catches some signal which is not in the block list and reset block-mask to original one.

#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdio.h>

const int LineSize=1024*1024;
#define  BlockSize 16
char* outname="out.txt";
const int Permission=S_IRUSR|S_IWUSR|S_IRGRP;
char block[BlockSize]={0};
int fds[2];

int main(int argc, char* argv[])
{
	pid_t pid;
	char buf[LineSize];
	int fdin, fdout, i=0, n=0;
	char msg[20];
	if (pipe(fds)<0)
	{
		printf("pipe error\n");
	}
	
        if ((fdout=open(outname, O_WRONLY|O_CREAT, Permission))==-1)
        {
                printf("write open error\n");
        }
	//initialize buf to be full of number of blocks...
	while (n<LineSize/BlockSize)
	{
		sprintf(block, "no.%d\n", n+1);
		i=strlen(block);
		//just pad space after number
		while (i!=BlockSize-1)
		{
			block[i]=' ';
			i++;
		}
		block[BlockSize-1]='\n';
		
		strcpy(buf+n*BlockSize, block);
		n++;
	}
		
		
	if ((pid=fork())==0)
	{
		while ((n=read(fds[0], buf, LineSize))>0)
		{
			if (write(fdout, buf, n)!=n)
			{
				printf("write to output error\n");
			}
			sprintf(msg, "child read %d\n", n);
			if (write(STDOUT_FILENO, msg, strlen(msg))!=strlen(msg))
			{
				printf("display error\n");
			}		
		}
	}
	else
	{
		if (write(fds[1], buf, LineSize)!=LineSize)
		{
			printf("write error\n");			
		}
	}
	return 0;
}
	

And this is for my personal reminder of debugging for another running process by using "attach" in GDB

1. When the other process ID is available either by tracing or without tracing, you can attach the process by using GDB -p [pid] [exefile].

2. It is wrong to kill the debugged process within GDB because it may closes all processes including children. Instead you should open another GDB process and debug over there. GDB is magic! 

The reason for you to link "math" library is the same as "pthread". But recall that usually gcc should give "unresolved function" after linking if the implementation of a function used is not supplied. However, when you compile program which uses functions from "math.h" or "pthread.h", gcc just finishes fine without giving linking error. But the program won't run. There is two questions here. 1. Why no error is given in compiling stage? 2. Why should you have to link them by yourself?

The second question is easy since I guess these libraries are platform-specific. That is to say, different platform have its own implementation and the best way to deal with this problem is to make these library dynamic library so that these library interface can be made uniformal in different platform. But the first question I have no clue at all. I guess there must be some compiler directive suppressing gcc to link functions in dynamic library. But I don't know what it is or whether this is the answer. I noticed there is a key word "__THROW" at end of each pthread function. Is it the one? I think it is not since in "math.h" I didn't find similar one.

Playing with pointers...(The following stuff is purely for personal reminder. It may contain contents of ambiguity and incorrectness. View's discretion is suggested.)

Look at code following and do you really understand "pass-by-pointer"? I think I do, but I don't.

1. All variable is just an alias of memory address.

2. Pass-by-pointer just passes the address and see following prototype: void foo(char* ptr);

int main()

{

	char* onlyPtr;

	foo(onlyPtr);//here you pass a wild pointer and you are lucky if program crashes.

}

3. What compiler does is to create a temporary variable of char* which has the same value of your parameter.

i.e.    char myCh;

	foo(&myCh); //a temporary char* variable created to have value of &myCh which is an address of itself.

4. What should I say about this simple question? I sometimes boast myself as a decent C/C++ programmer whose basic

instinct is the handling of pointers. However, I found out I was confused a bit with "passing-by-pointer" mode.

Let's keep one simple thing in our mind because all others are not absolutely necessary:

There is ONE AND ONLY ONE MODE IN C, "passing-by-value", nothing more and nothing less.

5. Pay attention that a memory address is passed to the function and you can manage with the address whatever you 

like to do. When the function returns, you can retrieve the address stored in the contents in the address. I can

even pass the address of an integer which happens to have same length of an address, based on current 32bit address

architecture.

#include <stdlib.h>
 
#define PtrSize sizeof(char*)
char* createBuf(char* ptr);

int main()
{
        char* array;
        char ptr[PtrSize];
        char*temp=NULL;   
        array=createBuf(ptr);
        printf("malloc contents : %s\n", array);
        //temp=(char*)(*ptr);
        //strncpy(temp, *((char**)ptr), sizeof(char*));
        printf("and from ptr is %s\n",*((char**)ptr)); 
        
        return 0;
}
        
char* createBuf(char* ptr)
{
        char* buf;
        int i;
        buf=(char*) malloc(500*sizeof(char));
        for (i=0; i<26; i++)
        {
                buf[i]='a'+i;
        }
        buf[i]='\0';
        *((char**)ptr)=buf;
        return buf;
}
        

synchronization---revisited

Actually there is little new about this synchronization test except that I am now using Linux pthread library with conditional variable instead of busy-waiting-style of polling. It is almost exactly a re-make of Dr. Probst array increment in comp346. Now I begin to understand some of his lectures. I really regret what I commented on him before. He is a good professor and I am stupid at that time since my view was as narrow as what I could see.

Conditional waiting is really a big leap from "polling-style" busy waiting and there is one thing worth bearing in mind: you need to unlock the mutex when you exit the conditional variable because "pthread_cond_wait" implicitly acquires the mutex for you and it is always your job to unlock it. Another small issue is that you would be better to call "pthread_cond_broadcast" instead of "pthread_cond_signal" unless you are sure about the sequence of how waiting threads are woken up.

#include <pthread.h>
#include <stdlib.h>
#include <sys/types.h>
#include <time.h>
#define Max_Threads 10

pthread_t threads[Max_Threads];

pthread_cond_t cond=PTHREAD_COND_INITIALIZER;

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;

int array[Max_Threads]={0,1,2,3,4,5,6,7,8,9};

int sequence[Max_Threads]={0,1,2,3,4,5,6,7,8,9};

void* func(void* arg);

void printArray();

void randomSequence();

int main()
{
	int i, *value;
	srand(time(0));
	printArray();
	randomSequence();
	for (i=0; i<Max_Threads; i++)
	{
		if (pthread_create(&threads[sequence[i]], NULL, func,&sequence[i]))
		{
			printf("create error\n");
		}
		else
		{
			printf("threas[%d] is created\n", sequence[i]);
		}
	}
	for (i=0; i<Max_Threads; i++)
	{
		if (pthread_join(threads[i], (void**)(&value)))
		{
			printf("join error");
		}
		printf("thread no.%d return with value=%d\n", i,*value);
	}
	printf("let me show you the array\n");
	printArray();
}

void randomSequence()
{
	int i,j, hold;
	for (i=0; i<Max_Threads; i++)
	{
		j=rand()%10;
		hold=sequence[i];
		sequence[i]=sequence[j];
		sequence[j]=hold;
	}
}

void printArray()
{
	int i;
	for (i=0; i<Max_Threads; i++)
	{
		printf("array[%d]=%d,", i, array[i]);
	}
	printf("\n");
}


void* func(void* arg)
{
	int index;
	index=*((int*)arg);
	if (pthread_mutex_lock(&mutex))
	{
		printf("mutex lock error");
	}
	if (index==0)
	{
		array[index]++;
		printf("threads[0] finished\n");
		if (pthread_cond_broadcast(&cond))
		{
			printf("cond signal error");
		}
		if (pthread_mutex_unlock(&mutex))
		{
			printf("unlock eeeror");
		}
	}
	else
	{
		while (array[index-1]!=index)
		{
			if (pthread_cond_wait(&cond, &mutex))
			{
				printf("cond lock error\n");
			}
		}
		array[index]++;
		printf("threads[%d] finishes job\n", index);
		if (pthread_cond_broadcast(&cond))
		{
			printf("cond error");
		}
		if (pthread_mutex_unlock(&mutex))
		{
			printf("unlock eeeror");
		}
	}
	return &array[index];
}	
	
	

array[0]=0,array[1]=1,array[2]=2,array[3]=3,array[4]=4,array[5]=5,array[6]=6,array[7]=7,array[8]=8,array[9]=9,
threas[3] is created
threas[1] is created
threas[6] is created
threas[4] is created
threas[0] is created
threads[0] finished
threads[1] finishes job
threas[9] is created
threas[7] is created
threas[8] is created
threas[2] is created
threads[2] finishes job
threads[3] finishes job
threas[5] is created
threads[4] finishes job
thread no.0 return with value=1
threads[5] finishes job
thread no.1 return with value=2
thread no.2 return with value=3
thread no.3 return with value=4
thread no.4 return with value=5
threads[6] finishes job
threads[7] finishes job
threads[8] finishes job
thread no.5 return with value=6
thread no.6 return with value=7
threads[9] finishes job
thread no.7 return with value=8
thread no.8 return with value=9
thread no.9 return with value=10
let me show you the array
array[0]=1,array[1]=2,array[2]=3,array[3]=4,array[4]=5,array[5]=6,array[6]=7,array[7]=8,array[8]=9,array[9]=10,
 

My conclusion for above puzzle:

I developed my own theory to explain above like this: 1. In "unix" which is actually "soloris" it is "hybrid" model. It means the kernel thread support unlimited user thread like "thread-pool". Thereby I don't have any "kernel-aware" thread number limit in Unix. Whereas in Linux, it is "one-to-one" model and I do have a number limit for creating threads.

I write all following testing program in a rather random style. Sometimes I just want to confirm a single idea which seems to be so trivial for most of us. And of course most of them have a rather blurred purpose and even cannot be understood by myself afterwards.

1. Broadcast test: I want to confirm that pthread_cond_broad only wakes up those threads who already associated with the conditional variable. (This is insane! Because it is already stated very clearly both in manual page and textbook. However, I give it a try.)

Also I practice the idea of multiple condition which I have an impression of being discussed by Dr. Probst. I didn't have a ready mind at that time.

#include <pthread.h>
#include <stdlib.h>


#define ThreadNumber 16

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t evencond=PTHREAD_COND_INITIALIZER, oddcond=PTHREAD_COND_INITIALIZER;
int choice=-1;
int counter;

void initialize();

void* run(void* arg);

int main()
{
	initialize();
	printf("sleep(2)\n");
	sleep(2);
	choice=getpid()%2;
	printf("choice=%d\n", choice);
	if (choice%2==0)
	{
		if (pthread_cond_signal(&oddcond))
		{
			perror("signal error from main");
		}			
	}
	else
	{
		if (pthread_cond_signal(&evencond))
		{
			perror("signal error from main");
		}
	}
	sleep(2);		
	return 0;
}

void* run(void* arg)
{
	//while (1)
	{
		if (pthread_mutex_lock(&mutex))
		{
			perror("mutex error");
		}
		while (choice<0)
		{
			if ((int)arg%2==0)//even
			{
				if (pthread_cond_wait(&evencond, &mutex))
				{
					perror("cond lock error");
				}
			}
			else
			{
				if (pthread_cond_wait(&oddcond, &mutex))
				{
					perror("cond error");
				}
			}
		}
		while (choice!=(int)arg%2)
		{
			printf("thread#%d is running\n", (int)arg);
			if ((int)arg%2==0)
			{
				if (pthread_cond_broadcast(&oddcond))
				{
					perror("broadcast error");
				}
				if (pthread_cond_wait(&evencond, &mutex))
				{
					perror("cond error");
				}
			}
			else
			{
				if (pthread_cond_broadcast(&evencond))
				{
					perror("broadcast error");
				}
				if (pthread_cond_wait(&oddcond, &mutex))
				{
					perror("cond error");
				}
			}
		}
		if ((int)arg%2==0)
		{
			if (pthread_cond_signal(&evencond))
			{
				perror("signal error");
			}
		}
		else
		{
			if (pthread_cond_signal(&oddcond))
			{
				perror("signal error");
			}
		}
		printf("thread#%d is finished\n", (int)arg);
		if (pthread_mutex_unlock(&mutex))
		{
			perror("mutex unlock error");
		}
		
	}
}

void initialize()
{
	int i;
	pthread_t tid;
	for (i=0; i<ThreadNumber; i++)
	{
		if (pthread_create(&tid, NULL, run, (void*)i))
		{
			perror("create error");
		}
	}
}

2. write test: In this little weird test, I want to run multiple process which has no relation at all. (i.e. not by fork) And ask them to write to same file with different contents at almost same time. Obviously the file can only be a mess.

#include <stdlib.h>
#include <signal.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>

#define BufferSize 1024
#define WriteNumber 16
#define WriteSize BufferSize/WriteNumber

char buf[BufferSize];

void initialize(char ch);
void handler(int no);

int fd, count=0;

int main(int argc, char* argv[])
{
	sigset_t maskset, zeroset;
	sigemptyset(&zeroset);
	sigemptyset(&maskset);
	sigaddset(&maskset, SIGUSR1);
	
	if (argc!=3)
	{
		printf("usage: writetest.exe filename contents");
		exit(0);
	}
	initialize(argv[2][0]);
	if (sigprocmask(SIG_BLOCK, &maskset, NULL)<0)
	{
		perror("sigprocmask error");
	}
	if ((fd=open(argv[1], O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR|S_IXUSR))<0)
	{
		perror("open error");
	}
	if (lseek(fd, 0, SEEK_SET)<0)
	{
		perror("lseek error");
	}
	if (signal(SIGUSR1, handler)==SIG_ERR)
	{
		perror("signal error");
	}
	while (count<WriteNumber)
	{
		sigsuspend(&zeroset);
	}
	return 0;
}

void handler(int no)
{
	if (write(fd, buf+count*WriteSize, WriteSize)!=WriteSize)
	{
		perror("write error");
	}
	else
	{
		count++;
	}
}

void initialize(char ch)
{
	int i;
	for (i=0; i<BufferSize; i++)
	{
		buf[i]=ch+i%10;
	}
}

The above program takes two parameters: file name and symbols to be written into file.

The following is the running script:

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <errno.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>

#define BufferSize 512

char buf[BufferSize];

void initialize(char* fileName);
void handler(int no);

int fd;

int main(int argc, char* argv[])
{
	if (argc!=2)
	{
		printf("usage: question8.exe filename\n");
		exit(0);
	}
	initialize(argv[1]);
	return 0;
}


void initialize(char* fileName)
{
	int i;
	pid_t pid;
	char* ptr;
	char endChar=' ';
	if ((fd=open(fileName, O_RDWR|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR))<0)
	{
		perror("open error\n");
	}
	if ((pid=fork())==0)
	{
		for (i=0; i<BufferSize; i++)
		{
			buf[i]='0'+i%10;
		}
		if (signal(SIGUSR1, handler)==SIG_ERR)
		{
			perror("signal error\n");
		}
		pause();
	}
	else
	{
		for (i=0; i<BufferSize; i++)
		{
			buf[i]='A'+i%10;
		}

		if (lseek(fd, BufferSize-1, SEEK_SET)<0)
		{
			perror("lseek error");
		}
		if (write(fd, &endChar, 1)!=1)
		{
			perror("write end of file error\n");
		}
		if (lseek(fd, 0, SEEK_SET)<0)
		{
			perror("seek error\n");
		}	
		if ((ptr=mmap(0, BufferSize, PROT_WRITE, MAP_SHARED, fd, 0))==(caddr_t)(-1))
		{
			perror("map error\n");
		}
		sleep(1);
		if (kill(pid, SIGUSR1)<0)
		{
			perror("kill error");
		}
		memcpy(ptr, buf, BufferSize);
		munmap(ptr, BufferSize);
		if (wait(&i)<0)
		{
			perror("wait error\n");
		}
	}
}

void handler(int no)
{
	if (write(fd, buf, BufferSize)!=BufferSize)
	{
		perror("sys write error\n");
	}
}	

#include <stdlib.h>
#include <signal.h>
#include <errno.h>

void handle(int no);

int main()
{
	int no;
	pid_t pid;
	for (pid=1; pid<65534; pid++)
	{
		if (kill(pid, SIGKILL)<0)
		{
			perror("won't work\n");
		}
		else
		{

			for (no=0; no<64; no++)
			{
				if (signal(no, handle)==SIG_ERR)
				{
					perror("signal error\n");
				}
			}
		}
	}
	printf("I am alive\n");
	sleep(1);
	if (atexit(main))
	{
		perror("atexit error");
	}
	return 0;
}


void handle(int no)
{
	abort();
}

	 signal is essentially bitmap and counting won't guarantee for all children's SIGCHLD signal

#include <signal.h>
#include <sys/types.h>
#include <stdlib.h>

void handler(int no);

int main()
{
	int i;
	if (signal(SIGCHLD,handler)==SIG_ERR)
	{
		printf("signal error");
	}
	for (i=0; i<10; i++)
	{
		if (fork()==0)
		{
			while (1)
			{
				printf("child %d sleep %d and dies\n", getpid(), 1);
				sleep(1);
				//if (i%2==0)
				{
					exit(i);
				}
			}		
		}
	}
	while (1)
	{
		sleep(5);
	}
	return 0;
}



void handler(int no)
{
	pid_t pid;
	int status;
	if ((pid=wait(&status))<0)
	{
		printf("wait error");
	}
	else
	{
		printf("child %d dies with status of %d\n", pid, status);
	}
}
		

The difference need to be made between c and c++