Detailed explanation of Linux systemV message queue and semaphore

1. Message Queue

1. Implementation principle

The operating system sets up a queue in the kernel. The two processes AB of communication pushback the data to be sent into the queue in the form of data blocks. The data block is a structure, and there are fields that identify who sent the data block, so we just need to let different processes see the same queue.

2. System call interface

(I) Create and get a message queue

msggetThe main function of the function is to create a new message queue or obtain the identifier of an existing message queue.

#include <sys/>
#include <sys/>
#include <sys/>
int msgget(key_t key, int msgflg);

Return value: Return one successfullymsgid, failed to return -1

• key: The return value of the ftok function
• msgflg: Identifier

(II) Control the message queue

msgctlSystem call functions used to control message queues, which are usually used to perform various management operations on message queues, such as obtaining message queue status, setting message queue attributes, and deleting message queues.

#include <sys/>
#include <sys/>
#include <sys/>
int msgctl(int msgid, int cmd, struct msqid_ds *buf);

Return value: Returning 0 means the operation is successful, and returning -1 means the operation is failed.

• msgid: Message queue identifier,msggetFunction returns value
• cmd：msgctlFunctionalcmdCommon parameters are as follows:

• buf: A pointermsgid_dsA pointer to a structure, used to store or provide relevant information about a message queue,msqid_dsThe structure contains various attributes of the message queue, such as the permissions of the queue, owner information, the size of the message queue, etc.

(III) Send a message

msgsndSystem call function for sending messages to message queues, which allows the process to add a message to the specified message queue.

#include <sys/>
#include <sys/>
#include <sys/>
int msgsnd(int msgid, const void *msgp, size_t msgsz, int msgflg);

Return value: Return 0 for success, return -1 for failure

• msgid: Message queue identifier,msggetFunction returns value
• msgp: A pointer to the message structure to be sent. The first member of the structure must be of type long, which specifies the type of the message. It can subsequently contain the data part of the message
• msgsz: The length of the message data part, i.e.msgpExcept for the first one in the pointed structurelongData length outside the type member
• msgflg: This position is 0, which means it is not set

(IV) Get data blocks in the message queue

msgrcvSystem call function for receiving messages from message queues, which allows processes to get messages from specified message queues

