Basically, there are two different ways to start a shell from the graphical user interface which usually shows after you have booted your computer:

While the first option is always available, you can only make use of the second option when you are already logged in to a desktop such as KDE or GNOME. Whichever way you choose, there is always a way back and you can switch back and forth between the shell and the graphical user interface.

If you want to give it a try, press Ctrl–Alt–F2 to leave the graphical user interface. The graphical user interface disappears and you are taken to a shell which prompts you to log in. Type your username and press Enter. Then type your password and press Enter. The prompt now changes and shows some useful information as in the following example:

 1   2   3
tux@linux:~>

When you are logged in at a remote computer the information provided by the prompt always shows you which system you are currently working on.

When the cursor is located behind this prompt, you can pass commands directly to your computer system. For example, you can now enter ls -l to list the contents of the current directory in a detailed format. If this is enough for your first encounter with the shell and you want to go back to the graphical user interface, you should log out from your shell session first. To do so, type exit and press Enter. Then press Alt–F7 to switch back to the graphical user interface. You will find your desktop and the applications running on it unchanged.

When you are already logged in to the GNOME or the KDE desktop and want to start a terminal window within the desktop, press Alt–F2 and enter konsole (for KDE) or gnome-terminal (for GNOME). This opens a terminal window on your desktop. As you are already logged in to your desktop, the prompt shows information about your system as described above. You can now enter commands and execute tasks just like in any shell which runs parallel to your desktop. To switch to another application on the desktop just click on the corresponding application window or select it from the taskbar of your panel. To close the terminal window press Alt–F4.

As soon as the prompt appears on the shell it is ready to receive and execute commands. A command can consist of several elements. The first element is the actual command, followed by parameters or options. You can type a command and edit it by using the following keys: ←, →, Home, End, <— (Backspace), Del, and Space. You can correct typing errors or add options. The command is not executed until you press Enter.

Important: No news is good news

The shell is not verbose: in contrast to some graphical user interfaces, it usually does not provide confirmation messages when commands have been executed. Messages only appear in case of problems or errors —or if you explicitly ask for them by executing a command with a certain option.

Also keep this in mind for commands to delete objects. Before entering a command like rm (without any option) for removing a file, you should know if you really want to get rid of the object: it will be deleted irretrievably, without confirmation.

> ls
bin Desktop Documents public_html tux.txt
> 

> ls -l
drwxr-xr-x 1 tux users     48 2015-06-23 16:08 bin
drwx---r-- 1 tux users  53279 2015-06-21 13:16 Desktop
drwx------ 1 tux users    280 2015-06-23 16:08 Documents
drwxr-xr-x 1 tux users  70733 2015-06-21 09:35 public_html
-rw-r--r-- 1 tux users  47896 2015-06-21 09:46 tux.txt
> 

drwxr-xr-x1 12 tux3 users4 485 2006-06-23 16:086 bin7

If you remember the name of command but are not sure about the options or the syntax of the command, choose one of the following possibilities:

Note that man pages and info pages do not exist for all commands. Sometimes both are available (usually for key commands), sometimes only a man page or an info page exists, and sometimes neither of them are available.

To address a certain file or directory, you must specify the path leading to that directory or file. There are two ways to specify a path:

Paths contain file names, directories or both, separated by slashes. Absolute paths always start with a slash. Relative paths do not have a slash at the beginning, but can have one or two dots.

When entering commands, you can choose either way to specify a path, depending on your preferences or the amount of typing, both will lead to the same result. To change directories, use the cd command and specify the path to the directory.

Note: Handling blanks in filenames or directory names

If a filename or the name of a directory contains a space, either escape the space using a back slash (\) in front of the blank or enclose the filename in single quotes. Otherwise Bash interprets a filename like My Documents as the names of two files or directories, My and Documents in this case.

When specifying paths, the following “shortcuts” can save you a lot of typing:

To apply your knowledge, find some examples below. They address basic tasks you may want to execute with files or folders using Bash.

13.4.1 Examples for working with files and directories #Edit source

Suppose you want to copy a file located somewhere in your home directory to a subdirectory of /tmp that you need to create first.

Procedure 13.1: Creating and changing directories #

From your home directory create a subdirectory in /tmp:

1. Enter

   > mkdir /tmp/test

   mkdir stands for “make directory”. This command creates a new directory named test in the /tmp directory. In this case, you are using an absolute path to create the test directory.

2. To check what happened, now enter

   > ls -l /tmp

   The new directory test should appear in the list of contents of the /tmp directory.

