File Metadata and Inodes

Everything is a file descriptor in Linux. A file descriptor is a number that uniquely identifies a file that is open on an operating system. The file descriptor contains information about the opened file. Every file has certain key attributes to identify its properties. Regular files include images, audio, video, and other raw files that usually have metadata associated with them. All the file attributes are stores in an inode.

An inode is a data structure that tracks all the information about a file. An inode plays a very crucial role in Unix-based operating systems. When a user wants to access a file, the operating system first searches for the inode number in an associated inode table. The storage of inode numbers in an operating system and finding a particular file using the path is explained in Figure 4-3. Every inode has a unique number. An inode number is the index number that is associated with each inode. OS searches for an inode number come from an inode table. The Unix storage system is a bit different from the Windows storage system, but it is more efficient. The structure of an inode is represented in Figure 4-2.

Figure 4-3 shows an inode pointing mechanism structure that represents accessing a file named script.ts on the operating system. Suppose that a user wants to access a file on the operating system at /root/Desktop/WebDev/script.ts.

Initially, the root directory has a specific inode number that points to the root number. It consists of several files and folders. In our situation, the root directory has home, desktop, documents, and downloads directories. The desktop directory has an inode number that consists of several lists of files and folders (i.e., Python, Web Dev, Courses directories, and a helloworld.c program file).

Each directory and program file has its own inode number. When I navigate to the Web Dev directory, it has a separate inode number that points to another set of files and directories (that include index.html, style.css, script.js, script.ts), which have different inode numbers. The searched file is available in the Web Dev directory. If the given file name is not available in the specified location, an error is immediately thrown. All the inode numbers are internally connected to provide better and faster access to files and directories.

When you enter a directory and input the ls command in the command line, all the files and directories in that directory are displayed based on the inode number. This happens because of all the inode numbers of files and directories in that directory point to an array of inode numbers that point to the parent directory. This is represented in Figure 4-3; for example, the desktop inode is pointing to six different inode numbers. Those are the files and directories in the desktop directory.

creat

This system call creates a new empty file with a system call. It is available in the fcntl.h library, which is a file handling library for Unix and Linux. The return type for this function is an integer. If file creation is successful, it returns a non-negative integer. If the creation of the file fails, it returns –1.

If you want to use multiple modes at the same time, you can use the bitwise OR operator.

A file descriptor is an integer value that identifies the open file in a process. This program creates a new file with the given permissions set.

open

The open system call function opens a file and can perform read and write operations based on the mode set to the function. An open system call can also create a file. If the specified filename is not available, then it automatically creates a new file with the given name. The return type of this function is an integer. If the file opens successfully, it returns a positive integer value; otherwise, it returns –1.

This program prints a statement on whether the given file is open or not.

close

This system call closes the file descriptor that was created to open, create, or read the contents in a file. The return type of this function is an integer. If the file descriptor is closed successfully, it returns 0; otherwise, it returns –1.

file_descriptor is an integer value that identifies the open file in a process.

This program opens a file and closes the file descriptor after the task is done. After the file descriptor is opened and work is done, it is a good programming practice to close the descriptor.

read

This function system call reads the content of a file that was indicated by a file descriptor. The return type of this function is an integer. It returns –1 if an error occurs or when any signal interrupt occurs during a read operation. A successful read of a file returns the number of bytes read during the operation.

This program prints the number of bytes that were read and then prints the content.

write

This function writes content to a given file descriptor. The return type of this file is an integer. It returns –1 for an error or if any signal interrupt is raised; otherwise, it returns the number of bytes that are returned to a file.

This function syntax is the same as the read function. But the key difference is that it writes the content to a file using the buffer. The read function reads the content from a file using a buffer.

This code opens a given file and asks the user to enter the content that they want to write to it. The write function writes content and prints the number of bytes written to a file.

Append Operations in Files Using System Calls

A write system call writes the content to the given file descriptor. But the O_RDWR flag mode overrides the content in an existing file. If you want to add more content to a file without overriding the existing content, the O_APPEND flag adds the new content at the end of the file without overriding any of the existing content.

This program appends content to an existing file without overwriting it.

chmod Function to Change Permissions

The chmod system call is available in the fcntl.h library. It changes the file permissions using the C program. The return type of this function is an integer. It returns 0 if it is successful and –1 if failure occurs.

