This chapter covers viewing interrupts. It focuses on /proc/interrupts, CPU info viewing (/proc/cpuinfo), and viewing the physical memory installed. It also looks at /proc/meminfo, the free command, viewing swap memory, and adding and removing additional swap memory using the dd, mkswap, swapon, and swapoff commands. The raid status (viewing/proc/mdstat) is outlined, as is the /dev devices directory, the /proc virtual directory, the lsmod command and its usage, the modprobe command and its usage, and the lspci command and its usage. The /proc directory is a virtual filesystem that is created upon boot up, which stores various items of hardware information about a system.

Navigating through the various directories and using these commands is very informative, and allows you to retrieve hardware information in a Linux environment.

We will cover the following topics in this chapter:

• Viewing CPU, RAM, and swap info
• Interrupts and devices
• Modules

Let's take a look at how we can view CPU, RAM, and swap info on a Linux system.

First, we will focus our attention on gaining information on a CPU, so we will look at the /proc/cpuinfo file. We can garner detailed information about the CPU, ranging from the vendor ID, the CPU family, the model name, the CPU rate in MHZ, its cache size, and the number of cores, to name a few. Here is an excerpt from running the cat command alongside /proc/cpuinfo:

Some more information is given here about the CPU:

From the preceding output, we can see detailed information pertaining to the CPU that we ran the cat /proc/cpuinfo command against.

Next, let's take a look at how we can gather information on the amount of physical memory, the Random Access Memory (RAM), installed in a system. We will focus on two commands: the cat /proc/meminfo and the free commands.

Using the Linux system for demonstration once again, we will look at the output of the cat /proc/meminfo command:

Some more memory usage information is shown in the following screenshot:

From the preceding output, we can see some important fields, namely the first three fields (MemTotal, MemFree, and MemAvailable), which reflect the current status of our physical memory (RAM).

Now let's look at another command, the free command. This command will give us the memory information in a more human-readable format. Using our test Linux system, we will run the free command:

Running the free command on its own yields the preceding results in kilobytes. We can tag some options onto the free command to be even more explicit. Here is a list of options that we can use with the free command, using an Ubuntu distro:

These are some more options that we can pass with the free command on an Ubuntu distro:

Similarly, if we take a look at the main page of the free command on a CentOS 7 distribution, we can see similar options:

Some more options that we can pass with the free command on a CentOS 7 distro are shown in the following screenshot:

Let's try a few of the options with the free command:

The preceding output is by far one of the most commonly used options (-h) with the free command. We can even take it a step further by tagging on the (-g) option to display the total amount of physical memory in gigabytes:

We can even see the low and high memory statistics by using yet another fantastic option, the (-l) option:

In the preceding screenshot, we are not just shown the RAM information, but also our swap memory. This is displayed in the last row. We can use another command if we prefer to see only the swap memory. Here, we can use the swapon command:

Here are some options that can be used with the swapon command from the main page of swapon on an Ubuntu distro:

Some more options that can be passed with the swapon command on an Ubuntu distro are shown in the following screenshot:

Here are some options that can be used with the swapon command from the main page of swapon on a CentOS 7 distro:

Some more options that can be passed with the swapon command on a CentOS 7 distro are shown in the following screenshot:

We can also see swap information from within the /proc directory, specifically in /proc/swaps:

From the preceding output, we can see that the swap space is using the /dev/sda4 partition. Now, if for some reason we run out of physical memory and we have maxed out our swap space, then we can either add more physical memory or add more swap space. So, let's focus on the steps to add more swap space.

We will need to create a blank file using the dd command. Note that you need root access to run this command at the shell:

trainer@trainer-virtual-machine:~$ dd if=/dev/zero of=/root/myswapfile bs=1M count=1024
dd: failed to open '/root/myswapfile': Permission denied
trainer@trainer-virtual-machine:~$

From the preceding output, we can see that we got a Permission denied message, so let's switch to the root and try to rerun that command:

root@trainer-virtual-machine:/home/trainer# dd if=/dev/zero of=/root/myswapfile bs=1M count=1024
1024+0 records in
1024+0 records out
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 17.0137 s, 63.1 MB/s
root@trainer-virtual-machine:/home/trainer#

There we go; we've just created a swap file using the name myswapfile. Now we need to run the mkswap command and call the swap file that we just created at the shell:

root@trainer-virtual-machine:~# mkswap myswapfile
Setting up swapspace version 1, size = 1024 MiB (1073737728 bytes)
no label, UUID=e3b8cc8f-ad94-4df9-8608-c9679e6946bb
root@trainer-virtual-machine:~#

Now, the last step is to turn on the swap file so that the system uses it as needed:

root@trainer-virtual-machine:~# swapon myswapfile
swapon: /root/myswapfile: insecure permissions 0644, 0600 suggested.
root@trainer-virtual-machine:~#

