将信号更改的变量发送到子进程中exec创建的进程。[C]

Question

So I'm creating a signal handler to modify the speed at which output is printed to the screen. The output is done by a process that prints to another terminal open while still allowing the user to put in input such as '+' to increase the speed its read and '-' to decrease the speed.

The code looks something like this.

static state* start_button(void)
{
    state *destination;                                                        

    pid_t pid;                                                    
    pid = fork();                                                 
    switch(pid)                                                   
    {                                                                          
        case -1:                                   
            destination = &ready;                                              
            break;                                                             
        case 0:                                                                          
            execl("./outputTerminal",
                "outputTerminal",file_number,"/dev/ttys001",NULL);                                                                     
            break;                                                             
        default:                                                               
            destination = &going;                                            
            break;                                                             
    }                                                                          

    return destination;
 }

In the going state( going.c ) my thought process was to create volatile variables seconds and nanoseconds and use those variables to update the nanosleep() function that outputTerminal is using to read the lines 1 line at a time like so in the code snippet below. Is this possible? This is a homework question btw. I have all the functions working like they are supposed to I just need to figure out how to send the variables changed by the signal over to that process. I tried doing kill(baby_pid,SIGUSR1) in the going state after I set the signal handler because I saved the pid but that just kills the process outputTerminal for some reason.

 //going.c
 volatile sig_atomic_t seconds;
 volatile sig_atomic_t nanoseconds; //Update these in the going state

 //Then pass them to the process outputTerminal like so


 //outputTerminal.c
 struct timespec tm1,tm2;
 tm1.tv_sec = seconds;
 tm2.tv_nsec = nanoseconds;
 nanosleep(&tm1,&tm2);

This is my signal handler

static void speed_handler(int signal)                                          
{                                                                              
    long max_nano = 1000000000L;                                               
    long incrementer = 250000000L;                                             
    if(speed_control == 0)                                                     
    {                                                                          
        if(nanoseconds == 0L && seconds > 0)                                   
        {                                                                      
            seconds -= 1;                                                      
            nanoseconds = max_nano;                                            
        }                                                                      

        if(nanoseconds != 0L)                                                  
            nanoseconds -= incrementer;                                          
    }                                                                          

    if(speed_control == 1)                                                     
    {                                                                          
        nanoseconds += incrementer;                                            
        if(nanoseconds >= max_nano)                                            
        {                                                                      
            nanoseconds = 0L;                                                  
            seconds += 1;                                                      
        }                                                                      
    }                                                                          
}

Answer 1

What you're looking for is called IPC, short for Inter-process Communication and there are many ways to do what you want. Your approach doesn't work because your processes have distinct address spaces so changing a variable in one has no effect on the other.

A few ways in which you could communicate information from one process to another:

• Share memory between processes (using mmap with MAP_SHARED )
• Send extra information using signals (look up sigqueue and sigval . Or maybe check this old answer https://stackoverflow.com/a/7270506 )
• Use a pipe
• Or a message queue

There are quite a few more mechanisms but this should get you started.