Bash – In Bash, what is file descriptor 255 for, can I use it

bashfile-descriptors

I understand file descriptor (or file handler) is an file IO technique in Linux systems.

I also know that each process has 3 standard streams (namely stdin, stdout and stderr) that are represented by files with descriptors from 0 to 3.

However, I notice that all the processes I examined with lsof -p <pid> has an extra file descriptor 255 with read permission.

From this answer, I learned that this feature is specific to Bash shell, however both the answer the and the referenced source didn't really explain what this file descriptor is for.

My question:

What is the 255 file descriptor for?
Can I make use of it in my Bash script or is it just an internal working mechanism that is not supposed to be used/manipulated manually?

Best Answer

For the last part of your question:

can I use it?

From man bash:

Redirections using file descriptors greater than 9 should be used with care, as they may conflict with file descriptors the shell uses internally.

So, if you mean use as creating a new fd with that number the answer is no.

If you mean use as: "write to that fd":

$ echo hello >/dev/fd/255"

Or to read from it:

$ read a </dev/fd/255
abc
$ echo "$a"
abc

the answer is yes.
But, probably, it should be better (independent of shell) to use /dev/tty to access the tty.

what is file descriptor 255 for?

As an alternative connection to the tty in case fd 1 (/dev/stdout) and fd 0 (/dev/stdin) get blocked.

More detail.

Other shells may use a different number (like 10 in zsh)

$ zsh
mail% ls -l /proc/self/fd /proc/$$/fd/* &
[1] 3345
mail% lrwx------ 1 isaac isaac 64 Oct 14 09:46 /proc/3250/fd/0 -> /dev/pts/2
lrwx------ 1 isaac isaac 64 Oct 14 09:50 /proc/3250/fd/1 -> /dev/pts/2
lrwx------ 1 isaac isaac 64 Oct 14 09:50 /proc/3250/fd/10 -> /dev/pts/2
lrwx------ 1 isaac isaac 64 Oct 14 09:50 /proc/3250/fd/2 -> /dev/pts/2

/proc/self/fd:
total 0
lrwx------ 1 isaac isaac 64 Oct 14 09:50 0 -> /dev/pts/2
lrwx------ 1 isaac isaac 64 Oct 14 09:50 1 -> /dev/pts/2
lrwx------ 1 isaac isaac 64 Oct 14 09:50 2 -> /dev/pts/2
lr-x------ 1 isaac isaac 64 Oct 14 09:50 3 -> /proc/3345/fd

[1]  + done       ls -l /proc/self/fd /proc/$$/fd/*
mail%

From mail list:

Fd 255 is used internally as a connection to the tty, so that it doesn't interfere with the use of exec to relocate fds. Bash also allocates high fds when handling a process substitution `<(foo)', for the same reason.
Andreas Schwab

Related Solutions

Bash Primary – Definition of a Primary in Bash

As noted, this is jargon. The bash reference manual does not define the term; it is assumed that the reader knows about it.

You can easily find it used for operands in an arithmetic expression. See for example Arithmetic Expressions in a Fortran 77 Language Reference Manual, which says

A primary is the basic component in an arithmetic expression. The forms of a primary are the following:

an unsigned arithmetic constant

a symbolic name of an arithmetic constant

an arithmetic variable reference

an arithmetic array element reference

an arithmetic function reference

an arithmetic expression enclosed in parentheses

In POSIX, it is (still) used mostly relying upon the reader's prior knowledge of the term. For instance, in the shell command language, it refers to primaries of the find command:

(such as in the argument to the find - name primary when find is being called using one of the exec functions as defined in the System Interfaces volume of POSIX.1-2008, or in the pattern argument to the fnmatch() function),

and on reading that section it is apparent that primaries means the same as operands. That is, at each level of command-parsing, the command (or primary) has some further primaries to consider until all that are left are constants or variables: aka "operand".

Bash – simple test for anything printed on stderr in shell/Bash

You could do (POSIXly):

if { cmd 2>&1 >&3 3>&- | grep '^' >&2; } 3>&1; then
  echo there was some output on stderr
fi

Or to preserve the original exit status if it was non-zero:

fail_if_stderr() (
  rc=$({
    ("$@" 2>&1 >&3 3>&- 4>&-; echo "$?" >&4) |
    grep '^' >&2 3>&- 4>&-
  } 4>&1)
  err=$?
  [ "$rc" -eq 0 ] || exit "$rc"
  [ "$err" -ne 0 ] || exit 125
) 3>&1

Using exit code 125 for the cases where the command returns with a 0 exit status but produced some error output.

To be used as:

fail_if_stderr cmd its args || echo "Failed with $?"