COP 4604 UNIX System Programming IPC. Dr. Sam Hsu Computer Science & Engineering Florida Atlantic University

Transcription

1 COP 4604 UNIX System Programming IPC Dr. Sam Hsu Computer Science & Engineering Florida Atlantic University

2 Interprocess Communication Interprocess communication (IPC) provides two major functions/services: Information exchange For data transfer among processes. Process synchronization For synchronization of process execution.

3 Various IPC Implementations IPC Type POSIX.1 SVR4 4.4BSD Signals Pipes (HDX) FIFOs (named pipes) Stream pipes (FDX) Named stream pipes Message queues Semaphores Shared memory Sockets Streams

4 Signals Most widely known UNIX IPC facility. Used primarily to inform processes the occurrence of asynchronous events. Posted by one process and received by another or the same process. The receiving process performs an action appropriate to the signal received: Default (SIG_DFL). Ignored (SIG_IGN). User-defined.

5 Pipes A pipe is a one-way communication channel (HDX) that couples one process to another. Used only between processes that have a common ancestor. More specifically, for communication between parent and child in general. There are two types of pipes: named and unnamed Unnamed pipes are used for communication between related processes. Named pipes can be used for communication between unrelated processes.

6 The pipe() System Call Syntax pipe() Is used to create an unnamed pipe. Needs an array of two int's for two fd's (r/w)

7 Pipes Are Files In fact, a pipe is another generalization of the UNIX file concept. A pipe is a FIFO file. lseek() does not work on a pipe. Unnamed pipes come and go. Named pipes (also known as FIFOs) are permanent files.

8 Some Properties of Pipes (1/2) Write before read If a read() is issued while the pipe is empty, it will block. The size of a pipe is limited. Max is PIPE_BUF. If a write() is issued when the pipe is full, it will block.

9 Some Properties of Pipes (2/2) Data could be intermingled if several processes are writing to the same pipe. If all writers of a pipe are closed, a reader will encounter EOF. If all readers of a pipe are closed, a writer will face a broken pipe. Non-blocking reads and writes Issue fcntl() with O_NONBLOCK flag.

10 FIFOs Also known as named pipes. Can be used between unrelated processes for data exchange.

11 The popen()/pclose() Functions To create a pipe between the calling program and the command to be executed. Will handle dirty work such as: The creation of a pipe. The fork of a child. Closing the unused ends of the pipe. Executing a shell to execute the command. Waiting for the command to terminate.

12 Three SV IPC Facilities SV provides 3 unique IPC facilities (structures). Semaphores For process synchronization. Shared memory For process communication. Message queues For process communication.

13 Semaphores Semaphores are useful for process synchronization and resource management. A semaphore is an unsigned integer shared among several competing processes. Operating upon a semaphore involves adding or subtracting from the underlying semaphore value. The UNIX implementation of semaphores is modeled after Dijkstra's semaphores.

14 Shared Memory Shared memory allows one or more process to share the same segment of memory. Shared memory may be attached to more than one process. Once attached, it is part of a process's data space. Shared memory is the fastest IPC.

15 Messages Queues A message queue allows processes to send and receive discrete amounts of data, know as messages. A message is a collection of bytes of varying lengths, ranging from zero to a system imposed maximum. The message content can be anything -- ASCII or binary. Each message has a type associated with it. A message type is a long integer.

16 Common Features of the Three IPC Facilities (1/3) An IPC facility must be created prior to use. It can be created anytime before use. Permission and ownership for a facility are established at the time of creation. But these attributes can be changed later. An IPC facility can exist with contents intact after all processes accessing it have exited. Changes made to an IPC facility by a process persist after the process exits. An IPC facility must be explicitly removed. Removal of an IPC facility can be done by either the owner or creator.

17 Common Features of the Three IPC Facilities (2/3) Shares a common data structure defined in <sys/ipc.h> struct ipc_perm { uid_t uid; /* owner's user id */ gid_t gid; /* owner's group id */ uid_t cuid; /* creator's user id */ gid_t cgid; /* creator's group id */ mode_t mode; /* access modes */ uint_t seq; /* slot usage sequence number */ key_t key; /* key */ }

