From Gentoo Wiki
Jump to: navigation, search

GNU Bash (Bourne-again shell) is a shell program. It is the first program started if someone logs in at a terminal. Which user uses what shell is defined in the file /etc/passwd. It enables users to easier interact with the system and start additional programs. A lot of this information also applies to other shells such as zsh.


app-shells/bash is part of the @system set and comes installed on every Gentoo system. It is also used by Portage, Gentoo's default package manager. It is highly recommended to not uninstall bash (or any other package in the @system set), even if another shell is used as a login-shell.

USE flags

It is possible to change USE flags:

USE flags for app-shells/bash The standard GNU Bourne again shell

afs Add OpenAFS support (distributed file system) global
bashlogger Log ALL commands typed into bash; should ONLY be used in restricted environments such as honeypots local
examples Install examples, usually source code global
mem-scramble Build with custom malloc/free overwriting allocated/freed memory local
net Enable /dev/tcp/host/port redirection local
nls Add Native Language Support (using gettext - GNU locale utilities) global
plugins Add support for loading builtins at runtime via 'enable' local
readline Enable support for libreadline, a GNU line-editing library that almost everyone wants global

After making USE modifications, ask Portage to update the system so the changes take effect:

root #emerge --ask --changed-use --deep @world


Login shell

The default login shell for a user is defined in the /etc/passwd file. The login shell can be changed using the chsh utility, which is part of sys-apps/coreutils package.


Many settings on how the shell behaves, can be defined via variables. Those variables are defined in several different configuration files, where the settings in the last file parsed do overwrite previous definitions.

  • /etc/profile - Initial settings for all users.
  • /home/USER/.bash_profile - Settings for this user.
  • /home/USER/.bash_login - Settings for this user, if /home/USER/.bash_profile doesn't exist
  • /home/USER/.profile - Settings for this user, if /home/USER/.bash_profile and /home/USER/.bash_login does not exist.

If the shell is started without login (e.g. in a terminal on a desktop), the following files are used:

  • /etc/bashrc - Initial settings for all users.
  • /home/USER/.bashrc - Settings for this user.

In Gentoo, and many other Linux distributions, the /etc/bashrc file is parsed in /etc/profile to ensure that /etc/bashrc and /home/USER/.bashrc are always checked when someone logs into the system. The final settings are defined by the user in their personal .bashrc file.


FILE ~/.bashrc
# configure PS1 command prompt
PS1='\u@\h \w \$ '

# no double entries in the shell history
export HISTCONTROL="$HISTCONTROL erasedups:ignoreboth"

# do not overwrite files when redirecting output by default.
set -o noclobber

# wrap these commands for interactive use to avoid accidental overwrites.
rm() { command rm -i "$@"; }
cp() { command cp -i "$@"; }
mv() { command mv -i "$@"; }

Tab completion

The app-shells/bash-completion package adds completion to many programs and their parameters.

root #emerge --ask app-shells/bash-completion

The following line must be added to each user's .bashrc file in order to load bash-completion upon login:

FILE ~/.bashrc
source /etc/profile.d/

(The script is located at /etc/bash/bashrc.d/ in app-shells/bash-completion-2.1_p20141224.)

Completion can now be enabled for various programs with eselect:

user $eselect bashcomp enable gentoo

Some system administrators may wish to enable completion for currently installed packages on a global scale (effecting all users on the system at one time). Root privileges are necessary:

root #eselect bashcomp enable {0..478}

To enable completion globally for all currently installed packages:

root #eselect bashcomp enable --global {0..478}

You will get an error message /usr/share/bash-completion/completions doesn't exist, which can safely be ignored.

Starting with app-shells/bash-completion-2.1-r90, the framework used to enable and manage completions in Gentoo is finally changing in order to properly follow upstream design.[1]
You may experience a serious delay if you have enabled too many items.

If so, just disable all globally and select only the items that are necessary.

root #eselect bashcomp disable --global {0..478}


user $eselect bashcomp enable (the list you want to use)


Environment variables

See all variables for the current shell process which have the export attribute set:

user $export

Of course, users can export their own variables, which are available to the current process and inherited by child processes:

user $export MYSTUFF=Hello

Environment variables can also be localized to an individual child process by prepending an assignment list to a simple command. The resulting environment passed to execve() will be the union of the assignment list with the environment of the calling shell process:

user $USE=kde emerge -pv libreoffice

To check the value of a variable:

user $typeset -p MYSTUFF


The special shell variable PS1 defines what the terminal prompt looks like:

CODE Prompt
MyUserName@MyPC: ~ $
the ~ symbol represents the current user's home directory (/home/${USER}/)

This prompt would be the following value in PS1:

PS1="\u@\h \w $ "

The following table lists the possible placeholders that can be used in the PS1 variable:

Code Effect
\u Username
\h Hostname
\w Current directory
\d Current date
\t Current time
\$ Indicate the root user with '#' and normal users with '$'
\j Number of currently running tasks (jobs)

