Move IPC stuff from the libc side, inside the sys folder.

This commit is contained in:
Enrico Fraccaroli
2023-05-08 12:53:17 +02:00
parent e19354a9ee
commit 19e8ad309f
16 changed files with 45 additions and 43 deletions
+46
View File
@@ -0,0 +1,46 @@
/// @file ipc.h
/// @brief Inter-Process Communication (IPC) structures.
/// @copyright (c) 2014-2023 This file is distributed under the MIT License.
/// See LICENSE.md for details.
#pragma once
#include "sys/types.h"
#include "stddef.h"
#define IPC_CREAT 01000 ///< Create key if key does not exist.
#define IPC_EXCL 02000 ///< Fail if key exists.
#define IPC_NOWAIT 04000 ///< Return error on wait.
#define IPC_RMID 0 ///< Remove identifier.
#define IPC_SET 1 ///< Set `ipc_perm' options.
#define IPC_STAT 2 ///< Get `ipc_perm' options.
#define IPC_INFO 3 ///< See ipcs.
#define IPC_PRIVATE 4 ///< assures getting a new ipc_key.
/// @brief Permission details of an IPC object.
struct ipc_perm {
/// Key supplied to msgget(2).
key_t __key;
/// Effective UID of owner.
uid_t uid;
/// Effective GID of owner.
gid_t gid;
/// Effective UID of creator.
uid_t cuid;
/// Effective GID of creator.
gid_t cgid;
/// Permissions.
unsigned short mode;
/// Sequence number.
unsigned short __seq;
};
/// @brief Returns a possible IPC key based upon the filepath and the id.
/// @param path The file path.
/// @param id the project id.
/// @return the IPC key.
key_t ftok(char *path, int id);
/// @brief Prints System V IPC Informations
/// @return 0 on success, -1 on failure and errno is set to indicate the error.
long ipcs();
+126
View File
@@ -0,0 +1,126 @@
/// @file msg.h
/// @brief Definition of structure for managing message queues.
/// @copyright (c) 2014-2023 This file is distributed under the MIT License.
/// See LICENSE.md for details.
#pragma once
#include "sys/ipc.h"
#include "sys/types.h"
#include "stddef.h"
#include "time.h"
/// Type for storing the number of messages in a message queue.
typedef unsigned int msgqnum_t;
/// Type for storing the number of bytes in a message queue.
typedef unsigned int msglen_t;
/// @brief Buffer to use with the message queue IPC.
typedef struct msgbuf {
/// Type of the message.
long mtype;
/// Text of the message.
char mtext[1];
} msgbuf_t;
/// @brief Message queue data structure.
typedef struct msqid_ds {
/// Ownership and permissions.
struct ipc_perm msg_perm;
/// Time of last msgsnd(2).
time_t msg_stime;
/// Time of last msgrcv(2).
time_t msg_rtime;
/// Time of creation or last modification by msgctl().
time_t msg_ctime;
/// Number of bytes in queue.
unsigned long msg_cbytes;
/// Number of messages in queue.
msgqnum_t msg_qnum;
/// Maximum number of bytes in queue.
msglen_t msg_qbytes;
/// PID of last msgsnd(2).
pid_t msg_lspid;
/// PID of last msgrcv(2).
pid_t msg_lrpid;
} msqid_ds_t;
#ifdef __KERNEL__
/// @brief Get a System V message queue identifier.
/// @param key can be used either to obtain the identifier of a previously
/// created message queue, or to create a new set.
/// @param msgflg controls the behaviour of the function.
/// @return the message queue identifier, -1 on failure, and errno is set to
/// indicate the error.
long sys_msgget(key_t key, int msgflg);
/// @brief Used to send messages.
/// @param msqid the message queue identifier.
/// @param msgp points to a used-defined msgbuf.
/// @param msgsz specifies the size in bytes of mtext.
/// @param msgflg specifies the action to be taken in case of specific events.
/// @return 0 on success, -1 on failure and errno is set to indicate the error.
long sys_msgsnd(int msqid, msgbuf_t *msgp, size_t msgsz, int msgflg);
/// @brief Used to receive messages.
/// @param msqid the message queue identifier.
/// @param msgp points to a used-defined msgbuf.
/// @param msgsz specifies the size in bytes of mtext.
/// @param msgtyp specifies the type of message requested, as follows:
/// - msgtyp == 0: the first message on the queue is received.
/// - msgtyp > 0: the first message of type, msgtyp, is received.
/// - msgtyp < 0: the first message of the lowest type that is less than or
/// equal to the absolute value of msgtyp is received.
/// @param msgflg specifies the action to be taken in case of specific events.
/// @return 0 on success, -1 on failure and errno is set to indicate the error.
long sys_msgrcv(int msqid, msgbuf_t *msgp, size_t msgsz, long msgtyp, int msgflg);
/// @brief Message queue control operations.
/// @param msqid the message queue identifier.
/// @param cmd The command to perform.
/// @param buf used with IPC_STAT and IPC_SET.
/// @return 0 on success, -1 on failure and errno is set to indicate the error.
long sys_msgctl(int msqid, int cmd, msqid_ds_t *buf);
#else
/// @brief Get a System V message queue identifier.
/// @param key can be used either to obtain the identifier of a previously
/// created message queue, or to create a new set.
/// @param msgflg controls the behaviour of the function.
/// @return the message queue identifier, -1 on failure, and errno is set to
/// indicate the error.
long msgget(key_t key, int msgflg);
/// @brief Used to send messages.
/// @param msqid the message queue identifier.
/// @param msgp points to a used-defined msgbuf.
/// @param msgsz specifies the size in bytes of mtext.
/// @param msgflg specifies the action to be taken in case of specific events.
/// @return 0 on success, -1 on failure and errno is set to indicate the error.
long msgsnd(int msqid, msgbuf_t *msgp, size_t msgsz, int msgflg);
/// @brief Used to receive messages.
/// @param msqid the message queue identifier.
/// @param msgp points to a used-defined msgbuf.
/// @param msgsz specifies the size in bytes of mtext.
/// @param msgtyp specifies the type of message requested, as follows:
/// - msgtyp == 0: the first message on the queue is received.
/// - msgtyp > 0: the first message of type, msgtyp, is received.
/// - msgtyp < 0: the first message of the lowest type that is less than or
/// equal to the absolute value of msgtyp is received.
/// @param msgflg specifies the action to be taken in case of specific events.
/// @return 0 on success, -1 on failure and errno is set to indicate the error.
long msgrcv(int msqid, msgbuf_t *msgp, size_t msgsz, long msgtyp, int msgflg);
/// @brief Message queue control operations.
/// @param msqid the message queue identifier.
/// @param cmd The command to perform.
/// @param buf used with IPC_STAT and IPC_SET.
/// @return 0 on success, -1 on failure and errno is set to indicate the error.
long msgctl(int msqid, int cmd, msqid_ds_t *buf);
#endif
+136
View File
@@ -0,0 +1,136 @@
/// @file sem.h
/// @brief Definition of structure for managing semaphores.
/// @copyright (c) 2014-2023 This file is distributed under the MIT License.
/// See LICENSE.md for details.
#pragma once
#include "sys/types.h"
#include "sys/ipc.h"
#include "stddef.h"
#include "time.h"
#define SEM_UNDO 0x1000 ///< Undo the operation on exit.
/// @defgroup SemaphoreCommands semctl commands
/// @brief List of commands for semctl function.
/// @{
#define GETPID 11 ///< Get sempid.
#define GETVAL 12 ///< Get semval.
#define GETALL 13 ///< Get all semval's.
#define GETNCNT 14 ///< Get semncnt.
#define GETZCNT 15 ///< Get semzcnt.
#define SETVAL 16 ///< Set semval.
#define SETALL 17 ///< Set all semval's.
#define GETNSEMS 19 ///< Get sem_nsems
#define OPERATION_NOT_ALLOWED -18 ///< Return value for blocking operations on semaphores.
/// }@
/// @brief Optional argument for semctl() function
union semun {
/// @brief Value for SETVAL.
int val;
/// @brief Buffer for IPC_STAT & IPC_SET.
struct semid_ds *buf;
/// @brief Array for GETALL & SETALL.
unsigned short *array;
/// @brief Buffer for IPC_INFO.
struct seminfo *__buf;
};
/// @brief Single Semaphore.
struct sem {
/// @brief Semaphore Value.
unsigned short sem_val;
/// @brief Process ID of the last operation.
pid_t sem_pid;
/// @brief Number of processes waiting of semaphore.
//unsigned short semncnt;
/// @brief Number of processes waiting for the value to become 0
unsigned short sem_zcnt;
};
/// @brief Semaphore set
struct semid_ds {
/// @brief Ownership and permissions.
pid_t owner;
/// @brief IPC_KEY associated to the semaphore set.
key_t key;
/// @brief Semaphore ID associated to the semaphore set.
int semid;
/// @brief Last semop time.
time_t sem_otime;
/// @brief Last change time.
time_t sem_ctime;
/// @brief Number of semaphores in set.
unsigned long sem_nsems;
/// @brief List of all the semaphores.
struct sem *sems;
};
/// @brief Buffer to use with the semaphore IPC.
struct sembuf {
/// @brief Semaphore index in array.
unsigned short sem_num;
/// @brief Semaphore operation.
short sem_op;
/// @brief Operation flags.
short sem_flg;
};
#ifdef __KERNEL__
/// @brief Get a System V semaphore set identifier.
/// @param key can be used either to obtain the identifier of a previously
/// created semaphore set, or to create a new set.
/// @param nsems number of semaphores.
/// @param semflg controls the behaviour of the function.
/// @return the semaphore set identifier, -1 on failure, and errno is set to
/// indicate the error.
long sys_semget(key_t key, int nsems, int semflg);
/// @brief Performs operations on selected semaphores in the set.
/// @param semid the semaphore set identifier.
/// @param sops specifies operations to be performed on single semaphores.
/// @param nsops number of operations.
/// @return 0 on success, -1 on failure and errno is set to indicate the error.
long sys_semop(int semid, struct sembuf *sops, unsigned nsops);
/// @brief Performs control operations on a semaphore set.
/// @param semid the semaphore set identifier.
/// @param semnum the n-th semaphore of the set on which we perform the operations.
/// @param cmd the command to perform.
/// @param arg
/// @return 0 on success, -1 on failure and errno is set to indicate the error.
long sys_semctl(int semid, int semnum, int cmd, union semun *arg);
#else
/// @brief Get a System V semaphore set identifier.
/// @param key can be used either to obtain the identifier of a previously
/// created semaphore set, or to create a new set.
/// @param nsems number of semaphores.
/// @param semflg controls the behaviour of the function.
/// @return the semaphore set identifier, -1 on failure, and errno is set to
/// indicate the error.
long semget(key_t key, int nsems, int semflg);
/// @brief Performs operations on selected semaphores in the set.
/// @param semid the semaphore set identifier.
/// @param sops specifies operations to be performed on single semaphores.
/// @param nsops number of operations.
/// @return 0 on success, -1 on failure and errno is set to indicate the error.
long semop(int semid, struct sembuf *sops, unsigned nsops);
/// @brief Performs control operations on a semaphore set.
/// @param semid the semaphore set identifier.
/// @param semnum the n-th semaphore of the set on which we perform the operations.
/// @param cmd the command to perform.
/// @param arg
/// @return 0 on success, -1 on failure and errno is set to indicate the error.
long semctl(int semid, int semnum, int cmd, union semun *arg);
#endif
+206
View File
@@ -0,0 +1,206 @@
/// @file shm.h
/// @brief Definition of structure for managing shared memories.
/// @copyright (c) 2014-2023 This file is distributed under the MIT License.
/// See LICENSE.md for details.
#pragma once
#include "sys/ipc.h"
#include "sys/types.h"
#include "stddef.h"
#include "time.h"
/// Data type for storing the number of attaches.
typedef unsigned long shmatt_t;
/// @brief Shared memory data structure.
struct shmid_ds {
/// Operation permission struct.
struct ipc_perm shm_perm;
/// Size of segment in bytes.
size_t shm_segsz;
/// Time of last shmat().
time_t shm_atime;
/// Time of last shmdt().
time_t shm_dtime;
/// Time of last change by shmctl().
time_t shm_ctime;
/// Pid of creator.
pid_t shm_cpid;
/// Pid of last shmop.
pid_t shm_lpid;
/// Number of current attaches.
shmatt_t shm_nattch;
/// Pointer to the next shared memory data structure.
struct shmid_ds *next;
/// Where shm created is memorized, should be a file.
void *shm_location;
};
#if 0
#include "debug.h"
#include "time.h"
#include "kheap.h"
#include "stddef.h"
#include "paging.h"
#include "syscall.h"
#include "scheduler.h"
//======== Permission flag for shmget ==========================================
// or S_IRUGO from <linux/stat.h>.
#define SHM_R 0400
// or S_IWUGO from <linux/stat.h>.
#define SHM_W 0200
//==============================================================================
//======== Flags for shmat =====================================================
// Attach read-only else read-write.
#define SHM_RDONLY 010000
// Round attach address to SHMLBA.
#define SHM_RND 020000
// Take-over region on attach.
#define SHM_REMAP 040000
// Execution access.
#define SHM_EXEC 0100000
//==============================================================================
//======== Commands for shmctl =================================================
// Lock segment (root only).
#define SHM_LOCK 11
// Unlock segment (root only).
#define SHM_UNLOCK 12
//==============================================================================
// Ipcs ctl commands.
#define SHM_STAT 13
#define SHM_INFO 14
#define SHM_STAT_ANY 15
//======== shm_mode upper byte flags ===========================================
// segment will be destroyed on last detach.
#define SHM_DEST 01000
// Segment will not be swapped.
#define SHM_LOCKED 02000
// Segment is mapped via hugetlb.
#define SHM_HUGETLB 04000
// Don't check for reservations.
#define SHM_NORESERVE 010000
/// @@brief Syscall Service Routine: Shared memory control operation.
int syscall_shmctl(int *args);
/// @@brief Syscall Service Routine: Get shared memory segment.
int syscall_shmget(int *args);
/// @@brief Syscall Service Routine: Attach shared memory segment.
void *syscall_shmat(int *args);
/// @@brief Syscall Service Routine: Detach shared memory segment.
int syscall_shmdt(int *args);
/// @@brief User Wrapper: Shared memory control operation.
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
/// @@brief User Wrapper: Get shared memory segment.
int shmget(key_t key, size_t size, int flags);
/// @@brief User Wrapper: Attach shared memory segment.
void *shmat(int shmid, void *shmaddr, int flag);
/// @@brief User Wrapper: Detach shared memory segment.
int shmdt(void *shmaddr);
/// @@brief Find shmid_ds on list.
struct shmid_ds *find_shm_fromid(int shmid);
/// @@brief Find shmid_ds on list.
struct shmid_ds *find_shm_fromkey(key_t key);
/// @@brief shmid_ds on list.
struct shmid_ds *find_shm_fromvaddr(void *shmvaddr);
#endif
#ifdef __KERNEL__
/// @brief Get a System V shared memory identifier.
/// @param key can be used either to obtain the identifier of a previously
/// created shared memory, or to create a new one.
/// @param size of the shared memory, rounded up to a multiple of PAGE_SIZE.
/// @param flag controls the behaviour of the function.
/// @return the shared memory identifier, -1 on failure, and errno is set to
/// indicate the error.
long sys_shmget(key_t key, size_t size, int flag);
/// @brief Attaches the shared memory segment identified by shmid to the address
/// space of the calling process.
/// @param shmid the shared memory identifier.
/// @param shmaddr the attaching address.
/// @param shmflg controls the behaviour of the function.
/// @return returns the address of the attached shared memory segment; on error
/// (void *) -1 is returned, and errno is set to indicate the error.
void * sys_shmat(int shmid, const void *shmaddr, int shmflg);
/// @brief Detaches the shared memory segment located at the address specified
/// by shmaddr from the address space of the calling process
/// @param shmaddr the address of the shared memory segment.
/// @return 0 on success, -1 on failure and errno is set to indicate the error.
long sys_shmdt(const void *shmaddr);
/// @brief Performs the control operation specified by cmd on the shared memory
/// segment whose identifier is given in shmid.
/// @param shmid the shared memory identifier.
/// @param cmd the command to perform.
/// @param buf is a pointer to a shmid_ds structure.
/// @return a non-negative value basedon on the requested operation, -1 on
/// failure and errno is set to indicate the error.
long sys_shmctl(int shmid, int cmd, struct shmid_ds *buf);
#else
/// @brief Get a System V shared memory identifier.
/// @param key can be used either to obtain the identifier of a previously
/// created shared memory, or to create a new one.
/// @param size of the shared memory, rounded up to a multiple of PAGE_SIZE.
/// @param flag controls the behaviour of the function.
/// @return the shared memory identifier, -1 on failure, and errno is set to
/// indicate the error.
long shmget(key_t key, size_t size, int flag);
/// @brief Attaches the shared memory segment identified by shmid to the address
/// space of the calling process.
/// @param shmid the shared memory identifier.
/// @param shmaddr the attaching address.
/// @param shmflg controls the behaviour of the function.
/// @return returns the address of the attached shared memory segment; on error
/// (void *) -1 is returned, and errno is set to indicate the error.
void * shmat(int shmid, const void *shmaddr, int shmflg);
/// @brief Detaches the shared memory segment located at the address specified
/// by shmaddr from the address space of the calling process
/// @param shmaddr the address of the shared memory segment.
/// @return 0 on success, -1 on failure and errno is set to indicate the error.
long shmdt(const void *shmaddr);
/// @brief Performs the control operation specified by cmd on the shared memory
/// segment whose identifier is given in shmid.
/// @param shmid the shared memory identifier.
/// @param cmd the command to perform.
/// @param buf is a pointer to a shmid_ds structure.
/// @return a non-negative value basedon on the requested operation, -1 on
/// failure and errno is set to indicate the error.
long shmctl(int shmid, int cmd, struct shmid_ds *buf);
#endif