18 Common Features of the Three IPC Facilities (3/3) Needs an IPC key to gain access to an IPC facility. All processes wishing to use the same IPC facility must specify the same key. This key must uniquely identify the IPC facility. An IPC facility is identified by a nonnegative integer. In need of an IPC key to generate such a numeric ID. Three ways to generate an IPC key: IPC_PRIVATE Use a predefined key and store it in a common header file. Use key_t ftok(const char *path, int id) to generate an IPC key.

19 Three Major Categories of IPC System Calls get(): Is used to create or access an IPC facility. It returns an IPC identifier. semget(), shmget(), msgget() ctl(): Is used to determine status, set options and/or permissions, or remove an IPC facility. semctl(), shmctl(), msgctl() op(): Is used to operate on an IPC identifier. semop() shmat(), shmdt() msgsnd(), msgrcv()

20 End-user Level Commands ipcs Used to report inter-process communication facilities status ipcrm Used to remove a message queue, semaphore set, or shared memory ID.

21 Semaphore Basics (1/3) A semaphore is an integer variable that can be accessed only through two standard atomic operations: Proberen wait P(S): while S <= 0 do skip; S S-1; Verhogen signal V(S): S S+1;

22 Semaphore Basics (2/3) Semaphores are used to control access to shared resource(s). An important mechanism to ensure mutual exclusion to protect critical sections in a program. To obtain a shared resource, a process needs to test the semaphore that controls the resource. If the semaphore value is positive, the process can use the resource. The process decrements the semaphore value by 1, indicating it has used one unit of the resource.

23 Semaphore Basics (3/3) If the value tested is 0, the process goes to sleep until the semaphore value is greater than 0. The controlling semaphore value is incremented by 1 when a process is done with the shared resource. If any other processes are asleep, waiting for the semaphore, they are awakened. Semaphores are typically implemented inside the kernel. To ensure that the test of a semaphore s value and the de/incrementing of the value are implemented as atomic operations.

24 2 Types of Semaphores (1/2) Binary (lock/unlock) Having a value of 0 or 1. Usually used for locking a resource. N -ary (counting) N is the available number of an intended resource on a system. Usually used for maintaining a pool of resources.

25 2 Types of Semaphores (2/2) Note that the type/nature of a semaphore (whether binary of N-ary) is imposed by the application (user-defined), not by the system. In the binary case, a process waits for the semaphore to become one; in the N-ary case, a process waits for a non-zero value. (The latter can be considered as a more general case of the former.)

26 Semaphore Implementation (1/2) A semaphore is a sharable unsigned short integer variable. Semaphores are grouped together to form sets. No standalone semaphores. A semaphore set (array) contains: 1 to SEMMSL semaphores. 1 data structure, struct semid_ds, containing administrative information about the set.

27 Semaphore Implementation (2/2) Each semaphore set is uniquely identified by a nonnegative integer. One or more semaphores in a set can be accessed at the same time. All semaphores involved in an operation are changed "atomically". Only one process can access a semaphore set at any given time.

28 Basic Semaphore Operations Incrementing. Decrementing. Testing for zero.

29 Semaphore System Calls (1/2) semget(): To create or gain access to a set of one or more semaphores. semctl(): To get or set the value of a semaphore(s) in a set. To get or modify the status of a semaphore set. To identify process waiting for a specific semaphore value. To identify process that did the last operation on a semaphore. To remove a semaphore set.

30 Semaphore System Calls (2/2) semop(): To wait for the value of a semaphore(s) to become 0. To increment semaphore value(s). To decrement semaphore value(s). IPC_NOWAIT for non-blocking. SEM_UNDO for undo operations. Note: sleep() and wakeup() are used internally.

31 Blocking/nonblocking Operations A semaphore operation can be either: Blocking: Processes wait for resources to be released. Non-blocking: Processes return an error code -1, and the external errno variable is set accordingly. (IPC_NOWAIT is set.) UNIX puts the blocked process to sleep to eliminate the busy waiting phenomenon.

