1

Specifically, I want to view the /proc/PID/io file for a child process created by fork(). I can only think to try to access it within the parent process, but it is always inaccessible.

pid_t pid = fork();
if (pid < 0) // failed
{
    return;
}
else if (pid == 0) // child process
{
    char* args[] = { "cat", "test.txt" };
    execv(args[0], args);
}
else // parent process
{
    wait(NULL);
}

The file is accessible before the call to wait, but it of course doesn't contain any nonzero values since the child hasn't finished yet. The file is inaccessible after the call to wait, because the child has terminated. So, how would I go about this?

Admittedly, this is for a project, but we have not covered anything beyond basic forking. Any help is appreciated.

Rob
  • 45
  • 5
  • 1
    When a process terminates and the child is collected, the corresponding entry in /proc vanishes. What information do you need? Also, please specify your operating system since the proc file system is not part of POSIX nor System V. – fuz Sep 15 '14 at 12:46
  • 3
    This sounds like an [XY Problem](http://mywiki.wooledge.org/XyProblem) instance to me. Please try to clarify why you need that access. – unwind Sep 15 '14 at 12:47
  • Sorry, it's actually a Linux machine provided by my school that I ssh into. I need the values of "bytes_read" and "bytes_written" from the /proc/PID/io file, per the project description. – Rob Sep 15 '14 at 13:11

1 Answers1

2

When your child terminates you receive a signal SIGCHLD. Calling wait will wait for this and then clean up the child.

What you have to do is install a signal handler for SIGCHLD, when it arrives the child process is already a zombie, but its /proc entry still exists. Then read /proc/[child pid]/io and only afterwards wait for the child in order to clean it up.

Edit:

Here is some code (requires root (sudo) permissions:

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

pthread_mutex_t mutex;

void sigchldhandler(int s) {
    // signals to the main thread that child has exited
    pthread_mutex_unlock(&mutex); 
}

int main() {

    // init and lock the mutex
    pthread_mutex_init(&mutex, NULL);
    pthread_mutex_lock(&mutex);

    // install signal handler
    signal(SIGCHLD, sigchldhandler);

    pid_t child_pid = fork();

    if (child_pid > 0) {
        // parent
        // wait for the signal
        pthread_mutex_lock(&mutex);

        char buffer[0x1000];
        sprintf(buffer, "/proc/%d/io", child_pid);
        FILE * fp = fopen(buffer, "r");
        if (!fp) {
            perror("fopen");
            abort();
        }
        while (fgets(buffer, sizeof(buffer), fp)) {
            printf("%s", buffer);
        }
        // clean up child
        wait(0);

        return 0;

    } else if (child_pid < 0) {
        perror("fork");
        abort();
    } else {
        // child
        char* args[] = { "cat", "test.txt" };
        execv(args[0], args);
    }

}
Sergey L.
  • 21,822
  • 5
  • 49
  • 75
  • I will try that. Thanks for the help. EDIT: How can I get the PID of the child while in the signal handler? – Rob Sep 15 '14 at 15:11
  • @Robbeh Easy solution: put it into a global variable. The Portable solution: use the newer `sigaction` signal API, which can have a function that receives the PID as an argument. But ideally you shouldn't run anything big in a signal handler. Most stuff you can do there isn't signal safe! – Sergey L. Sep 15 '14 at 15:40
  • Ah, of course. Thanks very much. And thank you for the sample code. – Rob Sep 15 '14 at 15:51