Inter process communication using Message Queues (mq) -1

Message queues are one of the many ways of communicating among processes in linux.

Message queues communicate by sending and reciveing messages, over a common queue. The sender sends the message by writing to the queue and recieves by reading from the queue.

The following are some of the commonly used functions with respect to message queues.

To create or open a message queue we use the function mq_open:

mqd_t mq_open(const char *name, int oflag, mode_t mode,struct mq_attr *attr) Arguments: name : Name of the message queue oflag : Flags which control the operation of the queue. The various possible flags are : One of the flags O_RDONLY , O_WRONLY, O_RDWR Optionally ored with: O_NONBLOCK, O_CREAT, O_EXCL. Note: The description of the flags can be found in the man pages. When a new message queue has to be created along with the above two argumetns these two are also mandatory mode: Which specifies the permissions of the queue. attr: A structure which sets the attributes, like message size, number of messages etc. If set to NULL it is initalized to default values. It has been explained further below.

Retrun:

The function returns a data type mqd_t which is a descrpitor for the message queues. In case of a error it returns -1.

Setting and getting attributes :

The attributes of the message queue are stored in a structure mq_attr.

struct mq_attr { long mq_flags; /* Flags: 0 or O_NONBLOCK */ long mq_maxmsg; /* Max. # of messages on queue */ long mq_msgsize; /* Max. message size (bytes) */ long mq_curmsgs; /* # of messages currently in queue */ };

The fields of these structures can be read by using the function int mq_getattr(mqd_t mqdes, struct mq_attr *attr); Arguments : mqdes : The queue descriptor returned by the open call. mq_attr: A pointer to a buffer to which the attribute structure will be returned.

To change the attributes of an already existing queue we can use the function

int mq_setattr(mqd_t mqdes, struct mq_attr *newattr,struct mq_attr *oldattr); Arguments: mqdes : The queue descriptor returned by the open call. newattr: Pointer to the structure with the new attribute values oldattr: Pointer to the structure of the current attr gets returned to this buffer like the mq_getattr or it can be left as NULL.

Sending and recieving messages :

Once the message queue is opened successfully, the process can communicate with the queue using the queue descriptor along with the functions mq_send to send a message and mq_recieve to recieve a message.

Sending:

int mq_send(mqd_t mqdes, const char *msg_ptr,size_t msg_len, unsigned msg_prio);Arguments : Arguments mqdes : The queue descriptor returned by the open call msg_ptr: Pointer to buffer that holds the message to be transfered msg_len: Length of the message that has to be transfered msg_prio: Priority of the message, Messages are placed on the queue in decreasing order of priority

Receieving:

ssize_t mq_receive(mqd_t mqdes, char *msg_ptr,size_t msg_len, unsigned *msg_prio); Arguments mqdes : The queue descriptor returned by the open call msg_ptr: Pointer to buffer where the received message has to be placed msg_len: mq_msgszie for the queue which is being read from. msg_prio: This recives the priority of the message that was recieved.

Using the above set of functions we can set up a message queue and communicate between processes using them. In the next few posts we will see examples of how to use the above mentioned functions.

Changing the font and background of a terminal

In almost all the linux distributions the default terminal that opens is with black text and white back ground or when you log into the text mode it would be black background with white font.

Not everyone is fond of such simple looks and if you are one of them then here are a few ways you can change that look.

Using GUI:

Go to edit->"Profile preferences" and from the tabs, color and background you can set the color for the text as well as the backgroud.

This is possible only when you are using the terminal in the GUI, but not when you log in using the text mode.

Here are two to modify the color of the font as well as the background, even when in the text mode .

tput:

To change the font run the command

tput setaf <Any number from 0 to 7>

e.g.:

tput setaf 1

This will make the font to appear in red. There are 8 possible colors for the 8 different numbers.

Similarly for changing the background color

tput setab <Any number from 0 to 7>

e.g.:

tput setab 2

This will set the background to green.

To make the font bold:

tput bold

To go back to the default colors run the command

tput reset

setterm:

This command does not work in the GUI but works in the text mode.

To change the color of the font pass the option forground to the command

setterm -foreground <color>

Where the color could be one of the following :

black, red, green, yellow, blue,magenta, cyan, or white

e.g.:

setterm -foreground red

Similarly to change the background of the font pass the option "background" with the color.

setterm -background <color>

