Background Process – Pipe Input in Unix/Linux

background-processpipestdin

if i want to display "aaa" on screen:

(1)$: echo aaa | cat                 ... works OK
(2)$: echo aaa | ( cat )             ... works OK
(3)$: echo aaa | ( cat & )           ... NOT working
(4)$: ( echo aaa & ) | cat           ... works OK 
(5)$: echo aaa | ( cat <&0 & )       ... works ok in BASH (but not in SH)
(6)$: echo aaa | ( cat <&3 & ) 3<&0  ... works ok in BASH and SH

conlusion from (3) and (4) -> detached process still have connected output that can be controlled, used, redirected…, but not input!

My question is: does someone understand why and how line (5) works ???

… "<&0" is short for "0<&0", why redirecting 0 to 0 is solution, and what really happens behind with input of detached process. Subshell's are not the problem, using braces {…} instead of (…) provide same results.

… and question2: is there better solution for "giving input to detached process" than line (6).

Best Answer

Yes, as required by POSIX, commands started in background with & have their standard input redirected from /dev/null.

And indeed

{ cmd <&3 3<&- & } 3<&0

is the most obvious way to work around it.

It's not clear why you'd want to run part of pipeline in background though.

Related Solutions

Segfaulting Program – Piping Output from a Segfaulting Program

Programs typically buffer their output for efficiency. That is, they accumulate output in a memory area (called a buffer), and they actually get the output out only when the buffer is full or at certain key points in the program. When the program ends normally, it flushes the output buffer (i.e. prints out any data that's left in it). When it segfaults, the content of the buffer is lost.

You don't observe this effect when running the program directly in a terminal because the behavior is different when the program's output is connected to a terminal (as opposed to a regular file or a pipe). In a terminal, the default behavior is to flush the buffer at the end of each line. Therefore you'll see every complete line that's produced up to the point when the program segfaults.

You can force the program to run in a terminal and collect its output. The simplest way is to run script. There are a number of annoyances that you'll need to work around:

script adds a header line to the transcript file, which you'll need to remove afterwards.
script doesn't return the status code of the command, so you'll need to save it somewhere if you want to know about the segfault or any other error.
script will cause normal output and error out; you'd better save the error output to a separate file.

export FONT="foo"
script -q -c '
    ttf2afm "$FONT.ttf" 2>"$FONT.ttf2afm-err";
    echo $? >"$FONT.ttf2afm-status"
' "$FONT.ttf2afm-typescript"
tail -n +2 <"$FONT.ttf2afm-typescript" >"foo.afm"
rm "$FONT.ttf2afm-typescript"
if [ "$(cat "$FONT.ttf2afm-status")" -ne 0 ]; then
  echo 1>&2 "Warning: ttf2afm failed"
  cat "$FONT.ttf2afm-err"
fi

Formatting grep output with awk. Simple case and background case

Many grep implementation will use line buffered when standard output is terminal. When standard output is terminal, it's often an interactive session, you want to get data as soon as possible. So grep will write data to standard output as soon as seeing a newline.

When standard output isn't terminal (often meaning non-interactive session), grep will use block buffer instead. It means grep doesn't write to standard output immediately when seeing a newline. grep collects amount of data (4096 bytes in Linux) before writing to standard output.

Some grep version, like GNU grep or BSD grep have --line-buffered option. It make grep always writing to standard output when seeing a newline. So your example become:

mplayer *.* 2>/dev/null | grep --line-buffered Playing | awk '{print "Mplayer: "$1}'

If your grep version doesn't have --line-buffer, you can do it all with awk:

mplayer *.* 2>/dev/null | awk '/Playing/{print "Mplayer: "$1}'

GNU coreutils has a tool stdbuf for modifying buffering of command. You can always force line buffer in standard output with:

stdbuf -oL command

There's also unbuffer command which disables the output buffering only.

Further reading

Best Answer

Related Solutions

Segfaulting Program – Piping Output from a Segfaulting Program

Formatting grep output with awk. Simple case and background case

Related Question