We've got that warning message telling us about insecure permissions. We will discuss permissions in a later chapter. For now, we will continue to use the existing permissions. The last step is to verify that the swap file is indeed available to our system:

root@trainer-virtual-machine:~# swapon
NAME                TYPE       SIZE   USED    PRIO
/dev/sda4           partition  5.9G   960K    -1
/root/myswapfile    file       1024M   0B     -2
root@trainer-virtual-machine:~#

And, voila, we now have the newly created swap file at our system's disposal. We can also run the free command, and we will now find that the swap memory has increased by one gigabyte:

root@trainer-virtual-machine:~# free -h
      total   used   free  shared  buff/cache   available
Mem:  1.9G    848M    72M   13M    1.0G        924M
Swap: 6.8G    960K    6.8G
root@trainer-virtual-machine:~#

Should we no longer want to use a swap file, we can use the swapoff command to remove myswapfile from the swap memory. Here is how we would accomplish this at the shell:

root@trainer-virtual-machine:~# swapoff myswapfile
root@trainer-virtual-machine:~#

Now let's rerun the swapon command followed by the free command to verify that myswapfile is indeed removed from swap usage:

root@trainer-virtual-machine:~# swapon
NAME       TYPE      SIZE   USED   PRIO
/dev/sda4 partition  5.9G   1.6M   -1
root@trainer-virtual-machine:~# free -h
       total   used    free   shared  buff/cache available
Mem:   1.9G    931M    133M   17M     917M        845M
Swap:  5.8G    1.6M    5.8G
root@trainer-virtual-machine:~#

As we can see, myswapfile is no longer available for use as swap memory. Here are the options we can use with the swapoff command on an Ubuntu distro:

Some more options that can be passed with the swapoff command are shown in the following screenshot:

Here are the options we can use with the swapoff command on a CentOS 7 distro:

Some more options that can be passed with the swapoff command are shown in the following screenshot:

Now let's switch gears and look at the Interrupt Requests (IRQs) and devices that are available in our Linux system. You can think of an interrupt as a service hotline that we would use whenever we need a particular item. We would ring a service hotline. The theory remains the same for devices within a Linux system; whenever it requires the CPU's attention, it sends out signals via interrupts. Traditional 32-bit architectures support up to 16 interrupts (0-15, as shown in the following screenshot). Newer architectures support far more than 16 interrupts.

Let's take a look at the /proc directory once again, honing in on /proc/interrupts:

More interrupts are shown in the following screenshot:

Some more interrupts are shown in the following screenshot:

From the preceding output, we can see that there are far more interrupts available. The output is read from left to right, where left represents the interrupt number, and moving to the right indicates the devices or services that are using the interrupts. We can see that the timer is using interrupt 0.

Now, let's turn our attention to devices. When we work with devices in a Linux system, the devices are represented by files. This enables us to communicate with the actual hardware in the system. There are some commonly used devices, such as hard disks, DVDs, and USBs, to name a few. Hard disks are represented as sd(n). For example: /dev/sda, /dev/sdb, /dev/sdc, and so on. Hard disk partitions are represented in the form of sd(n). For example: /dev/sda1, /dev/sda2, /dev/sdb1, and so on. Similarly, floppy disks are represented as fd. There are some special use-case files, such as /dev/null, /dev/zero, and /dev/tty*. You would use /dev/null when you want to send output from another command and the output is not needed. This is known as redirecting. /dev/zero is used in conjunction with the dd command that we covered earlier for creating blank files. /dev/tty* is used for remote logins. Let's take a look at how devices are shown in the Linux environment.

We will take a look at /proc/devices using our test Linux system:

From the preceding output, the hard disk and partition are represented in the format of /dev/sdXY, where X represents the hard disk and Y represents the partition. We can tell the ls command to filter the output to only the hard disk and partition information as follows:

root@trainer-virtual-machine:~# ls /dev/sd*
/dev/sda  /dev/sda1  /dev/sda2  /dev/sda3  /dev/sda4
root@trainer-virtual-machine:~#

Have you ever wondered what happened to the term drivers in a Linux environment? Well, wonder no more. Most people coming from a Microsoft Windows background are accustomed to interacting with hardware through the use of drivers. In Linux, we refer to drivers as modules. This isn't as scary as it sounds. We load and unload modules whenever we are working with a piece of hardware. For example, when we plug in a USB drive, a module is loaded into the backend and is unloaded automatically when we remove the USB drive. It's that flexible.

Let's take a look at how we can view the modules that are installed in the Linux system using the lsmod command:

More modules that are available for use are shown in the following screenshot:

From the preceding output, we can see that a number of modules are available for use in this Linux system. We read the output from left to right. Wherever we see a 0 value under the Used by column, it means that the module is not currently in use.

