Files and the Filesystem

Table 2-1 shows some of the important directories in the filesystem. Most of these follow the Linux standard of where files should go; a couple are specific to the Raspberry Pi. The /sys directory is where you can access all of the hardware on the Raspberry Pi.

You’ll see your current directory displayed before the command prompt. In Linux, your home directory has a shorthand notation: the tilde (~). When you open the LXTerminal, you’ll be dropped into your home directory, and your prompt will look like this:

pi@raspberrypi ~ $

Here’s an explanation of that prompt:

pi@raspberrypi ~ $

Your username, pi, followed by the at (@) symbol.

The name of your computer (raspberrypi is the default hostname).

The current working directory of the shell. You always start out in your home directory (~).

This is the shell prompt. Any text you type will appear to the right of it. Press Enter or Return to execute each command you type.

Use the cd (change directory) command to move around the filesystem. The following two commands have the same effect (changing to the home directory) for the Pi user:

cd /home/pi/
cd ~

If the directory path starts with a forward slash, it will be interpreted as an absolute path to the directory. Otherwise, the directory will be considered relative to the current working directory. You can also use . and .. to refer to the current directory and the current directory’s parent. For example, to move up to the top of the filesystem:

pi@raspberrypi ~ $ cd ..
pi@raspberrypi /home $ cd ..

You could also get there with the absolute path /:

pi@raspberrypi ~ $ cd /

Once you’ve changed to a directory, use the ls command to list the files there:

pi@raspberrypi / $ ls
bin   dev  home  lost+found  mnt  proc  run   selinux  sys  usr
boot  etc  lib   media       opt  root  sbin  srv      tmp  var

Most commands have additional parameters, or switches, that can be used to turn on different behaviors. For example, the -l switch will produce a more detailed listing, showing file sizes, dates, and permissions:

pi@raspberrypi ~ $ ls -l
total 8
drwxr-xr-x 2 pi pi 4096 Oct 12 14:26 Desktop
drwxrwxr-x 2 pi pi 4096 Jul 20 14:07 python_games

The -a switch will list all files, including invisible ones:

pi@raspberrypi ~ $ ls -la
total 80
drwxr-xr-x 11 pi   pi   4096 Oct 12 14:26 .
drwxr-xr-x  3 root root 4096 Sep 18 07:48 ..
-rw-------  1 pi   pi     25 Sep 18 09:22 .bash_history
-rw-r--r--  1 pi   pi    220 Sep 18 07:48 .bash_logout
-rw-r--r--  1 pi   pi   3243 Sep 18 07:48 .bashrc
drwxr-xr-x  6 pi   pi   4096 Sep 19 01:19 .cache
drwxr-xr-x  9 pi   pi   4096 Oct 12 12:57 .config
drwx------  3 pi   pi   4096 Sep 18 09:24 .dbus
drwxr-xr-x  2 pi   pi   4096 Oct 12 14:26 Desktop
-rw-r--r--  1 pi   pi     36 Sep 18 09:35 .dmrc
drwx------  2 pi   pi   4096 Sep 18 09:24 .gvfs
drwxr-xr-x  2 pi   pi   4096 Oct 12 12:53 .idlerc
-rw-------  1 pi   pi     35 Sep 18 12:11 .lesshst
drwx------  3 pi   pi   4096 Sep 19 01:19 .local
-rw-r--r--  1 pi   pi    675 Sep 18 07:48 .profile
drwxrwxr-x  2 pi   pi   4096 Jul 20 14:07 python_games
drwx------  4 pi   pi   4096 Oct 12 12:57 .thumbnails
-rw-------  1 pi   pi     56 Sep 18 09:35 .Xauthority
-rw-------  1 pi   pi    300 Oct 12 12:57 .xsession-errors
-rw-------  1 pi   pi   1391 Sep 18 09:35 .xsession-errors.old

Use the mv command to rename a file. The touch command can be used to create an empty dummy file:

pi@raspberrypi ~ $ touch foo
pi@raspberrypi ~ $ ls
foo   Desktop   python_games
pi@raspberrypi ~ $ mv foo baz
pi@raspberrypi ~ $ ls
baz   Desktop   python_games

Remove a file with rm. To remove a directory, you can use rmdir if the directory is empty, or rm -r if it isn’t. The -r is a parameter sent to the rm command that indicates it should recursively delete everything in the directory.