e.g.:

setterm -background green

To make the font bold

setterm -bold on

To go back to the default settings

setterm -reset

Creating a template for text files with some default text

Very often while writing programs or text documents, we use a certain content in every file we write. For eg almost every "c" file has the following lines

#include<stdio.h> main() { }

To avoid typing this repeatedly we can create a template which we can use to intialize our file with the default text.

Here are a two ways we can do it using shell scripting.

1. Taking the same example of a "c" file as above we can create a script as below

#!/bin/bash echo "#include<stdio.h>" > $1 echo "main()" >> $1 echo "{" >> $1 echo "}" >> $1 vi $1

In the above script the first set of echo commands are for the text we want our text file to have.

Let us call this script as template.sh

To this script we will pass the new file name which we want to create and use the "vi" editor to open it for editing.

To open a file by the name test having the required contents already entered i in it run the script as follows.

./template.sh test1

You should see a new file opened in the vi editor with the following contents.

#include<stdio.h> main() { }

2. The second way doing the same, especially when the text to be entered is more than a few lines we can create a file that has the required text and use the same to create the new file.

For eg:

Let us create a new file called "template" and put the required contetns into it

template: #include<stdio.h> main() { }

Let us say the above file is saved at the location /home/user/template.

We can use this file as shown in the script below

#!/bin/bash if [ $# -lt 1 ] then echo "Please enter a file name" exit fi echo "Please enter the path for the template file" read path cat $path >$i vi $i done

save the script as template2.sh and execute it as follows

./template2.sh test Please enter the path for the template file /home/user/template

A new file by the name test should get created which has the contents of the file template in it.

Below is a script that combines the above two into one, and makes it more dynamic such that it is able to create any number of files whose names are passed on the command line .

template.sh: #!/bin/bash if [ $# -lt 1 ] then echo "Please enter a file name" exit fi echo "Do you have template file y/n" read choice if [ $choice = "y" ] then echo "Please enter the path for the template file" read path fi for i in $@ do if [ $choice = "n" ] then echo "#include<stdio.h>" > $i echo "main()" >> $i echo "{" >> $i echo "}" >> $i else cat $path >$i fi vi $i done

To make this command work from any terminal you want, copy this script to /usr/bin as follows

Note: This will prompt for your password and you will be able to execute this only if you have root permissions.

sudo cp template.sh /usr/bin/.

If that is successful, you can call this command from any where in the system and create ths files with default text in it, all you have to do is modify the script with the text that you want.

Running shell commands from the vi editor

If you are fond of vi editor or use it a lot because you have to, here is small tip that might be helpful.

We can execute the shell commands while working with the editor. To this go the command mode by pressing "esc" and to execute a shell command first type ":!" and then the command.

:! "command "

Let us say we want to look at the contents of the current working directory with out exiting the editor then we can do it as follows

:! ls

Inter process communication using named pipes(FIFO) in linux

In the last post we saw the how to create pipes for communication between processes in linux.

One of the major disadvantage of pipes is that the they can not be accesed using their names by any other process other than child and the parent as they do not get listed in the directory tree.

The work around for this porblem is to create a named pipe which is also called as a FIFO, which stands for First in First out, meaning the data that is written into the pipe first will be read out first always.

The fifos get listed in the directory tree and any process can access it using its name by providing the approproiate path.

fifo are created using the function mkfifo() which takes as arguments

1. The name of the fifo that has to be created
2. The permissions for the file.

Once the file is created, it needs to be opened using the system call open() and the data can be read and written from the file using read() and write system calls.

One of the examples you can think of using a named pipe is communication between a server and a client. If ther are two fifos one of the server and the other of the client, then the client can send request to the server on the server fifo which the server will read and respond back with the reply on the client's fifo.

Another advantage of a fifo over the pipes is that fifo are birectoinal, that is the same fifo can be read from as well and written into.

Here is an example the demostrates the working of fifos.

First we will create two fifos one called the server and the other called the client.

create_fifo.c:

#include<stdio.h> #include<fcntl.h> #include<stdlib.h> main() { int file1,file2; int fd; char str[256]; char temp[4]="how"; char temp1[4]; file1 = mkfifo("fifo_server",0666); if(file1<0) { printf("Unable to create a fifo"); exit(-1); } file2 = mkfifo("fifo_client",0666); if(file1<0) { printf("Unable to create a fifo"); exit(-1); } printf("fifos server and child created successfuly"); }