32 Semaphore Data Structures kernel data space struct semid_ds { struct ipc_perm sem_perm; struct sem *sem_base ushort_t sem_nsems time_t sem_otime; time_t sem_ctime; int sem_binary; }; struct sem { ushort_t semval; pid_t sempid ushort_t semncnt ushort_t semzcnt; } [nsems]; (retained by kernel) Semaphore system calls semid = semget() semctl() union semun { int val struct semid_ds *buf; unshort *array; }; semop() struct sembuf { ushort sem_num; short sem_op; short sem_flg; }; Note: In union semun int val is used for SETVAL struct semid_ds *buf is used for IPC_STAT and IPC_SET ushort *array is used for GETALL and SETALL In struct sembuf short sem_op has the value: 0: zero test, +n.: release n, or -n: request n short sem_flg has the value: IPC_NOWAIT or SEM_UNDO struct sem is the data structure of a semaphore. It comes in an array.

33 Shared Memory Basics Shared memory allows multiple processes to share memory. Shared memory is used to hold data needed by two or more processes. Look-up tables, form layouts, etc.

34 Shared Memory Implementation The implementation of shared memory is machine dependent. It depends on the memory management of the host machine. System configuration values determine the minimum and maximum sizes of a segment. The number of segments that may be attached to a process is also restricted.

35 Shared Memory Creation & Attachment Typically one process creates a shared memory segment, maps the segment into its data space and initializes the segment. The term for mapping a shared memory segment into a user's data space is called attachment. The creator process specifies R/W permissions associated for the shared memory segment. Other processes may then attach the shared memory segment and access its contents. Unrelated processes can thus communicate via shared memory.

36 Shared Memory Detachment A process using a shared memory segment may detach it explicitly when finished. If not done explicitly, an exit() call will detach the segment automatically. Detachment does not remove the shared memory.

37 Explicit Removal & Synchronization Shared memory must be removed explicitly. Usually by the same process that does the creation. Synchronized access to shared memory must be done explicitly. Usually used with semaphores.

38 Shared Memory System Calls (1/2) shmget(): To obtain a shared memory identifier. shmat(): To attach a shared memory segment to a process data segment. shmdt(): To detach a shared memory segment from a process data segment.

39 Shared Memory System Calls (2/2) shmctl(): To determine the status of a shared memory segment. To change permissions or ownership of a shared memory segment. To remove a shared memory.

40 A Conceptual View of Shared Memory argv[] & envp[] stack argv[] & envp[] stack heap BSS data text shared memory heap BSS data text

41 Message Queues Basics Message queues are for exchange of data among processes. The data exchanged are in discrete portions known as messages. A message is a sequence of bytes, from zero to the system limit, with a message type. The structure of a message is up to the programmer. Once a message queue is created, processes can send/receive messages to/from the queue.

42 Reading Messages A process can selectively read messages on a queue: First message on the queue. First message of a specific type on the queue. First message from a range of types (from 1 to upper bound of range) on the queue.

43 Some Message Queue Properties Messages queues are similar to unnamed pipes; however, Each message has a type associated with it. Data in a pipe is just a sequence of types with no header of format. Unread data in a pipe vanishes when the last reader process close a file descriptor associated with the pipe's read end. A message queue sticks around. It will remain active until it is explicitly removed.

44 Message Queues System Calls (1/2) msgget(): To create or to gain access to a message queue. msgctl(): To determine the status of a message queue. To change the permission or ownership of a message queue. To change the maximum size. To remove a message queue.

45 Message Queues System Calls (2/2) msgsend(): To send a message. msgrcv(): To receive a message.

46 Some Comments on the Three SV IPC Facilities The SV IPC structures are system-wide. They stick around until explicitly removed. Not compatible with standard UNIX file manipulation facilities. Can t use open(), close(), read(), write(), etc. Almost a dozen of new system calls were added to the kernel to support these IPC facilities. Basically, they are intra-system IPC facilities.