3. Switch to the newly created directory with

   > cd /tmp/test

Procedure 13.2: Creating and copying files #

Now create a new file in a subdirectory of your home directory and copy it to /tmp/test. Use a relative path for this task.

Important: Overwriting of existing files

Before copying, moving or renaming a file, check if your target directory already contains a file with the same name. If yes, consider changing one of the filenames or use cp or mv with options like -i, which will prompt before overwriting an existing file. Otherwise Bash will overwrite the existing file without confirmation.

1. To list the contents of your home directory, enter

   > ls -l ~

   It should contain a subdirectory called Documents by default. If not, create this subdirectory with the mkdir command you already know:

   > mkdir ~/Documents

2. To create a new, empty file named myfile.txt in the Documents directory, enter

   > touch ~/Documents/myfile.txt

   Usually, the touch command updates the modification and access date for an existing file. If you use touch with a filename which does not exist in your target directory, it creates a new file.

3. Enter

   > ls -l ~/Documents

   The new file should appear in the list of contents.

4. To copy the newly created file, enter

   > cp ~/Documents/myfile.txt .

   Do not forget the dot at the end.

   This command tells Bash to go to your home directory and to copy myfile.txt from the Documents subdirectory to the current directory, /tmp/test, without changing the name of the file.

5. Check the result by entering

   > ls -l

   The file myfile.txt should appear in the list of contents for /tmp/test.

Procedure 13.3: Renaming and removing files or directories #

Now suppose you want to rename myfile.txt into tuxfile.txt. Finally you decide to remove the renamed file and the test subdirectory.

1. To rename the file, enter

   > mv myfile.txt tuxfile.txt

2. To check what happened, enter

   > ls -l

   Instead of myfile.txt, tuxfile.txt should appear in the list of contents.

   mv stands for move and is used with two options: the first option specifies the source, the second option specifies the target of the operation. You can use mv either

   • to rename a file or a directory,

   • to move a file or directory to a new location or

   • to do both in one step.

3. Coming to the conclusion that you do not need the file any longer, you can delete it by entering

   > rm tuxfile.txt

   Bash deletes the file without any confirmation.

4. Move up one level with cd .. and check with

   > ls -l test

   if the test directory is empty now.

5. If yes, you can remove the test directory by entering

   > rmdir test

root, also called the superuser, has privileges which authorize them to access all parts of the system and to execute administrative tasks. They have the unrestricted capacity to make changes to the system and they have unlimited access to all files. Therefore, performing some administrative tasks or running certain programs such as YaST requires root permissions.

> sudo chown wilber kde_quick.xml

In Linux, objects such as files or folders or processes generally belong to the user who created or initiated them. There are some exceptions to this rule. For more information about the exceptions, refer to Book “Security and Hardening Guide”, Chapter 19 “Access control lists in Linux”. The group which is associated with a file or a folder depends on the primary group the user belongs to when creating the object.

When you create a new file or directory, initial access permissions for this object are set according to a predefined scheme. As an owner of a file or directory, you can change the access permissions for this object. For example, you can protect files holding sensitive data against read access by other users and you can authorize the members of your group or other users to write, read, or execute several of your files where appropriate. As root, you can also change the ownership of files or folders.

-rw-r----- 1 tux users      0 2015-06-23 16:08 checklist.txt
-rw-r--r-- 1 tux users  53279 2015-06-21 13:16 gnome_quick.xml
-rw-rw---- 1 tux users      0 2015-06-23 16:08 index.htm
-rw-r--r-- 1 tux users  70733 2015-06-21 09:35 kde-start.xml
-rw-r--r-- 1 tux users  47896 2015-06-21 09:46 kde_quick.xml
drwxr-xr-x 2 tux users     48 2015-06-23 16:09 local
-rwxr--r-- 1 tux users 624398 2015-06-23 15:43 tux.sh

-rw-r----- 1 tux users      0 2015-06-23 16:08 checklist.txt
-rw-r--r-- 1 tux users  53279 2015-06-21 13:16 gnome_quick.xml
-rw-rw---- 1 tux users      0 2015-06-23 16:08 index.htm
-rw-r--r-- 1 tux users  70733 2015-06-21 09:35 kde-start.xml
-rw-r--r-- 1 tux users  47896 2015-06-21 09:46 kde_quick.xml
drwxr-xr-x 2 tux users     48 2015-06-23 16:09 local
-r-xr-xr-x 1 tux users 624398 2015-06-23 15:43 tux.jpg

