acknowledgement : prof. y. moon at kangwon nat’l univ
DESCRIPTION
Inter-Process Communication , Advanced I/O (Chap 12, 14 in the book “Advanced Programming in the UNIX Environment”). Acknowledgement : Prof. Y. Moon at Kangwon Nat’l Univ. UNIX time. #include time_t time(time_t *calptr); - PowerPoint PPT PresentationTRANSCRIPT
Inter-Process Communication , Advanced I/O(Chap 12, 14 in the book “Advanced Programming in the UNIX Environment”)
Acknowledgement : Prof. Y. Moon at Kangwon Nat’l Univ.
UNIX time
2
#include <time.h>
time_t time(time_t *calptr); Returns: value of time if OK, -1 on error
struct tm *gmtime(const time_t *calptr); Returns: pointer to time structure
time_t mktime(struct tm *tmptr); Returns : calendar time if OK, -1 on error
char *asctime(const struct tm *tmptr);char *ctime(const time_t *calptr); Returns : pointer to null terminated string
size_t strftime(char *buf, size_t maxsize, const char *format, const struct tm *tmptr); Returns : number of characters stored in array if room, else 0
struct tm{ int tm_sec; int tm_min; int tm_hour; int tm_mday; /* [1,31] */ int tm_mon; /* [0,11] */ int tm_year; /* years since 1900 */ int tm_wday; /* days since Sunday [0, 6] */ int tm_yday; /* [0, 365] */ int tm_isdst;};
Lock
a synchronization mechanism for enforcing limits on access to a resource in an environment where there are many threads of execution
Advisory lock Other processes can still access (read or write) to a locked resource There is a way to check whether a resource is locked
Mandatory lock Prevent access to a locked resource
3
Advisory Locking
Applies or removes an advisory lock on the file associated with the file descriptor fd
Operation can be LOCK_SH LOCK_EX LOCK_NB LOCK_UN
Locks entire file
4
#include <fcntl.h>
int flock(int fd, int operation); Returns: 0 if OK, -1 otherwise
Advisory Record Locking
struct flock {short l_type; /* F_RDLCK, F_WRLCK, or F_UNLCK */off_t l_start; /* offset in bytes from l_whence */short l_whence; /* SEEK_SET, SEEK_CUR, SEEK_END */off_t l_len; /* length, in bytes; 0 means “lock to EOF */pid_t l_pid; /* returned by F_GETLK */
}
Lock types are : F_RDLCK : non-exclusive (read) lock; fails if write lock exists F_WRLCK : exclusive (write) lock; fails if any lock exists F_UNLCK : releases our lock on specified range
5
#include <fcntl.h>
int fcntl(int fd, int cmd, struct flock* lock); Returns: depends on cmd if OK, -1 on error
Setting and Clearing a lock
6
struct flock fl; int fd;
fl.l_type = F_WRLCK; /* F_RDLCK, F_WRLCK, F_UNLCK */ fl.l_whence = SEEK_SET; /* SEEK_SET, SEEK_CUR, SEEK_END */ fl.l_start = 0; /* Offset from l_whence */ fl.l_len = 0; /* length, 0 = to EOF */ fl.l_pid = getpid(); /* our PID */
fd = open("filename", O_WRONLY); fcntl(fd, F_SETLKW, &fl); /* F_GETLK, F_SETLK, F_SETLKW */
fl.l_type = F_UNLCK; /* tell it to unlock the region */ fcntl(fd, F_SETLK, &fl); /* set the region to unlocked */
Non-Blocking(Asynchronous) I/O
A form of I/O that permits subsequent processing to continue before current processing has finished.
Non Blocking I/O function returns immediately Two ways for specifying non-blocking I/O
When calling “open” and specify O_NONBLOCK flag For a file descriptor that is already open, call fcntl to
turn on O_NONBLOCK file status flag.
7
IPC
Pipes FIFOs
Message Queue Shared Memory Semaphores
Page 8
Page 9
ContentsContents
Pipes
FIFOs
System V IPC• Message Queues
• Shared Memory
• Semaphores
APUE (Interprocess Communication
Page 10
IPC using PipesIPC using Pipes
IPC using regular files• unrelated processes can share
• fixed size
• lack of synchronization
IPC using pipes• for transmitting data between related processes
• can transmit an unlimited amount of data
• automatic synchronization on open()
APUE (Interprocess Communication
Page 11
Pipes in a UNIX ShellPipes in a UNIX Shell
In a UNIX shell, the pipe symbol is: | (the vertical bar)
In a shell, UNIX pipes look like:$ ls -alg | more
• where the standard output of the program at the left (i.e., the producer) becomes the standard input of the program at the right (i.e., the consumer).
We can have longer pipes:$ pic paper.ms | tbl | eqn | ditroff -ms
APUE (Interprocess Communication
Page 12
Example (1/2)Example (1/2)
$ who | sort
APUE (Interprocess Communication
pipewho sort
write pointer ofanother process
read pointer of one process
Page 13
Example (2/2)Example (2/2) APUE (Interprocess Communication
Page 14
IPC using PipesIPC using Pipes
Data transmitting• data is written into pipes using the write() system call
• data is read from a pipe using the read() system call
• automatic blocking when full or empty
Types of pipes• (unnamed) pipes
• named pipes (FIFOs)
APUE (Interprocess Communication
Page 15
Pipes (1/4)Pipes (1/4)
In UNIX, pipes are the oldest form of IPC.
Limitations of Pipes:• Half duplex (data flows in one direction)
• Can only be used between processes that have a common ancestor (Usually used between the parent and child processes)
• Processes cannot pass pipes and must inherit them from their parent
• If a process creates a pipe, all its children will inherit it
APUE (Interprocess Communication
Page 16
Pipes (2/4)Pipes (2/4)
Two file descriptors are returned through the fd argument• fd[0]: can be used to read from the pipe, and
• fd[1]: can be used to write to the pipe
Anything that is written on fd[1] may be read by fd[0].• This is of no use in a single process.
• However, between processes, it gives a method of communication
The pipe() system call gives parent-child processes a way to communicate with each other.
APUE (Interprocess Communication
#include <unistd.h>
int pipe(int fd[2]) Returns: 0 if OK, -1 on error
Page 17
Pipes (3/4)Pipes (3/4) APUE (Interprocess Communication
parent child: parent closes fd[0] child closes fd[1]
parent child: parent closes fd[1] child closes fd[0]
pipe
kernel
fd[1]
parent
fd[0]
child
pipe
kernel
fd[0]
parent
fd[1]
child
Page 18
Pipes (4/4)Pipes (4/4)
Read from a pipe with write end closed: (fd[1] 이 close 된 경우 )
• returns 0 to indicate EOF
Write to a pipe with read end closed: (fd[0] 가 close 된 경우 )
• SIGPIPE generated,
• write() returns error (errno == EPIPE)
APUE (Interprocess Communication
Page 19
example: pipe.c (1/2)example: pipe.c (1/2)
#include <stdio.h> // pipe.c
#define READ 0#define WRITE 1
char* phrase = "Stuff this in your pipe and smoke it";
main( ) { int fd[2], bytesRead; char message[100]; pipe(fd); if (fork() == 0) { // child close(fd[READ]); write(fd[WRITE], phrase, strlen(phrase)+1); fprintf(stdout, "[%d, child] write completed.\n", getpid()); close(fd[WRITE]); } else { // parent close(fd[WRITE]); bytesRead = read(fd[READ], message, 100); fprintf(stdout, "[%d, parent] read completed.\n", getpid()); printf("Read %d bytes: %s\n", bytesRead,message); close(fd[READ]); }}
APUE (Interprocess Communication
Page 20
example: pipe.c (2/2)example: pipe.c (2/2) APUE (Interprocess Communication
실행 결과
Page 21
ContentsContents
Pipes
FIFOs
System V IPC• Message Queues
• Shared Memory
• Semaphores
APUE (Interprocess Communication
Page 22
FIFOs (1/3)FIFOs (1/3)
Pipes can be used only between related processes.(e.g., parent and child processes)
FIFOs are "named pipes" that can be used between unrelated processes.
A type of file• stat.st_mode == FIFO
• Test with S_ISFIFO() macro
APUE (Interprocess Communication
Page 23
FIFOs (2/3)FIFOs (2/3) APUE (Interprocess Communication
Creating FIFOs is similar to creating a file.• pathname: filename
• mode: permissons, same as for open() function
Using a FIFO is similar to using a file.• we can open, close, read, write, unlink, etc., to the FIFO.
#include <sys/types.h>#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode); Returns: 0 if OK, -1 on error
Page 24
FIFOs (3/3)FIFOs (3/3)
if FIFO opened without O_NONBLOCK flag• an open for read-only blocks until some other process opens the FIFO for writing
• an open for write-only blocks until some other process opens the FIFO for reading
if O_NONBLOCK is specified (nonblocking)• an open for read-only returns immediately if no process has the FIFO open for writing
• an open for write-only returns an error (errno=ENXIO) if no process has the FIFO open for reading
Like a pipe, if we write to a FIFO that no process has open for reading, the signal SIGPIPE is generated.
When the last writer for a FIFO closes the FIFO, an end of file (EOF) is generated for the reader of the FIFO.
APUE (Interprocess Communication
Page 25
Uses of FIFOsUses of FIFOs
Used by shell commands to pass data from one shell pipeline to another, without creating intermediate files.
Used in client-server application to pass data between clients and server.
APUE (Interprocess Communication
Page 26
Using FIFOs to Duplicate Output StreamsUsing FIFOs to Duplicate Output Streams APUE (Interprocess Communication
tee(1) copies its standard input to both its standard output and to the file named on its command line.
$ mkfifo fifo1$ prog3 < fifo1 &$ prog1 < infile | tee fifo1 | prog2
prog1 tee
prog2
prog3fifo1
infile
Page 27
An Example using a FIFOAn Example using a FIFO APUE (Interprocess Communication
Page 28
Client-Server Communication Using a FIFOClient-Server Communication Using a FIFO
Server creates a “well-known” FIFO to communicate with clients.
APUE (Interprocess Communication
Problem: Server can't reply clients using a single “well-known” FIFO
client
well-knownFIFO
readrequest
client
server
write request
write request
.
.
.
Page 29
ContentsContents
Pipes
FIFOs
System V IPC• Message Queues
• Shared Memory
• Semaphores ( 간단히 )
APUE (Interprocess Communication
Page 30
System V IPCSystem V IPC
Message Queues• Send and receive amount of data called “messages”.
• The sender classifies each message with a type.
Shared Memory• Shared memory allows two or more processes to share a given region of memory.
• Readers and writers may use semaphore for synchronization.
Semaphores• Process synchronization and resource management
• For example, a semaphore might be used to control access to a device like printer.
APUE (Interprocess Communication
Page 31
Identifiers & KeysIdentifiers & Keys
Identifier: each IPC structure has a nonnegative integer
Key: when creating an IPC structure, a key must be specified (key_t)
id = xxxget(key, …)
How to access the same IPC? key in a common header• Define a key in a common header
• Client and server agree to use that key
• Server creates a new IPC structure using that key
• Problem when the key is already in use
− (msgget, semget, shmget returns error)
− Solution: delete existing key, create a new one again!
APUE (Interprocess Communication
Page 32
IPC System CallsIPC System Calls
msg/sem/shm get• Create new or open existing IPC structure.
• Returns an IPC identifier
msg/sem/shm ctl• Determine status, set options and/or permissions
• Remove an IPC identifier
msg/sem/shm op• Operate on an IPC identifier
• For example(Message queue)
− add new msg to a queue (msgsnd)
− receive msg from a queue (msgrcv)
APUE (Interprocess Communication
Page 33
Permission StructurePermission Structure APUE (Interprocess Communication
ipc_perm is associated with each IPC structure.
Defines the permissions and owner.
struct ipc_perm { uid_t uid; /* owner's effective user id */ gid_t gid; /* owner's effective group id */ uid_t cuid; /* creator's effective user id */ gid_t cgid; /* creator’s effective group id */ mode_t mode; /* access modes */ ulong seq; /* slot usage sequence number */ key_t key; /* key */};
Page 34
Message Queues (1/2)Message Queues (1/2)
Linked list of messages• Stored in kernel• Identified by message queue identifier (in kernel)
msgget• Create a new queue or open existing queue.
msgsnd• Add a new message to a queue
msgrcv• Receive a message from a queue• Fetching order: based on type
APUE (Interprocess Communication
Page 35
Message Queues (2/2)Message Queues (2/2)
Each queue has a structure
APUE (Interprocess Communication
struct msqid_ds { struct ipc_perm msg_perm; struct msg *msg_first; /* ptr to first msg on queue */ struct msg *msg_last; /* ptr to last msg on queue */ ulong msg_cbytes; /* current # bytes on queue */ ulong msg_qnum; /* # msgs on queue */ ulong msg_qbytes; /* max # bytes on queue */ pid_t msg_lspid; /* pid of last msgsnd() */ pid_t msg_lrpid; /* pid of last msgrcv() */ time_t msg_stime; /* last-msgsnd() time */ time_t msg_rtime; /* last-msgrcv() time */ time_t msg_ctime; /* last-change time */ };
We can get the structure using msgctl() function.Actually, however, we don’t need to know the structure in detail.
Page 36
msgget()msgget() APUE (Interprocess Communication
#include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h>
int msgget(key_t key, int flag); Returns: msg queue ID if OK, -1 on error
Create new or open existing queueflag : ipc_perm.modeExamplemsg_qid = msgget(DEFINED_KEY, IPC_CREAT | 0666);
Page 37
msgctl()msgctl() APUE (Interprocess Communication
#include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h>
int msgctl(int msqid, int cmd, struct msqid_ds *buf); Returns: 0 if OK, -1 on error
Performs various operations on a queuecmd = IPC_STAT:fetch the msqid_ds structure for this queue, storing it in bufcmd = IPC_SET:set the following four fields from buf: msg_perm.uid, msg_perm.gid, msg_perm.mode, and msg_qbytescmd = IPC_RMID:remove the message queue.
Page 38
msgsnd()msgsnd() APUE (Interprocess Communication
#include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h>
int msgsnd(int msqid, const void *ptr, size_t nbytes, int flag); Returns: 0 if OK, -1 on error
msgsnd() places a message at the end of the queue.• ptr: pointer that points to a message• nbytes: length of message data• if flag = IPC_NOWAIT: IPC_NOWAIT is similar to the nonblocking I/O flag for file
I/O.
Structure of messages
struct mymesg { long mtype; /* positive message type */ char mtext[512]; /* message data, of length nbytes */};
Page 39
msgrcv()msgrcv() APUE (Interprocess Communication
#include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h>
int msgrcv(int msqid, void *ptr, size_t nbytes, long type, int flag); Returns: data size in message if OK, -1 on error
msgrcv() retrieves a message from a queue.type == 0: the first message on the queue is returnedtype > 0: the first message on the queue whose message type equals type is returnedtype < 0: the first message on the queue whose message type is the lowest value less than or equal to the absolute value of type is returnedflag may be given by IPC_NOWAIT
Page 40
example: sender.c receiver.c (1/4)example: sender.c receiver.c (1/4) APUE (Interprocess Communication
#include <stdio.h> // sender.c#include <sys/types.h>#include <sys/ipc.h>#include <sys/msg.h>
#define DEFINED_KEY 0x10101010
main(int argc, char **argv){ int msg_qid; struct { long mtype; char content[256]; } msg;
fprintf(stdout, "=========SENDER==========\n");
if((msg_qid = msgget(DEFINED_KEY, IPC_CREAT | 0666)) < 0) { perror("msgget: "); exit(-1); }
msg.mtype = 1; while(1) { memset(msg.content, 0x0, 256); gets(msg.content); if(msgsnd(msg_qid, &msg, sizeof(msg.content), 0) < 0) { perror("msgsnd: "); exit(-1); } }}
Page 41
example: sender.c receiver.c (2/4)example: sender.c receiver.c (2/4) APUE (Interprocess Communication
#include <stdio.h> // receiver.c#include <sys/types.h>#include <sys/ipc.h>#include <sys/msg.h>
#define DEFINED_KEY 0x10101010
main(int argc, char **argv){ int msg_qid; struct { long mtype; char content[256]; } msg;
fprintf(stdout, "=========RECEIVER==========\n");
if((msg_qid = msgget(DEFINED_KEY, IPC_CREAT | 0666)) < 0) { perror("msgget: "); exit(-1); }
while(1) { memset(msg.content, 0x0, 256); if(msgrcv(msg_qid, &msg, 256, 0, 0) < 0) { perror("msgrcv: "); exit(-1); } puts(msg.content); }}
Page 42
example: sender.c receiver.c (3/4)example: sender.c receiver.c (3/4) APUE (Interprocess Communication
Page 43
example: sender.c receiver.c (4/4)example: sender.c receiver.c (4/4) APUE (Interprocess Communication
Message Queue
Page 44
Shared MemoryShared Memory
Allows multiple processes to share a region of memory• Fastest form of IPC: no need of data copying between client & server
If a shared memory segment is attached• It become a part of a process data space, and shared among multiple processes
Readers and writers may use semaphore to• synchronize access to a shared memory segment
APUE (Interprocess Communication
Page 45
Shared Memory Segment StructureShared Memory Segment Structure
Each shared memory has a structure
APUE (Interprocess Communication
struct shmid_ds { struct ipc_perm shm_perm; struct anon_map *shm_amp; /* pointer in kernel */ int shm_segsz; /* size of segment in bytes */ ushort shm_lkcnt; /* # of times segment is being locked */ pid_t shm_lpid; /* pid of last shmop() */ pid_t shm_cpid; /* pid of creator */ ulong shm_nattch; /* # of current attaches */ ulong shm_cnattch; /* used only for shminfo() */ time_t shm_atime; /* last-attach time */ time_t shm_dtime; /* last-detach time */ time_t shm_ctime; /* last-change time */ };
We can get the structure using shmctl() function.Actually, however, we don’t need to know the structure in detail.
Page 46
shmget()shmget() APUE (Interprocess Communication
#include <sys/types.h> #include <sys/ipc.h> #include <sys/shm.h>
int shmget(key_t key, int size, int flag); Returns: shared memory ID if OK, -1 on error
Obtain a shared memory identifiersize: is the size of the shared memory segmentflag: ipc_perm.modeExampleshmId = shmget(key, size, PERM|IPC_CREAT|IPC_EXCL|0666);
Page 47
shmctl()shmctl() APUE (Interprocess Communication
#include <sys/types.h> #include <sys/ipc.h> #include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf); Returns: 0 if OK, -1 on error
Performs various shared memory operationscmd = IPC_STAT:fetch the shmid_ds structure into bufcmd = IPC_SET:set the following three fields from buf: shm_perm.uid, shm_perm.gid, and shm_perm.modecmd = IPC_RMID:remove the shared memory segment set from the system
Page 48
shmat()shmat() APUE (Interprocess Communication
#include <sys/types.h> #include <sys/ipc.h> #include <sys/shm.h>
void *shmat (int shmid, void *addr, int flag); Returns: pointer to shared memory segment if OK, -1 on error
Attached a shared memory to an address
flag = SHM_RDONLY: the segment is read-only
addr==0: at the first address selected by the kernel (recommended!)
addr!=0: at the address given by addr
Page 49
shared memory
Memory LayoutMemory Layout APUE (Interprocess Communication
uninitialized data(bss)
stack
heap
initialized data
text
high address
low address
command-line argumentsand environment variables
0xf7fffb2c
0xf77e86a00xf77d0000 shared memory of 100,000 bytes
0x0003d2c80x00024c28
malloc of 100,000 bytes
0x0003d2c80x00024c28 array[] of 40,000 bytes
Page 50
shmdt()shmdt() APUE (Interprocess Communication
#include <sys/types.h> #include <sys/ipc.h> #include <sys/shm.h>
void shmdt (void *addr); Returns: 0 if OK, -1 on error
Detach a shared memory segment
Page 51
example: tshm.c (1/2)example: tshm.c (1/2) APUE (Interprocess Communication
#include <sys/types.h> // tshm.c#include <sys/ipc.h>#include <sys/shm.h>
#define ARRAY_SIZE 100000#define MALLOC_SIZE 100000#define SHM_SIZE 100000
err_sys(char *p) { perror(p); exit(-1); }
char array[ARRAY_SIZE]; /* uninitialized data = bss */
int main(void) { int shmid; char *ptr, *shmptr;
printf("array[] from %x to %x\n", &array[0], &array[ARRAY_SIZE]); printf("stack around %x\n", &shmid);
if ((ptr = malloc(MALLOC_SIZE)) == NULL) err_sys("malloc error"); printf("malloced from %x to %x\n", ptr, ptr+MALLOC_SIZE);
if ((shmid = shmget(0x01010101, SHM_SIZE, IPC_CREAT | 0666)) < 0) err_sys("shmget error");
if ((shmptr = shmat(shmid, 0, 0)) == (void *) -1) err_sys("shmat error"); printf("shared memory attached from %x to %x\n", shmptr, shmptr+SHM_SIZE);
// if (shmctl(shmid, IPC_RMID, 0) < 0) err_sys("shmctl error");
exit(0);}
Page 52
APUE (Interprocess Communicationexample: tshm.c (2/2)example: tshm.c (2/2)
Page 53
SemaphoresSemaphores
A counter to provide access to shared data object for multiple processes
To obtain a shared resource:• 1. Test semaphore that controls the resource• 2. If value > 0, value--, grant use • 3. If value == 0, sleep until value > 0 • 4. Release resource, value ++
Step 1, 2 must be an atomic operation
APUE (Interprocess Communication
Page 54
Semaphore StructureSemaphore Structure APUE (Interprocess Communication
Each semaphore has a structurestruct semid_ds { struct ipc_perm sem_perm; struct sem *sem_base; /*ptr to first semaphore in set */ ushort sem_nsems; /* # of semaphors in set */ time_t sem_otime; /* last-semop() time */ time_t sem_ctime; /* last-change time */ };
struct sem { ushort semval; /* semaphore value, always >= 0 */ pid_t sempid; /* pid for last operation */ ushort semncnt; /* # processes awaiting semval > currval */ ushort semzcnt; /* # processes awaiting semval = 0 */ };
We can get the structure using semctl() function.Actually, however, we don’t need to know the structure in detail.
Page 55
semget()semget() APUE (Interprocess Communication
#include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h>
int semget(key_t key, int nsems, int flag); Returns: semaphore ID if OK, -1 on error
Obtain a semaphore IDnsems: sem_nsens (# of semaphores in set)flag: ipc_perm.mode
Page 56
semctl()semctl() APUE (Interprocess Communication
#include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h>
int semctl(int semid, int semnum, int cmd, union semun arg);
union semun { int val; /* for SETVAL */ struct semid_ds *buf; /* for IPC_START and IPC_SET */ ushort *array; /* for GETALL and SETALL */};
To use semaphore, please refer to the textbook and manuals related semaphore.
Page 57
ipcs, ipcrmipcs, ipcrm
ipcs: checking status of System V IPC• $ ipcs // check information of IPC (q, m, s)• $ ipcs –q ($ ipcs –qa) // check information of Message Queue • $ ipcs –m ($ ipcs –ma) // check information of Shared Memory• $ ipcs –s ($ ipcs –sa) // check information of Semaphore
ipcrm: delete a defined IPC• $ ipcrm –q id // Delete Message Queue• $ ipcrm –m id // Delete Shared Memory• $ ipcrm –s id // Delete Semaphore
APUE (Interprocess Communication
Page 58
Memory mapped file I/OMemory mapped file I/O APUE (Interprocess Communication
#include <sys/types.h> #include <sys/mman.h>
caddr_t mmap (caddr_t addr, size_t len, int prot, int flag, int filedes, off_t off); Returns: starting address of mapped region if OK, -1 on error
int munmap(caddr_t addr, size_t len);Returns : 0 if OK, -1 on error
Memory mapped I/O lets us map a file on disk into a buffer in memory so that when we fetch bytes from the buffer, the corresponding bytes of the file are read. Similarly, when we store data in the buffer, the corresponding bytes are automatically written to the file. This lets us perform I/O without using read or write.
To use this feature we have to tell the kernel to map a given file to a region in memory.