前置子流程控制台输出

Question

I have an app that spawns a child process. That child process outputs information about what it's doing by printing to stdout. The parent process does the same (ie prints to stdout).

In the child process I can write to stdout with some text prepended, but I have to add that to every single location I print across many source files.

I thought it might be smarter to have the parent process prepend output from the child process that it forks/exec's. I don't want to redirect the output because seeing the output inline with the parent process is beneficial. How do I do this? I'm using fork/exec in the parent.

Do I have to read the output and prepend each line manually or is there a simpler approach?

---

Update:

Thanks to Barmar. Here is how I'm doing it. I also could read byte by byte in the parent process from the pipe until line end. But I chose not to use that approach for reasons of complexity in my single threaded lua+C app.

// Crude example of output filtering using sed to 
// prepend child process output text

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <libgen.h>
#include <string.h>


pid_t spawn(int fd[2], const char* path)
{
  printf("Create child\n");
  pid_t pid = fork();
  switch(pid){
    case -1:
      printf("Create process failed");
      return -1;
    case 0:
      dup2(fd[1], STDOUT_FILENO);
      close(fd[0]);
      close(fd[1]);
      execl(path, path, NULL);
      return 0;
    default:
      return pid;
  }
}

pid_t spawnOutputFilter(int fd[2])
{
  printf("Create sed\n");
  pid_t pid = fork();
  switch(pid){
    case -1:
      printf("Create sed failed");
      return -1;
    case 0:
      dup2(fd[0], STDIN_FILENO);
      close(fd[0]);
      close(fd[1]);
      execlp("sed", "sed", "s/^/Engine: /", (char *)NULL);
      return -1;
    default:
      return pid;
  }
}


int main(int argc, char* argv[])
{
  if (argc > 1){
    int options;
    int fd[2];
    pipe(fd);
    pid_t pid = spawn(fd, argv[1]);
    pid_t sed_pid = spawnOutputFilter(fd);

    close(fd[0]);
    close(fd[1]);
    waitpid(pid, NULL, 0);
    waitpid(sed_pid, NULL, 0);
  }

  return 0;
}

Answer 1

I thought it might be smarter to have the parent process prepend output from the child process.

I guess it depends on how you judge "smart". It might be simpler to just make the child prepend the desired text to its outputs.

I don't want to redirect the output because seeing the output inline with the parent process is beneficial. What's the best way to do this?

When two processes share an open file, both access it independently, regardless of the nature of the relationship between those processes. Thus, if your child inherits the parent's stdout , the parent has no mechanism even to notice that the child is sending output, much less to modify that output.

If you want the parent to handle this, you would need to pass the child's output through the parent. You could do that by creating a pipe, and associating the child's stdout with the write end of that pipe. The parent would then need to monitor the read end, and forward suitably-modified outputs to its own stdout . The parent would probably want to create a separate thread for that purpose.

Additionally, if the child sometimes produces multi-line outputs that you want prefixed as a group, rather than per-line, then you'd probably need to build and use some kind of protocol for demarcating message boundaries, which would make the whole parent-moderation idea pretty pointless.

Answer 2

You could create a second child process that performs

execlp("sed", "sed", "s/^/PREFIX: /", (char *)NULL);

Connect the first child's stdout to this process's stdin with a pipe.

Answer 3

Couldn't you define #define printf(a) printf("your text:" a).

Other alternative I can think of is using dup

You open the same log file in your child process and dup your stdout to new file descriptor.