#include <sys/>
#include <sys/>
#include <sys/>
ssize_t msgrcv(int msgid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

Return value: successfully returns the number of bytes of the actual received message data part, excluding the first long

The first two parameters are the same as before

• msgsz: The maximum length of the buffer used to store the message data part when receiving a message
• msgtyp: If it is equal to 0, then the function only receives the first message in the message queue. If it is greater than 0, the message type in the receiving message queue ismsgtypIf the first message is less than 0, the message type in the receiving message queue is less than or equal tomsgtypThe first message of the minimum type of absolute value
• msgflg: This position is 0, which means it is not set

2. Semaphore

1. Principle

Semaphore is a type used to implement inter-processSynchronization and mutual exclusionThe mechanism of the semaphore is essentially an integer variable used to control access to shared resources. It can be regarded as a special counter, and its value represents the number of shared resources currently available. The value of the semaphore can be read and modified by multiple processes or threads. Through operations on the semaphore, the process or thread can coordinate access to shared resources.

The work of semaphores is based on two basic operations: P operation (wait operation) and V operation (signal operation)

• P operation: When a process or thread needs to access a shared resource, it performs a P operation. The P operation will decrement the value of the semaphore by 1. If the value of the semaphore after decrement is greater than or equal to 0, it means that there are currently available resources and the process or thread can continue to access; if the value of the semaphore after decrement is less than 0, it means that there are no available resources and the process or thread will be blocked until another process or thread releases the resources.
• V Operation: When a process or thread uses a shared resource, it will perform a V operation. The V operation will add the value of the semaphore to 1. If the value of the semaphore after adding 1 is less than or equal to 0, it means that other processes or threads are waiting for the resource. At this time, a waiting process or thread will be awakened

2. System call interface

(I) Create and get a semaphore

semgetis a system call function used to create or obtain a semaphore set

#include <sys/>
#include <sys/>
#include <sys/>

int semget(key_t key, int nsems, int semflg);

Return value: successfully returned semaphore identifiersemid, failed to return -1

• nsems: Indicates the number of semaphores in the semaphore set to be created or obtained. If it is to create a new semaphore set, it must be greater than 0. If it is to obtain an existing semaphore set, it can be 0.
• semflg: Flag bit, used to specify how and permissions to create or obtain semaphore sets

(II) Control the signal quantity

semctlIt is a system call function used to control the semaphore set. It can perform various operations on the semaphore set, such as initializing the value of the semaphore, obtaining the status of the semaphore, deleting the semaphore set, etc.

#include <sys/>
#include <sys/>
#include <sys/>

int semctl(int semid, int semnum, int cmd, ...);

Return value: depends oncmdThe current value ofGETVALCommand, returns the current value of the specified semaphore, forIPC_STAT、IPC_SETandIPC_RMIDWait for the command, return 0 means success

• semid: semaphore identifier,semgetFunction returns
• semnum: The number of semaphores in the semaphore set, the number starts from 0. If the cmd operation does not require a specific semaphore (such as deleting the entire semaphore set), this parameter can be ignored and usually set to 0
• cmd: The command to be executed specifies the type of operation for the semaphore set or a specific semaphore

(III) PV operation

semopSystem call function for performing operations on a semaphore set, which allows a process to perform atomic P and V operations on one or more semaphores, thereby enabling synchronization and mutual exclusion between processes.

#include <sys/>
#include <sys/>
#include <sys/>

int semop(int semid, struct sembuf *sops, unsigned nsops);

Return value: Return 0 for success, return -1 for failure

• sops: Point tostruct sembufPointer to a structure array containing the sequence of operations to be performed on the semaphore set
• nsops：sopsThe number of elements in the array, that is, the length of the sequence of operations to be performed

3. Comparison of systemV IPC methods

1. Describe the structure of IPC resources

Description shared memoryIPCResource structure:

struct shmid_kernel /* private to the kernel */
{	
	struct kern_ipc_perm	shm_perm;
	struct file *		    shm_file;
	int						id;
	unsigned long			shm_nattch;
	unsigned long			shm_segsz;
	time_t					shm_atim;
	time_t					shm_dtim;
	time_t					shm_ctim;
	pid_t					shm_cprid;
	pid_t					shm_lprid;
	struct user_struct		*mlock_user;
};

Describe message queueIPCResource structure:

struct msg_queue {
	struct kern_ipc_perm q_perm;
	time_t 				 q_stime;			/* last msgsnd time */
	time_t 				 q_rtime;			/* last msgrcv time */
	time_t				 q_ctime;			/* last change time */
	unsigned long 		 q_cbytes;			/* current number of bytes on queue */
	unsigned long		 q_qnum;			/* number of messages in queue */
	unsigned long		 q_qbytes;			/* max number of bytes on queue */
	pid_t				 q_lspid;			/* pid of last msgsnd */
	pid_t				 q_lrpid;			/* last receive pid */

	struct list_head 	 q_messages;
	struct list_head	 q_receivers;
	struct list_head	 q_senders;
};

Describe the semaphoreIPCResource structure:

struct sem_array {
	struct kern_ipc_perm	sem_perm;			/* permissions .. see  */
	time_t					sem_otime;			/* last semop time */
	time_t					sem_ctime;			/* last change time */
	struct sem				*sem_base;			/* ptr to first semaphore in array */
	struct sem_queue		*sem_pending;		/* pending operations to be processed */
	struct sem_queue		**sem_pending_last; /* last pending operation */
	struct sem_undo			*undo;				/* undo requests on this array */
	unsigned long			sem_nsems;			/* no. of semaphores in array */
};

They have the same characteristic that the first parameter isstruct kern_ipc_permType of

struct kern_ipc_perm
{
	spinlock_t		lock;
	int				deleted;
	key_t			key;
	uid_t			uid;
	gid_t			gid;
	uid_t			cuid;
	gid_t			cgid;
	mode_t			mode; 
	unsigned long	seq;
	void			*security;
};

2. The operating system manages IPC resources

All IPC resources have onestruct kern_ipc_permstructure, so the operating system uses an array to transfer thesestruct kern_ipc_permStructured

ipc_idsYes for management in Linux kernelIPCThe core data structure of the resource

struct ipc_ids {
    int             in_use;//Record the number of IPC resources being used in the current system    int             max_id;//Indicate the maximum IPC identifier value allowed in the system    unsigned short  seq;// is a serial number used to generate a unique IPC identifier    unsigned short  seq_max;//is the maximum value of the serial number    struct          semaphore sem;//This is a semaphore used to synchronously control concurrent access to IPC resources    struct          ipc_id_ary nullentry;// An empty ipc_id_ary structure    struct          ipc_id_ary* entries;// Pointer to ipc_id_ary structure};

struct ipc_id_ary {
    int    size;
    struct kern_ipc_perm *p[0];
};

The flexible array herepThe function is to maintain all the current operating systemIPCResources, which we use cast to store in this arraystruct ipc_id_ary*Find the specific oneIPCobject, becausekern_ipc_permIt is the first member of these three structures, we only know onekern_ipc_permThe address is equivalent to knowing a specificIPCThe object's start address can then be accessed through cast type conversionIPCAll member properties in the object, thus implementing a specificIPCAccess to objects, such as((struct shmid_kernel*)p[0])->q_stime,existkern_ipc_permThere are fields in it to identify thekern_ipc_permWhich one belongs toIPCThe operating system knows what type to force it to convert resources, which we use at the user level:shmid、msqid、semidIt's in the kernelpSubscript of array

ipc_id_arryIt belongs to the operating system, not to any process, the array subscript is linearly incremented, but it will not be becauseIPCThe resource is released and its incremental attribute is changed, that is, the last one in the current operating systemIPCThe resource's subscript is 100, release thisIPCResource, create next timeIPCWhen the resource is in the subscript is 101, not 100. When it is incremented to a certain value, it will return to 0.

Summarize

The above is personal experience. I hope you can give you a reference and I hope you can support me more.