Mkfifo: how it works (en)

From OnnoWiki
Jump to navigation Jump to search

mkfifo stands for make first-in-first-out. It is a command in Unix-based operating systems like Ubuntu that is used to create a *named pipe*. A pipe is an inter-process communication mechanism that allows one process to write data into the pipe while another process reads that data.

Difference between `mkfifo` and a regular pipe:

  • Regular pipe: Created dynamically when two processes communicate and disappears once the communication ends.
  • Named pipe: Permanently created in the file system, allowing different processes to access it at any time as long as the pipe exists.

Why Use `mkfifo`?

  • Inter-process communication: Ideal for connecting two or more independently running programs.
  • Synchronization: Can be used to synchronize activities between processes.
  • Gradual data processing: Data can be written and read incrementally, allowing for more efficient data processing.

How to Use `mkfifo`

Creating a named pipe:

mkfifo pipe_name

Example:

mkfifo mypipe

The above command creates a named pipe called `mypipe` in the current directory.

Accessing a named pipe:

  • Reading from the named pipe:
cat < pipe_name
  • Writing to the named pipe:
echo "Hello" > pipe_name

Usage Example:

Suppose we have two scripts:

  • Script 1 (writer):
 #!/bin/bash
 while true; do
     echo "Data from script 1" > mypipe
     sleep 1
 done
  • Script 2 (reader):
 #!/bin/bash
 while true; do
     read line < mypipe
     echo "Received data: $line"
 done

Script 1 will continuously write data to `mypipe` every second, while script 2 will continuously read data from `mypipe` and display it on the screen.

Additional `mkfifo` Options

  • `-m mode`: Set the access permissions for the named pipe.
  • `-Z context`: Set the SELinux security context for the named pipe.

Real-World Use Cases

  • Transferring data between two programs: For example, redirecting output from one program to the input of another.
  • Implementing a simple queue: Data written to the named pipe will be processed sequentially by the reading process.
  • Communication between parent and child processes: The child process can read commands from the parent process through a named pipe.

Conclusion

mkfifo is a highly useful tool for building more complex and efficient systems on Ubuntu Server. By understanding how it works, you can leverage it for various purposes, from inter-process communication to implementing synchronization mechanisms.

Interesting Links