Save the above program as create_fifo.c and compile is using gcc as follows

cc create_fifo.c -o create_fifo

If the compilation is successfull, run the program as follows

./create_fifo

If there are no errors, then two fifo should have got created in your current working directory. To confirm this run the command the "ls -l" in your current workind directory and you should see some thing like this.

If you notice the first column of the row containing fifo_server and fifo_client, you can see the letter "p" which signifies that it is a pipe.

Now to use these pipes, we will write two program's one to represent the server and other to represent the client. The server will read from the pipe fifo_server to which the client will send a request. On reciveing the request, the server will send the information to the client on fifo_client.

server.c

#include<stdio.h> #include<fcntl.h> main() { FILE *file1; int fifo_server,fifo_client; int choice; char *buf; fifo_server = open("fifo_server",O_RDWR); if(fifo_server<1) { printf("Error opening file"); } read(fifo_server,&choice,sizeof(int)); sleep(10); fifo_client = open("fifo_client",O_RDWR); if(fifo_server<1) { printf("Error opening file"); } switch(choice) { case 1: buf="Linux"; write(fifo_client,buf,10*sizeof(char)); printf("\n Data sent to client \n"); break; case 2: buf="debian"; write(fifo_client,buf,10*sizeof(char)); printf("\nData sent to client\n"); break; case 3: buf="2.6.32"; write(fifo_client,buf,10*sizeof(char)); printf("\nData sent to client\n"); } close(fifo_server); close(fifo_client); }

The above code,server.c, reads the choice from fifo_server to which the client writes and depending on the request,the server responds with the relevant data by writing to fifo_client.

Save the file and server.c and compile it as follows

cc server.c -o server

client.c:

#include<stdio.h> #include<fcntl.h> #include<stdlib.h> main() { FILE *file1; int fifo_server,fifo_client; char str[256]; char *buf; int choice=1; printf("Choose the request to be sent to server from options below"); printf("\n\t\t Enter 1 for O.S.Name \n \ Enter 2 for Distribution \n \ Enter 3 for Kernel version \n"); scanf("%d",&choice); fifo_server=open("fifo_server",O_RDWR); if(fifo_server < 0) { printf("Error in opening file"); exit(-1); } write(fifo_server,&choice,sizeof(int)); fifo_client=open("fifo_client",O_RDWR); if(fifo_client < 0) { printf("Error in opening file"); exit(-1); } buf=malloc(10*sizeof(char)); read (fifo_client,buf,10*sizeof(char)); printf("\n ***Reply from server is %s***\n",buf); close(fifo_server); close(fifo_client); }

The above code,client.c, sends a request to the server by writing to the pipe fifo_server, and recieves the reply from the server by reading the pipe fifo_client.

Save the file and server.c and compile it as follows

cc client.c -o client

To see the pipe in operation, open two terminals and go the folder where the pipes have been created.

Note: The server.c and client.c codes assume that the pipes exist in the same directory as the executables of server and client are, if they exist in any other directory you will have to provide the path to the same in the system call open().

Terminal 1:

./server

The terminal will go into a wait state with the cursor blinking, waiting for request from client.

Terminal 2:

./client

The client will prompt to make a choice of request to be sent to the server, enter number 1,2 or 3

Choose the request to be sent to server from options below Enter 1 for O.S.Name Enter 2.Distribution Enter 3.Kernel version

This number will be sent to the server and the client will go into a wait state, waiting for the server to respond.

After a few seconds you should see the reponse from the server being printed on the client terminal.

Note: wait for 10 seconds for the output to appear as the server has a sleep for 10 seconds, this is required to allow some time for the client to start its read operation on the fifo_client pipe.

for eg if we entered option 2, the response would be

output on client terminal:

***Reply from server is debian***

Ouput on server terminal :

Data sent to client

Thus we were able to communicate between the two processes using the fifos, even though the pipes were not created by them.

To use the pipes with out writing the server and client code we can use "cat" and "echo" commands.

Terminal 1:

cat fifo_server

Terminal 2:

echo "hello world" > fifo_server

We should be able to see the "hello world" being printed on the Terminal 1.

Making the home directory as the desktop

By default in all linux distributions the Desktop that is displayed is the contents of the folder Desktop under the home directory of the user.

