C程序的Bizzare打印-Linux终端

Question

I am making a program to experiment with forking and signals in C and Linux environment.

The program creates many child processes with various ways, and each process prints a specific message at its beginning and at its end, while most of them create children themselves. Parents always wait for all their children before they terminate, and also sleep for a fixed amount of time before they terminate and after their children terminate.

So I execute the program, and in the terminal, some messages are printed right away, but then the insert prompt of the terminal appears, as if the program has terminated and the terminal is ready to accept further commands, but the program being executed proceeds to print the rest of the messages AFTER that point.

I am able to write any new commands right after the last message printed by the program, without any new prompt appearing. What might be causing that?

EDIT:Problem found - I need to add the following code at the end of 'if' branch in'main':

else{
    int status;
    waitpid(id,&status,0)
}  

The terminal output (an example) :

user@oslab:~/workspace/Ex2.1 $ ./a.out ./forktree/proc.tree                                                                       
Hello I am process A and I just got forked by DAD!
Hello I am process B and I just got forked from A!
Hello I am process C and I just got forked from A!
Hello I am process D and I just got forked from A!
Hello I am process E and I just got forked from B!
Hello I am process F and I just got forked from B!
user@oslab:~/workspace/Ex2.1 $ I am process C, I finished creating 0 children, and now I am exiting.Farewell!
I am process D, I finished creating 0 children, and now I am exiting.Farewell!
I am process E, I finished creating 0 children, and now I am exiting.Farewell!
I am process F, I finished creating 0 children, and now I am exiting.Farewell!
I am process B, I finished creating 2 children, and now I am exiting.Farewell!
I am process A, I finished creatind 3 children, and now I am exiting.Farewell!

Below is the whole code, to make any research you want.
The tree.h defines a tree-like structure, which overall defines the "Tree" of processes that has to be made.

DAD is the very first process, below the root of the said tree.

Below is my program:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>  
#include <sys/prctl.h>  
#include <sys/types.h>  
#include <sys/wait.h>  
#include "forktree/tree.h"  
#include "forktree/tree.c"  
#define SLEEP_TIME 5

//BY NO MEANS READY TO RUN
//update:most functionality is now ready.

int first_of_the_year(struct tree_node *base);//Will only be used by the root of the tree,to make         recursion easier
int recurse_me(struct tree_node *base,char *parent_name);//will be used by every other forked process

int main(int argc, char *argv[]){
    struct tree_node *base = get_tree_from_file(argv[1]);
    //struct tree_node *rocket = NULL;
    char *parent_name = NULL;
    pid_t id = fork();
    if(id<0) {
        perror("fork");

    } else if (id == 0) {

        first_of_the_year(base);

    }
    return 0;

}

//forked recursions will return -1, while shallow recursions resulting in a successful fork from     parents will retun 0.
//that will prevent the children from re-creating multiple copies of other processes, while going     up (returning from) the recursion.

int first_of_the_year(struct tree_node *base){
    printf("Hello I am process %s and I just got forked by DAD!\n",base->name);
    int i = 0;
    int flag = 0;
    while((base->nr_children>i)&&(flag !=-1)){
        flag = recurse_me(base->children + i,base->name);
        i++;        
    }
    if (flag==0){
        int count = base->nr_children;
        int status;
        for (i = 0; i < count; i++) {
            wait(&status);
        }
        sleep(SLEEP_TIME);
        printf("I am process %s, I finished creatind %u children, and now I am     exiting.Farewell!\n",base->name,base->nr_children);
    }
    return 0;
}


int recurse_me(struct tree_node *base,char *parent_name){
    int id;
    id = fork();

    if(id<0) {
        perror("fork");

    } else if (id == 0) {
        printf("Hello I am process %s and I just got forked from %s!\n",(base-    >name),parent_name);
        int i=0;
        int flag=0;
        while((base->nr_children>i)&&(flag !=-1)){
            flag = recurse_me(base->children + i,base->name);
            i++;
        }
        if (flag==0){
            int count = base->nr_children;
            int status;
            for (i = 0; i < count; i++) {
                wait(&status);
            }
        sleep(SLEEP_TIME);
        printf("I am process %s, I finished creating %u children, and now I am exiting.Farewell!\n",base->name,base->nr_children);
    }
    return -1;
}

return 0;


}  

And here is tree.h:

#ifndef TREE_H
#define TREE_H

/******************************************************************************
 * Data structure definitions
 */

#define NODE_NAME_SIZE 16
/* tree node structure */
struct tree_node {
    unsigned          nr_children;
    char              name[NODE_NAME_SIZE];
    struct tree_node  *children;
};


/****************************************************************************** 
 * Helper Functions
 */

/* returns the root node of the tree defined in a file */
struct tree_node *get_tree_from_file(const char *filename);

void print_tree(struct tree_node *root);

#endif /* TREE_H */

Answer 1

I think the parent process might have terminated where as the child process not terminated. In your case , the main function might have terminated before the child processes.

Answer 2

fork starts a process in the background. Once the parent process finishes, control is returned to shell and a new prompt is shown.

To let the parent wait until the child is done, you can do something similar:

else {
    printf("Parent process is terminating...\n");
    wait(NULL);
    return 0;
}

Answer 3

I just noticed the problem. DAD, the very first process, does not wait for the root of the tree. So it exits before all the children and sub-children return. Adding the necessary code to wait for the root process of the tree solved the problem.