Fork Infinite Loop - c

Question

I am trying to make an directory monitoring program in C. So far it detects the subdirectories of a main directory, however the problem happens when I try to monitor the subdirectories of the subdirectories.
char * const son[] = { argv[0], name, NULL };
pid_t pid = fork();
if (pid == 0) {
execvp(son[0], son);
}
This code should have created a child process which would monitor the subdirectories. name is a string with the subdirectory "Desktop/test", for example.
I tried to print "name" before and it is the subdirectory I want so the problem isn't here.
The program works flawlessly until I add this. Once I add it, it enters an infinite loop, despite working previously. I also want to point out I don't use signals so the problem doesn't come from them.
This of course is just an excerpt of he code. If you think I need to post the full code, which is much bigger, I will add it, although honestly I doubt the problem is in it since it worked perfectly before.
EDIT:
Better add all the code, argv[1] is the directory,argv[2] for how many minutes I want the program to run, argv[3], it's the pause between each scan. It works if I remove the excerpt above and I know it's a bit confusing but if you have any questions just say.
int main(int argc, char *argv[]) {
char** direc;
int direct_pos = 0;
direc = (char**) malloc(2 * sizeof(char*));
double actual_time = 0;
double MAXTIME = atof(argv[2]);
MAXTIME = MAXTIME * 60;
double IterationTime = atof(argv[3]);
time_t start = time(0);
char dot2[100];
char dot[100];
sprintf(dot, "%s/.", argv[1]);
sprintf(dot2, "%s/..", argv[1]);
direct_pos++;
direc[direct_pos - 1] = (char*) malloc(strlen(dot) * sizeof(char));
strcpy(direc[direct_pos - 1], dot);
direct_pos++;
direc[direct_pos - 1] = (char*) malloc(strlen(dot2) * sizeof(char));
strcpy(direc[direct_pos - 1], dot2);
if (argc != 4) {
fprintf(stderr, "Usage: %s dir_name\n", argv[0]);
exit(1);
}
while (actual_time < MAXTIME) {
DIR *dirp;
if ((dirp = opendir(argv[1])) == NULL) {
perror(argv[1]);
exit(2);
}
struct stat stat_buf;
struct dirent *direntp;
while ((direntp = readdir(dirp)) != NULL) {
char name[100];
sprintf(name, "%s/%s", argv[1], direntp->d_name);
if (lstat(name, &stat_buf) == -1)
{
perror("lstat ERROR");
exit(3);
}
if (S_ISDIR(stat_buf.st_mode))
{
int x;
for (x = 0; x <= direct_pos; x++) {
if (x == direct_pos) {
char**newarray;
newarray = (char**) malloc((direct_pos + 1)* sizeof(char*));
int l;
for (l = 0; l < direct_pos; l++) {
//printf("\nxxxx%d\n", sizeof(direc[l]));
newarray[l] = (char*) malloc((strlen(direc[l])+1)
* sizeof(char));
strcpy(newarray[l], direc[l]);
}
direc = newarray;
direc[direct_pos] = (char*) malloc(sizeof(name)
* sizeof(char));
direc[direct_pos] = strcpy(direc[direct_pos], name);
direct_pos++;
double seconds_since_start = difftime(time(0), start);
double new_time = (MAXTIME - seconds_since_start) / 60;
char time_array[10];
sprintf(time_array,"%f",new_time);
char * const son[] = { argv[0], name, time_array,
argv[3], NULL };
printf("\n%s\n",son[1]);
x = direct_pos + 2;
pid_t pid = fork();
if (pid == 0) {
execvp(son[0], son)==-1);
break;
}
} else if (strcmp(name, direc[x]) == 0) {
x = direct_pos + 2;
}
}
}
}
sleep(IterationTime);
actual_time += IterationTime;
closedir(dirp);
}
exit(0);
}

Answer 1

You have a program that forks and then runs a new copy of itself. Think of it as endless recursion. There's no need to exec a new instance, simply write your code so that the program continues down one of two paths depending on the returned process ID.
But that's not the correct solution.
The correct solution is not to fork at all. You gain almost no benefit from having a thousand processes that look at one directory, versus a single process that looks at a thousand directories. Actually, you may be far worse, by putting load on the scheduler.

Answer 2

It looks like you always fork no matter what. I would put a check in there to make sure that if you have no subdirectories in the current directory that you don't fork.

Answer 3

You are forking a child-process, but what does the parent process do after the call to fork()? It seems you are wanting to recursively fork processes, but in order for that to work properly, you will have to-do the following:
1) Check to see if there are any sub-directories in the current directory ... if there aren't any, then exit(), otherwise read all the sub-directories in the current directory.
2) For each sub-directory fork a process. If the fork is the child (i.e., pid == 0), then make a call to execvp().
3) If pid != 0, then you're in the parent process. Rather than trying to sleep for some period of time, make a call to wait(), and keep on repeating the call to wait() until there are no child processes left.
4) Once there are no child-processes left (i.e., wait() returns an error status such that errno == ECHILD), then you can make a call to exit() in the parent process.
So if you follow those 4 steps, you should not incurr any infinite loops. Every child process will at some point exit once they reach a directory with no more sub-directories, and every parent will wait for it's children before exiting so you won't end up with any orphaned processes. If you do end up with an infinite loop, then it's because a child process is not exiting, which would then point to the logic used to detect if there are any sub-directories in the current directory, or you're not properly detecting that there are no longer any child left to wait for in a parent process.
Hope this helps,
Jason