If you are using a gnome desktop and using nautilus you can change this and make the contents of the your home folder be displayed on the desktop.

To do this open the terminal and type

gconf-editor /apps/nautilus/preferences/desktop_is_home_dir

You should see a window pop up as shown below.

In the line highlighted in the right frame of the window, check the option desktop_is_home_dir and then click on File->Quit

That should change your desktop to the home folder .

Switching between terminal tabs

If you are some one who uses terminal a lot and are used to opening more than a few tabs of terminals at time, here is simple way of switching between the terminals with out touching the mouse.

Alt + 1 will take you to the first tab of terminal, Alt + 2 will take you to the second tab of terminal and so on.

Another way of doing it is cntrl + pgup will take you to thee previous terminal and cntrl + pgdn will take you to the next terminal.

Inter process communication using pipes in linux

Linux provides many ways for processes to communicate with each other. One of them is using pipes.
Like a pipe that carries water in which water enters from one end and exits from the other, in linux pipes data enters from one end and exits from the other.

Pipes are created using the system call pipe() and the system calls read() and write() are used to read and write from the pipe. The c library in linux provides wrappers around these system calls which make their use much easier.

The function popen() is a wrapper for pipe, which allows us to create a pipe and read or write from it using c fuctions like fprintf,fscanf etc

popen :

Arguments : 1. command that will be executed by the child process.
2. The type of communication by the parent, i.e. whether the parent is going to read from the pipe or write into the pipe.
Return : It returns a file descriptor that gets created as a result of th call to the pipe.


Operation:

The open() system call creates a pipe and returns two file descriptors, one that can be used to read from the pipe and one that can be used to write into the pipe. This can be visualized as follows

The popen function which recives these two descriptors decides the next step based on whether the process requested for a read or write operation from the pipe. That is the whether the second arguement to the pipe was "r" or "w"
If the second argument was "r" that is the process is going to read from the pipe then the write file descriptor is changed to that of the standard output. Which means when the output of "command", which was passed as the first argument to open, instead of being printed on the standard output will now be sent into the pipe, which can be later read by using fscanf . Thus the child is able to send data through the pipe to the parent process, achieveing the commnicatio between processes.

Here is a example that shows how to open a pipe in read mode pipe_read.c #include<stdio.h> main() { FILE *file1; char str[256]; file1 = popen("echo hello world" ,"r"); while(!feof(file1)) { fscanf(file1,"%s",str); printf("%s \n ",str); } pclose(file1); } The above program opens the pipe in read mode, hence the process is going to read from the pipe, and write to the other end of the pipe which will be the standard output as exaplined above.

The command that the child process is going to execute is "echo hello world" which will be read by the parent process . The popen() returns a file descriptor which can be used to read from the pipe using the function fscanf() ,which reads from a file.

Thus we run a while loop till the end of file is reached and keep reading the contents of the file into a string, which is turn is printed on to the standard output to see what was the string read from the pipe.

compile the code using the gcc compiler as shown below

cc pipe_read.c -o pipe_read ./pipe_read

Output: hello world

The command "echo hello world" wrote "hello world" into the pipe, the same was read out using the file descriptor returned by popen.

If second argument was "w" that is the process is going to write into the pipe then the read file descriptor is changed to standard input. Which means what ever we write into the pipe will act as an input to the command that was passed in the first argument to popen. Thus the parent is able to send data to the child through the pipe, achieveing the commnicatio between processes.

Here is a example that shows how to open a pipe in write mode

pipe_write.c

#include<stdio.h> main() { FILE *file1; char str[256]; file1 = popen("wc -c" ,"w"); fprintf(file1,"hello world"); pclose(file1); }

The above program opens the pipe in write mode. The command that the child is executing is "wc -c" which counts the number of characters in the input file passed to it. As the pipe has been opened in write mode, that is the parent is going to write into the pipe, the child will read the data that the parent wrties. Hence what ever is printed into the file, using the file descriptor returned by popen() will be passed to "wc -w" as input which will count the number of characters and give the output on the standard output.

save the file as pipe_write.c. Compile it using gcc and execute is as follows.

cc pipe_write.c -o pipe_write ./pipe_write

Output: 11

There are 11 characters in the string "hello world" including the blank space, hence we see the output 11.

Changing the cursor style of the terminal