Entering commands in Bash can involve a lot of typing. This section introduces some features that can save you both time and typing.

13.7.1 Examples for using history, completion and wild cards #Edit source

The following examples illustrate how to make use of these convenient features of Bash.

Procedure 13.6: Using history and completion #

If you already did the example Section 13.4.1, “Examples for working with files and directories”, your shell buffer should be filled with commands which you can retrieve using the history function.

1. Press ↑ repeatedly until cd ~ appears.

2. Press Enter to execute the command and to switch to your home directory.

   By default, your home directory contains two subdirectories starting with the same letter, Documents and Desktop.

3. Type cd D and press →|.

   Nothing happens since Bash cannot identify to which one of the subdirectories you want to change.

4. Press →| again to see the list of possible choices:

   > cd D
   Desktop/ Documents/ Downloads/
   > cd D

5. The prompt still shows your initial input. Type the next character of the subdirectory you want to go to and press →| again.

   Bash now completes the path.

6. You can now execute the command with Enter.

Procedure 13.7: Using wild cards #

Now suppose that your home directory contains several files with various file extensions. It also holds several versions of one file which you saved under different filenames myfile1.txt, myfile2.txt etc. You want to search for certain files according to their properties.

1. First, create some test files in your home directory:

   1. Use the touch command to create several (empty) files with different file extensions, for example .pdf, .xml and .jpg.

      You can do this consecutively (do not forget to use the Bash history function) or with only one touch command: simply add several filenames separated by a space.

   2. Create at least two files that have the same file extension, for example .html.

   3. To create several “versions” of one file, enter

      > touch myfile{1..5}.txt

      This command creates five consecutively numbered files: myfile1.txt, …, myfile5.txt.

   4. List the contents of the directory. It should look similar to this:

      > ls -l
      -rw-r--r-- 1 tux users   0 2006-07-14 13:34 foo.xml
      -rw-r--r-- 1 tux users   0 2006-07-14 13:47 home.html
      -rw-r--r-- 1 tux users   0 2006-07-14 13:47 index.html
      -rw-r--r-- 1 tux users   0 2006-07-14 13:47 toc.html
      -rw-r--r-- 1 tux users   0 2006-07-14 13:34 manual.pdf
      -rw-r--r-- 1 tux users   0 2006-07-14 13:49 myfile1.txt
      -rw-r--r-- 1 tux users   0 2006-07-14 13:49 myfile2.txt
      -rw-r--r-- 1 tux users   0 2006-07-14 13:49 myfile3.txt
      -rw-r--r-- 1 tux users   0 2006-07-14 13:49 myfile4.txt
      -rw-r--r-- 1 tux users   0 2006-07-14 13:49 myfile5.txt
      -rw-r--r-- 1 tux users   0 2006-07-14 13:32 tux.png

2. With wild cards, select certain subsets of the files according to various criteria:

   1. To list all files with the .html extension, enter

      > ls -l *.html

   2. To list all “versions” of myfile.txt, enter

      > ls -l myfile?.txt

      Note that you can only use the ? wild card here because the numbering of the files is single-digit. As soon as you have a file named myfile10.txt you must to use the * wild card to view all versions of myfile.txt (or add another question mark, so your string looks like myfile??.txt).

   3. To remove, for example, version 1-3 and version 5 of myfile.txt, enter

      > rm myfile[1-3,5].txt

   4. Check the result with

      > ls -l

      Of all myfile.txt versions only myfile4.txt should be left.

You can also combine several wild cards in one command. In the example above, rm myfile[1-3,5].* would lead to the same result as rm myfile[1-3,5].txt because there are only files with the extension .txt available.

Note: Using wild cards in rm commands

Wild cards in a rm command can be very useful but also dangerous: you might delete more files from your directory than intended. To see which files would be affected by the rm, run your wild card string with ls instead of rm first.

In order to edit files from the command line, you will need to know the vi editor. vi is a default editor which can be found on nearly every UNIX/Linux system. It can run several operating modes in which the keys you press have different functions. This does not make it very easy for beginners, but you should know at least the most basic operations with vi. There may be situations where no other editor than vi is available.

Basically, vi makes use of three operating modes:

In the following (very simple) example, you will learn how to open and edit a file with vi, how to save your changes and quit vi.

13.8.1 Example: editing with vi #Edit source

Note: Display of keys

In the following, find several commands that you can enter in vi by just pressing keys. These appear in uppercase as on a keyboard. If you need to enter a key in uppercase, this is stated explicitly by showing a key combination including the Shift key.

