Navigating through the Filesystems

In this chapter, we will revisit the concepts of a file, which were discussed briefly in Chapter 1. You will learn in detail about the filesystem (FS) in Linux and its specifics. We will not go to certain filesystem implementations, as you will see there’re many, but we will establish the fundamentals of working with them. You will learn more about Linux’s FS hierarchy – its partitions, object types, and some frequently used operations.

You will get familiar with the filesystem library in C++, allowing you to execute system operations independently from the platform. We will use C++ examples to show you simple applications for file management. You’re also going to learn about string_views. Some of the operations you learn about here will be revisited again in Chapter 5, when we will discuss error handling.

Last but not least, you will learn hands-on about the fundamental inter-process communication (IPC) mechanism...

Technical requirements

In order to run the code examples, the reader must prepare the following:

• A Linux-based system capable of compiling and executing C and C++20 (for example, Linux Mint 21):
  • gcc12.2 compiler: https://gcc.gnu.org/git/gcc.git gcc-source
  • g++ with -std=c++2a flags for the C++ code
  • gcc without flags for the C code
• For all the examples, you can alternatively use https://godbolt.org/.
• Code examples could be found here: https://github.com/PacktPublishing/C-Programming-for-Linux-Systems/tree/main/Chapter%203

Going through Linux’s filesystem fundamentals

We went through some of the Unix (and Linux) filesystem definitions in Chapter 1. Let’s see how they really matter in the bigger picture of system programming. You probably remember what types of files there are in the Linux system – regular files, directories, special files, links, sockets, and named pipes. We are going to deal with most of them in this chapter and learn about what purpose they serve. One way to think about files in Unix, including Linux, is the following simple statement:

“On a UNIX system, everything is a file; if something is not a file, it is a process.”

So, everything that’s not a process has an API, which includes file operation system calls. Let’s agree that a file is the main instrument for the logical organization of data. Then there must be something that is the main instrument for file organization. Well, this is where the file management system, or simply...

Executing FS operations with C++

With C++17 FS operations that are closer to the system programming are facilitated. The FS library allows the C++ developer to distinguish between the Linux fs types and perform certain operations with them. Let’s take a look at an exemplary interface:

bool is_directory(const std::filesystem::path& p)

This method checks whether a given pathname is a directory. In a similar fashion, we can do the other type checks – is_fifo(), is_regular_file(), is_socket(), and is_symlink(). Can you tell why we don’t have the is_hardlink() method? That’s right – if two files with different character names point to a single inode, then both of them provide access to the same content. It doesn’t matter whether the inode’s hard link counter is higher than one, although we could get it through the hard_link_count() method.

As the C++ language is compilable on multiple OSes, the FS functions are also dependent...

IPC through anonymous pipes and named pipes

Before we even start working on this topic, let us ask you this. Have you ever done the following:

$ cat some_data | grep data
some data

If yes, then you probably call | a pipe. Where does this come from? Well, you actually pipe the output from one process as an input to another. You can do it with your own code as well – we are not limited to the system’s applications. And we can program this pipe communication in our own code, too. This is a fundamental instrument for the data transfer between processes. Do you remember reading earlier about FIFO files and named pipes? Yes, that’s right – they are the same thing, but is the |-symbolled pipe the same as them? No! That’s an anonymous pipe. System programmers differentiate between the so-called anonymous pipes and the named pipes. They have different purposes, so both of them are found on Linux systems nowadays. They are created and managed by pipefs...

Briefly observing signal handling

Signals in Linux are a powerful and simple way to synchronize processes through software interrupts sent to them, indicating that an important event has occurred. They have a different nature, depending on their roles. Some of them are ignorable, while others are not and cause a process to be blocked, unblocked, or terminated. We discussed those behaviors in the previous chapter, but is there something we could do to gracefully handle them? We will use the anonymous pipe example to trigger a SIGPIPE signal.

Let’s see the following example:

...
void handle_sigpipe(int sig) { // {1}
   printf("SIGPIPE handled!\n");
}
int main() {
   int an_pipe[2] = {0};
   char buff[BUFF_LEN + 1] = {0};
   if (pipe(an_pipe) == 0) {
      int pid = fork();
      if (pid == 0) {
        ...

Summary

In this chapter, we didn’t show any examples of file data modifications through C++. Our goals were mostly related to explaining the different Linux FS entities. We use the C++ filesystem library to enrich the knowledge in this direction – for example, improving system programming awareness. You learned about the roles of the different FS objects and their specifics. You also have the C++ instruments to manage file resources and level up your abstraction. There were also some hands-on examples of how to communicate between processes through anonymous and named pipes. Their implementation at the OS level was discussed as well, and we briefly explored signal handling in Linux.

In the next chapter, we will finally dive deeper into the C++ language, laying the foundations for its safe and secure usage, according to the latest standard. Later in the book, we will revisit some code segments shown in this chapter. We will continuously improve them through the usage...