If you want to find out all the parameters for a particular command, use the man command (or you can often use the --help option):

pi@raspberrypi ~ $ man curl
pi@raspberrypi ~ $ rm --help

To create a new directory, use mkdir. To bundle all of the files in a directory into a single file, use the tar command, originally created for tape archives. You’ll find a lot of bundles of files or source code are distributed as tar files, and they’re usually also compressed using the gzip command. Try this:

pi@raspberrypi ~ $ mkdir myDir
pi@raspberrypi ~ $ cd myDir
pi@raspberrypi ~ $ touch foo bar baz
pi@raspberrypi ~ $ cd ..
pi@raspberrypi ~ $ tar -cf myDir.tar myDir
pi@raspberrypi ~ $ gzip myDir.tar

You’ll now have a .tar.gz archive of that directory that can be distributed via email or the Internet.

Processes

Every program on the Pi runs as a separate process; at any particular point, you’ll have dozens of processes running. When you first boot up, about 75 processes will start, each one handling a different task or service. To see all these processes, run the top program, which will also display CPU and memory usage. top will show you the processes using the most resources; use the ps command to list all the processes and their ID numbers (see Figure 2-5).

Figure 2-5. The ps command shows a snapshot of all of the processes currently running on your Pi

Try:

pi@raspberrypi ~ $ ps aux | less

Sometimes you may want to kill a rogue or unresponsive process. To do that, use ps to find its ID, then use kill to stop it:

pi@raspberrypi ~ $ kill 95689

In the case of some system processes, you won’t have permission to kill it (though you can circumvent this with sudo, covered in the next section).

Sudo and Permissions

Linux is a multiuser operating system; the general rule is that everyone owns their own files and can create, modify, and delete them within their own space on the filesystem. The root (or super) user can change any file in the filesystem, which is why it is good practice to not log in as root on a day-to-day basis.

There are some tools like sudo (“superuser do”) which allow users to act like superusers for performing tasks, like installing software without the dangers (and responsibilities) of being logged in as root. You’ll be using sudo a lot when interacting with hardware directly, or when changing system-wide configurations.

Each file belongs to one user and one group. Use chown and chgrp to change the file’s owner or group. You must be root to use either:

pi@raspberrypi ~ $ sudo chown pi garply.txt
pi@raspberrypi ~ $ sudo chgrp staff plugh.txt

Each file also has a set of permissions that show whether a file can be read, written, or executed. These permissions can be set for the owner of the file, the group, or for everyone (see Figure 2-6).

Figure 2-6. File permissions for owner, group, and everyone

You set the individual permissions with the chmod command. The switches for chmod are summarized in Table 2-2.

Here are a few examples of how you can combine these switches:

chmod u+rwx,g-rwx,o-rwx wibble.txt 
chmod g+wx wobble.txt 
chmod -rw,+r wubble.txt 

Allow only the user to read, write, and execute.

Add permission to write and execute to entire group.

Make read-only for everyone.

The only thing protecting your user space and files from other people is your password, so you better choose a strong one. Use the passwd command to change it, especially if you’re putting your Pi on a network.

The Network

Once you’re on a network, there are a number of Linux utilities that you’ll be using on a regular basis. When you’re troubleshooting an Internet connection, use ifconfig, which displays all of your network interfaces and the IP addresses associated with them (see Figure 2-7).

Figure 2-7. The ifconfig command gives you information about all of your network interfaces

The ping command is actually the most basic tool for troubleshooting network connections. You can use ping (think sonar) to test whether there is a two-way connection between two IP addresses on the network or Internet. Note that many websites block ping traffic, so you may need to ping multiple sites to accurately test a connection:

ping yahoo.com
ping altavista.com
ping lycos.com
ping netscape.com 

Fail happens here

To log in to another computer remotely (and securely, with encrypted passwords), you can use the Secure Shell (SSH). The computer on the remote side needs to be running an SSH server for this to work, but the SSH client comes built into Raspbian. In fact, this is a great way to work on your Raspberry Pi without a monitor or keyboard, as discussed in “Running Headless”.

Related to SSH is the sftp program, which allows you to securely transfer files from one computer to another. Rounding out the set is scp, which you can use to copy files from one computer to another over a network or the Internet. The key to all of these tools is that they use the Secure Sockets Layer (SSL) to transfer files with encrypted login information. These tools are all standard stalwart Linux tools.