1. To create and open a new file with vi, enter

   > vi textfile.txt

   By default, vi opens in command mode in which you cannot enter text.

2. Press I to switch to insert mode. The bottom line changes and indicates that you now can insert text.

3. Write some sentences. If you want to insert a new line, first press Esc to switch back to command mode. Press O to insert a new line and to switch to insert mode again.

4. In the insert mode, you can edit the text with the arrow keys and with Del.

5. To leave vi, press Esc to switch to command mode again. Then press : which takes you to the extended mode. The bottom line now shows a colon.

6. To leave vi and save your changes, type wq (w for write; q for quit) and press Enter. If you want to save the file under a different name, type w FILENAME and press Enter.

   To leave vi without saving, type q! instead and press Enter.

Bash offers you several commands to search for files and to search for the contents of files:

When searching for the contents of a file with grep, the output gives you the line in which the searchstring was found along with the filename. Often this contextual information is still not enough information to decide whether you want to open and edit this file. Bash offers you several commands to have a quick look at the contents of a text file directly in the shell, without opening an editor.

Sometimes it would be useful if you could write the output of a command to a file for further editing or if you could combine several commands, using the output of one command as the input for the next one. The shell offers this function by means of redirection or pipes.

Normally, the standard output in the shell is your screen (or an open shell window) and the standard input is the keyboard. With certain symbols you can redirect the input or the output to another object, such as a file or another command.

As you have seen in Section 13.8, “Editing texts”, programs can be started from the shell. Applications with a graphical user interface need the X Window System and can only be started from a terminal window within a graphical user interface. For example, if you want to open a file named vacation.pdf in your home directory from a terminal window in KDE or GNOME, simply run okular ~/vacation.pdf (or evince ~/vacation.pdf) to start a PDF viewer displaying your file.

When looking at the terminal window again you will realize that the command line is blocked as long as the PDF viewer is open, meaning that your prompt is not available. To change this, press Ctrl–Z to suspend the process and enter bg to send the process to the background.

Now you can still have a look at vacation.pdf while your prompt is available for further commands. An easier way to achieve this is by sending a process to the background directly when starting it. To do so, add an ampersand at the end of the command:

> okular ~/vacation.pdf &

If you have started several background processes (also named jobs) from the same shell, the jobs command gives you an overview of the jobs. It also shows the job number in brackets and their status:

> jobs
[1]   Running        okular book.opensuse.startup-xep.pdf &
[2]-  Running        okular book.opensuse.reference-xep.pdf &
[3]+  Stopped        man jobs

To bring a job to the foreground again, enter fg JOB_NUMBER.

Whereas job only shows the background processes started from a specific shell, the ps command (run without options) shows a list of all your processes—those you started. Find an example output below:

> ps
PID TTY          TIME CMD
15500 pts/1    00:00:00 bash
28214 pts/1    00:00:00 okular
30187 pts/1    00:00:00 kwrite
30280 pts/1    00:00:00 ps

In case a program cannot be terminated in the normal way, use the kill command to stop the process (or processes) belonging to that program. To do so, specify the process ID (PID) shown by the output of ps. For example, to shut down the KWrite editor in the example above, enter

> kill 30187

This sends a TERM signal that instructs the program to shut itself down.

Alternatively, if the program or process you want to terminate is a background job and is shown by the jobs command, you can also use the kill command in combination with the job number to terminate this process. When identifying the job with the job number, you must prefix the number with a percent character (%):

> kill %JOB_NUMBER

If kill does not help—as is sometimes the case for “runaway” programs—try

> kill -9 PID

This sends a KILL signal instead of a TERM signal, usually bringing the specified process to an end.

This section is intended to introduce the most basic set of commands for handling jobs and processes. Find an overview for system administrators in Book “System Analysis and Tuning Guide”, Chapter 2 “System monitoring utilities”, Section 2.3 “Processes”.

On Linux, there are two types of commands that make data easier to transfer:

When combining these two types of commands, their effect is comparable to the compressed archive files that are prevalent on other operating systems, for example, ZIP or RAR.

To pack the test directory with all its files and subdirectories into an archive named testarchive.tar, do the following:

To compress files, use gzip or, for better compression, bzip2.

This section provides an overview of the most important Linux commands. There are many more commands than listed in this chapter. Along with the individual commands, parameters are listed and, where appropriate, a typical sample application is introduced.

Adjust the parameters to your needs. It makes no sense to write ls file if no file named file actually exists. You can usually combine several parameters, for example, by writing ls -la instead of ls -l -a.