The default style of the cursor in the terminal of most distros is a big blinking block. This can be changed to either just a underline or a thinner block as follows.

-> open a terminal

-> run the command

gconf-editor /apps/gnome-terminal/profiles/Default/cursor_shape

-> In the window that will pop out , look at window on the right. The highlighted line will have cursor_shape in the first column and the value "block" in the second column.

-> To change this, click on the second column and enter the value "underline" to have the cursor as an underline or enter "ibeam" to use a vertical line cursor.

-> Hit the enter key after entering the new value

-> click on file and quit.

Your terminal cursor would have changed to what ever new value you chose.

Writing an example driver from scratch : Chapter -6

In the previous five chapters we walked through the steps of writing an simple charcater driver and for a virtual device and accessing it from the user space.

The limitation of driver written was it could not read using cat command . This was because the return value of the read function was not appropriate for the cat function.

The cat command continues to read from a file unless it is not informed that there is no further data to be read from the file, which is done by returning 0 when the end of file is reached.

To do this in our read function we have to keep count of the number of bytes that are written into the device. Hence we add a variable "written" into the write function which gets updated when data is written in to the device as follows

written = written + count ;

This value of written is assigned to another variable "read" every time device is opened. When the read function is called the variable "read" is compared with the variable "count", which indicates the number of bytes that the userspace wants to read. In case the count value is more than read, then we have to decrease the value of count to the amount of data present in the device i.e

if ( count > read)
count = read

And on every pass through the read function we keep decreasing the value of read by the count number of bytes that are read, and return the value of read.

Thus when end of file is reached the value of read becomes zero which when returned to cat, it would stop reading from the file.

Here is the drive code with the modified read and write functions. The steps to compile and insert the device are the same as in chapter-4

Note: The code has been tested and found working on kernel version 4.6

#include <linux/module.h> #include <linux/kernel.h> #include <linux/fs.h> // required for various structures related to files liked fops. #include <asm/uaccess.h> // required for copy_from and copy_to user functions #include <linux/semaphore.h> #include <linux/cdev.h> static int Major; static int written,read; struct device { char array[100]; struct semaphore sem; }char_arr; int open(struct inode *inode, struct file *filp) { printk(KERN_INFO "Inside open \n"); if(down_interruptible(&char_arr.sem)) { printk(KERN_INFO " could not hold semaphore"); return -1; } read = written; return 0; } int release(struct inode *inode, struct file *filp) { printk (KERN_INFO "Inside close \n"); printk(KERN_INFO "Releasing semaphore"); up(&char_arr.sem); return 0; } ssize_t read_char(struct file *filp, char *buff, size_t count, loff_t *offp) { unsigned long ret; printk("Inside read \n"); if(count > read) count = read; read = read -count; ret = copy_to_user(buff, char_arr.array, count); return count; } ssize_t write_char(struct file *filp, const char *buff, size_t count, loff_t *offp) { unsigned long ret; printk(KERN_INFO "Inside write \n"); ret = copy_from_user(char_arr.array, buff, count); written += count; return count; } struct file_operations fops = { owner: THIS_MODULE, read: read_char, write: write_char, open: open, release: release }; struct cdev *kernel_cdev; int char_arr_init (void) { int ret; dev_t dev_no,dev; kernel_cdev = cdev_alloc(); kernel_cdev->ops = &fops; kernel_cdev->owner = THIS_MODULE; printk (" Inside init module\n"); ret = alloc_chrdev_region( &dev_no , 0, 1,"char_arr_dev"); if (ret < 0) { printk("Major number allocation is failed\n"); return ret; } Major = MAJOR(dev_no); printk (KERN_INFO" The major number for your device is %d\n", Major); init_MUTEX(&char_arr.sem); ret = cdev_add( kernel_cdev,dev_no,1); if(ret < 0 ) { printk(KERN_INFO "Unable to allocate cdev"); return ret; } return 0; } void char_arr_cleanup(void) { printk(KERN_INFO " Inside cleanup_module\n"); cdev_del(kernel_cdev); unregister_chrdev_region(Major, 1); } MODULE_LICENSE("GPL"); module_init(char_arr_init); module_exit(char_arr_cleanup);

Assuming we have created a device by the name /dev/temp, we can communicate with the device as follows

$ echo "hi" > /dev/temp
$ cat /dev/temp
hi

Or we can use the user application code as show in chapter-5