Now let's look at the process to remove a module using the rmmod command. We will remove the usbhid module, since it's not currently in use. We can quickly verify this is not in use by using lsmod | grep usbhid:

root@trainer-virtual-machine:~# lsmod | grep usbhid
usbhid                 49152  0

Great! Let's go ahead and remove that module using the rmmod command:

root@trainer-virtual-machine:~# rmmod usbhid
root@trainer-virtual-machine:~#
root@trainer-virtual-machine:~# lsmod | grep usbhid
root@trainer-virtual-machine:~#

There we go; the usbhid module is no longer loaded in the Linux system. It still resides there, however, because it was compiled in the kernel. There are only a few options to pass with rmmod. Here, they are on an Ubuntu distro:

Similarly, here are the options to pass with the rmmod on a CentOS 7 distro:

In order for us to reinstall this usbhid module, we will use another popular command: insmod. Let's see how insmod works at the shell:

root@trainer-virtual-machine:~# insmod usbhid
insmod: ERROR: could not load module usbhid: No such file or directory
root@trainer-virtual-machine:~#

Now, based on the preceding output, it may seem to be contradictory that the insmod command is unable to find the usbhid module. Don't worry, this module is compiled in the kernel. That being said, we can use yet another helpful command, modprobe. This, by far, is more popular than insmod, as modprobe actually calls insmod in the backend whenever we add a module using modprobe. Interestingly enough, modprobe can be used to remove module(s) too. It does this by calling rmmod in the backend.

So, let's use modprobe to install the usbhid module at the shell.

root@trainer-virtual-machine:~# modprobe -v usbhid
insmod /lib/modules/4.4.0-24-generic/kernel/drivers/hid/usbhid/usbhid.ko
root@trainer-virtual-machine:~#

We used the (-v) option with modprobe because, by default, it will not show what is happening in the background. As you can see, modprobe is indeed calling insmod in the backend. Now we can remove this usbhid module using modprobe, and we will see that it is calling rmmod in the backend:

root@trainer-virtual-machine:~# modprobe -r -v usbhid
rmmod usbhid
root@trainer-virtual-machine:~#

From the preceding output, it is evident that modprobe is calling rmmod to remove a module.

Here are some options that can be used with the modprobe command on an Ubuntu distro:

More options that can be passed with the modprobe command are shown in the following screenshot:

Some more options that can be passed with the modprobe command are shown in the following screenshot:

Here are some options that can be used with the modprobe command on a CentOS 7 distro:

Some more options that can be passed with the modprobe command are shown in the following screenshot:

More options that can be passed with the modprobe command are shown in the following screenshot:

In this chapter, we focused on hardware settings, looking at the CPU, RAM, and swap information in the various directories. We used a variety of commands. Also, we touched on IRQs and the various interrupts available in a Linux system. We then looked at devices, in the context of files. Finally, we worked with modules. We saw the various modules currently available in a Linux system, and learned the steps to install and remove a module.

In the next chapter, we will focus on the process of booting the system. Moreover, the various boot managers will be covered. This is another critical aspect for every Linux engineer to get to grips with. Simply put, without a boot manager, the system won't be able to boot unless we boot off some form of media. Gaining the knowledge will put you, as a Linux engineer, ahead of other so-called engineers. You will be at a greater advantage regarding certification after completing the next chapter.

1. Which directory is created as a virtual file system?

A. /dev
B. /lib
C. /proc
D. None of the above

2. What is the command to view the CPU info?

A. less /proc
B. more /proc
C. cat /proc
D. cat /proc/cpuinfo

3. What is the command to view the RAM inside the /proc directory?

A. tail /proc/free
B. less /proc/free
C. cat /proc/meminfo
D. cat /proc/RAM

4. Which option is used with the free command to display the memory info in a friendly format?

A. free -F
B. free -L
C. free -h
D. free –free

5. Which command is used to tell the system that a file is a swap file?

A. doswap
B. format swap
C. mkswap
D. swap

6. Which command is used to activate a swap file?

A. Swap
B. onSwap
C. swap
D. swapon

7. Which command is used to display the swap-partition info?

A. mkswap
B. swapon
C. swap
D. swapoff

8. Which device file can redirect messages to be sent for discard?

A. /dev/discard
B. /dev/null
C. /dev/redirect
D. None of the above

9. Which command is used to display the currently available modules in a Linux system?

A. insmod
B. depmod
C. rmmod
D. lsmod

10. Which command is used to install a module without having to specify the absolute path?

A. rmmod
B. modules
C. modrm
D. modprobe

• This website will give you all of the necessary information about the current CompTIA Linux+ certification: https://www.comptia.org/
• This website will give you details relating to LPI exams, specifically the LPIC-1 that you earn by passing both CompTIA Linux+ exams: http://www.lpi.org/
• This last website gives you details about the various Linux kernels available: https://www.kernel.org/