This program changes the permissions of a file. It returns a success statement if successful and returns a failure message if it is unable to change the permissions.

File Permissions Check

You can check a file’s permissions with the access function in C, which is available in the unistd.h library. This return type of this function is an integer. It returns 0 if successful and –1 if failed.

This program tests the read and write access of a file and prints the output (i.e., read or write). You can modify the code to test execute permissions as well.

Soft Links

A diagram of symbolic links is shown in Figure 4-5.

Creating a Soft Link Using the Command Line

The creation of a soft link is done with the ln command and some extra flags. Let’s look at creating a soft link.

ln -s <file_name> <softlink_name>

Note

The soft link name is your choice; there are no restrictions on for user’s name.

Figure 4-6 shows an example.

Unlinking a Soft Link

When a soft link is created, a link file is too. There are two ways to remove these links from the file.

• Delete the link file

rm <soft_link_name>

• Unlink the file

unlink <soft_link_name>

After the unlinking action is done, the soft link is no longer available in the system. Let’s closely look at the example shown in Figure 4-7.

Hard Links

Figure 4-8 is a diagram of a hard link.

Creating a Hard Link Using a System Call

The creation of a hard link is done with a link system call. This system call function is available in the unistd.h library. It returns an integer value: 0 for a success and –1 for a failure.

The following shows the syntax.

int link(const char *filepath,

         const char *linkname);

• filepath takes its name as an argument where the file is located in the system.

• linkname takes the link name as an argument. You can also provide the path where you want to store it.

Here’s an example.

#include<stdio.h>

#include<unistd.h>

int main(){

   int link_status;

   char filepath[50], linkname[50];

   printf("Enter the filename: ");

   scanf("%[^ ]%*c", filepath);

   printf("Enter the linkname: ");

   scanf("%[^ ]%*c", linkname);

   link_status = link(filepath, linkname);

   // Hardlink be Created.

   // 0 ---> Successful || -1 ---> Failure.

   if(link_status == 0){

       printf("HardLink is Created Successfully.!");

   }else{

       printf("Unable to Create the Hard Link.");

   }

   return 0;

}

This program creates a hard link and prints the success message if appropriate. If any error occurs, it prints a failure message.

Note

The unlinking of both the hard and soft links can be done in the same command (i.e., using either the rm command or the unlink command. Programmatically, the same unlink system call which is available in the unistd.h unlink the link that is created. Once the link is unlinked, it is deleted from the system.

Creating a Directory

The creation of a directory is done with the mkdir function , which is available in the sys/stat.h library. The return type of this function is an integer. It returns 0 on the successful creation of a directory; it returns –1 for a failure.

This creates a new directory and prints a success message if the creation operation is successful; otherwise, it prints an error message.

Deleting a Directory

The deletion of a directory is done with the rmdir function, which is available in the sys/stat.h library. The return type of this function is an integer. It returns 0 on the successful deletion of a directory; it returns –1 if a failure.

This program deletes the directory from the system and prints a success message for a successful operation; otherwise, it returns a failure message.

Getting the Current Working Directory

The getcwd function gets the current working directory. It is available in the unistd.h library. The return of this function is a character data type. It returns the program’s current working directory.

This program prints the current working directory when a success; otherwise, it prints NULL.

Changing Directory

There is a chdir system call that changes directory in your operating system. It is available in the unistd.h library. The return type of this function is an integer. It returns 0 on the successful change in a directory; it returns –1 for a failure.

This program changes the working directory of the calling process.

Reading a Directory

Two types of functions read the content in directories: opendir and readdir. They are available in the dirent.h library. The return type of the opendir function is the directory stream.

A directory stream is an ordered sequence of all directory entries in a directory. A directory entry represents the files. This directory stream points to the start position.

The return type of readdir is a dirent structure, which returns NULL if the directory reaches its end. Dirent is a built-in structure that is implemented in the dirent.h library.

This program returns all the files and folders present in the given location.

Closing a Directory

The closedir function closes the directory stream that is running in a process. The return type of this function is an integer. It returns 0 on the successful closing of a directory; it returns –1 for a failure.

This program prints the success statement if the directory is closed successfully; otherwise, it prints a failure message.