You can also put complete commands into your prompt using a command substitution. Here we want to execute cut -d\ -f1 /proc/loadavg to show the one-minute load average at the beginning of the prompt:

PS1="\$(cut -d\  -f1 /proc/loadavg) $ "

which looks like this:

CODE Prompt
0.10 $

Having colors in the prompt:

PS1="\e[0;32m\]\u@\h \w >\e[0m\] "

The \e[0;32m\] changes the color for every next output, we have to put \e[0m\] at the end of our variable to reset the color, or we would type everything in green.

Color codes:

Code Color
\e[0;30m\] Black
\e[0;31m\] Red
\e[0;32m\] Green
\e[0;33m\] Yellow
\e[0;34m\] Blue
\e[0;35m\] Magenta
\e[0;36m\] Cyan
\e[0;37m\] White
\e[0m\] Reset to standard colors

The 0; in \e[0;31m\] means foreground. You can define other values like 1; for foreground bold and 4; for foreground underlined. Omit this number to refer to the background, e.g. \e[31m\].


The set command is used to display and change settings in the bash shell.

Show all current settings:

user $set -o

Disable the shell history:

user $set +o history

Enable the shell history:

user $set -o history


You can use the alias builtin to define a new command or redefine an existing command:

user $alias ll='ls -l'

Whenever now ll (two lowercase Ls) is send to the shell, it will actually execute ls -l.

To remove an alias:

user $unalias ll
No harm is done to the actual command being redefined.

If you want to temporarily bypass an alias you can escape the first letter of the command with a backslash character:

user $\ls


The history of used commands in a session is written to a file in the user's home directory. The easiest way to access the commands in the history is using the Up and Down keys.

To show all commands in the current history:

user $history

To search for commands in the history, by piping the output through grep and filter for words:

user $history | grep echo

The commands are numbered and can be executed using their index:

user $!2

To execute the last command used:

user $!!

Delete every command in the history:

user $history -c

Show the current settings for history:

user $echo $HISTCONTROL


Shell scripts are text files which contain programs written in a certain shell scripting language. Which shell is used to interpret the commands in a script is defined in the first line (which is called the shebang):

echo 'Hello World!'

If no shell is defined the default shell for the user who executes the script is used. Often /bin/sh is used, which is the father of all shells and has very limited functionalities. Nearly all shells available understand commands used when running /bin/sh, so those scripts are highly portable.

On many distributions /bin/sh is a symbolic link to /bin/bash. But on other distributions (like Debian) it can be a symbolic link to /bin/dash, which is a POSIX compliant variant of sh. In order to insure a good portability, be sure to test any script using the same shell than the one used in it's shebang.

Start scripts

To run scripts directly from the command-line, they need to be executable. To make a shell script executable:

user $chmod +x

Now the script can be executed by using the ./ prefix, where either the shell defined by the shebang in the script or the default shell of the user is used:

user $./

In alternative you can explicitly invoke the shell and pass the script filename as an argument (no change of permissions needed):

user $sh

The file extension .sh does not matter, but it helps to distinguish scripts from normal text files.


In Bash it is possible to redirect the output of one program into the input of another program using a pipe, indicated by the | symbol. This enables users to create command chains. Here is an example to redirect the output of ls -l into the program /usr/bin/less:

user $ls -l | less

To redirect output into a file:

user $ls -l > ls_l.txt

The > operator will erase any previous content before adding new one. If this is not desired, use the >> (append) operator instead.

Logical operators

Logical operators are very useful to chain commands together. This is helpful when checking if the previous command finished successfully or not.

&& (AND) - The following command prints 'Success' only if our test script is successful:

user $./ && echo 'Success'

|| (OR) - The following command prints 'Failure' only if our test script is unsuccessful:

user $./ || echo 'Failure'


Usually if we start a script or command, the input is blocked until the command is finished. To start a program directly in the background, so we can continue to work in the shell:

user $sh &

This will execute the script as job number 1 and the prompt expects the next input.

If a program is already running and you need to do something on the shell, it is possible to move programs from foreground to background and vice versa. To get a command prompt if a command is running on the shell, put it into sleep using Ctrl+Z, then move it to the background:

user $bg %1

To list all jobs running in the background:

user $jobs

To move a job back to foreground:

user $fg %1
Programs running as jobs usually do not terminate once they finish execution, there will be a message if a job finished and bringing it to foreground will then terminate the program.

Command substitution

Using a command substitution, it is possible to run programs as parameters of other commands like here:

user $emerge $(qlist -CI x11-drivers)

This will first execute the command in the brackets and append the output as parameter of emerge.

This command is quite useful in Gentoo to quickly rebuild all X11 drivers.

More substitutions can be performed in one command like this:

user $emerge $(qlist -CI x11-drivers) $(qlist -CI modules)

See also

  • shell - A command-line interpreter.
  • dash - The Debian Almquist Shell.

External resources


  1. News Items - bash-completion-2.1-r90, Welcome – Gentoo Linux, November 25th, 2014. Retrieved on November 3rd, 2015.