『리눅스 학당-리눅스 강좌 / 연재 (go LINUX)』 475번 제 목:[강좌1] 시스템 V IPC - IPC 의 개념 올린이:ddoch (한동훈 ) 97/07/06 00:32 읽음:2987 관련자료 없음 ----------------------------------------------------------------------------- -=-=-=-=-=-=-=-=-=-=-=-=-=-=-= 시스템 V IPC 통신 강좌 -=-=-=-=-=-=-=-=-=-=-=-=-=-=-= 글쓴이 : 한동훈 ddoch@hitel.kol.co.kr 날 짜 : 1997.7.3 저작권 : GPL 기타사항 : 질문과 관련된 내용이나 답변을 요하는 내용은 메일로 적어주지 마시고 관련 프로그래밍 게시판을 이용해 주시면 아는 데 까지 성의껏 답변해 드리겠습니다. 참고자료 : Beginning Linux Programming 중 '12장 세마포어, 공유메모리, 메시지 큐' Advanced Programming in the UNIX Environment 중 IPC 부분 UNIX 시스템 프로그래밍 중 IPC 부분 Linux IPC 관련 man 페이지 준비사항 : C 에 대한 기본적인 이해 Linux & UNIX 시스템에 대한 전반적인 이해 '안되면 되게 하라!'는 군바리 정신 궁뎅이에 땀띠가 나도록 지긋이 컴 앞에 앉아 있을 수 있는 정신 프로그램 실행환경 : Linux 슬랙웨어 (알짜) 3.1 커널 2.0.0 GCC 2.7.2 □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ 목 차 □ □ □ □ 1. 들어가는 말 □ □ 2. IPC 개요 □ □ 3. 세마포어 □ □ 4. 공유메모리 □ □ 5. 메시지 큐 □ □ 6. 나오는 말 □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ 1. 들어가는 말 요즘 들어 날씨도 무척 더워지고 있는 것 같습니다. 작년 같으면 한참 물놀이한다 고 바쁠 시기인데, 이번 여름이 다가기 전에 자연과 함께 멋진 추억을 만들어 보심 이 어떨지.. ^^; 뒤돌아 보면 아름다운 리눅스.. 이 리눅스 때문에 안그래도 더운 올 여름을 더욱 끓이고 계신 분들이 많으시더군요. 사랑스러운 마음에 뽀뽀라도 해주고 싶어서 안달인 분들, 짝사랑에 지쳐서 모니터만 뚫어져라 쳐다보고 계신 분들, 새옷이라도 입혀서 좀 더 멋있게 만들어 주려고 없는 호주머니 먼지를 톡톡 터시는 분들... 그 분들과 함께 '가자. 아틀란티스로!'가 아닌 '가자. 리눅스의 심해로!'라고 외쳐 보고 싶군요. ~.~ 이승희 처자(?) 만큼이나 시원한 IPC 프로그래밍을 마음껏 즐겨 보십시요. :) 2. IPC 의 개요 IPC 는 'InterProcess Communication' 의 준말입니다. 우리말로 해석하면 '프로세스 간 통신' 정도의 뜻입니다. IPC 를 이용하면, 프로세스간에 편지를 주고 받을 수도 있고, 일정한 메모리를 공유하여 시스템의 리소스를 절약하거나 대용량의 데이터를 교환할 수도 있으며, 마치 교통신호등같이 프로세스끼리 사이좋게 협력하여 어떠한 일을 처리 할 수도 있습니다. 다중 프로세스, 다중 사용자 환경에서의 프로그래밍 상 에서 발생할 수 있는 프로세스 동기화 같은 문제점을 해결하거나 프로세스 사이 의 통신에 주로 사용된다는 것입니다. IPC 는 시스템 V.2 판에서 제공되기 시작했으며, 아주 유용한 기능들을 제공하고 있 습니다. 일반적으로 IPC 삼총사로 불리우는 세마포어, 공유메모리, 메시지 큐가 있 으며, Linux 시스템에서 IPC 패키지를 깔았다면 (거의 대부분의 경우에 설치되어 있 을 겁니다.) 시스템에서 제공하는 IPC 관련 설비를 이용할 수 있습니다. 그럼, IPC 설비의 장점을 한번 살펴볼까요? 무엇이던지 먼저 구미가 당겨야 겠죠? 가. IPC 의 장점 ㄱ. 다중 프로세스 환경에서 필요한 프로세스 동기화 문제를 손쉽게 해결할 수 있습 니다. Linux & UNIX 환경에서 DB 관련 응용 프로그램을 개발할 경우가 좋은 예가 될 수 있겠군요. 여러명의 사용자가 동시에 어떤 하나의 파일에 쓰기를 시도할 경우 는 종종 있습니다. 동시에 읽기 같은 경우에는 문제가 발생할 소지가 그다지 없 지만 쓰기시 에는 좀 다릅니다. 예를 하나 들어 보겠습니다. 어떤 하나의 파일에 동시에 두개의 프로세스가 파일의 끝부분에 내용을 추가하기 위해 접근을 한다고 가정합시다. 두개의 프로세스를 P1, P2 라고 하고, 기존의 파일의 내용을 F0, P1 이 추가하려는 내용을 F1, P2 가 추가하려는 내용을 F2라 고 가정하겠습니다. 동시에 쓰기를 시도하지 않는다면, P1 이 먼저 쓰기를 했 을 경우에는 다음과 같은 정상적인 결과가 나올 것입니다. +------------------+---------+---------+ | F0 | F1 | F2 | +------------------+---------+---------+ [그림1 - 하나의 파일에 두개의 프로세스가 순서대로 쓰기를 했을 경우] 그러나 동시에 쓰기를 시도할 때에는, 원치 않는 결과가 나올 수도 있습니다. P1 이 파일을 열어서 쓰기 직전에 P2가 파일을 열었다면, 현재 P1, P2 가 가지고 있는 파일의 이미지는 꼭 같은 것이 될 것입니다. 이 경우에 P1은 F1 을 F0 뒤에 추가하고 파일을 닫습니다. 그리고 P2도 F0 뒤에 F2 를 추가시키고 파일 을 닫을 것입니다. 이렇게 된다면 F1, F2 가 차례로 파일의 뒷부분에 추가되는 것이 아니라 F1, F2 의 내용이 뒤섞이게 되어서 데이터가 엉망으로 될 것입니다. 이 경우를 보통 데이터가 '크럽' 된다라고 이야기를 합니다. 실제의 경우에는 이 보다도 더 다양한 문제가 나타납니다. 연습용으로 짜는 프로그램일 경우는 모 르겠지만 실제 사용을 목적으로 하는 응용 프로그램에 이런 결점이 있어서는 안 될 것입니다. (실제 F1 의 내용은 사라지겠죠? 덮어썼으니..) +---------------+ | F2 | +------------------+---------+-----+ | F0 | | | +------------------+---------+-----+ | F1 | +---------+ [그림2 - 하나의 파일에 두개의 프로세스가 동시에 쓰기를 했을 경우] 뒤에서 말씀드리겠지만, 여기서 파일을 열어서 닫는 부분까지가 '임계영역'이라고 합니다. 이 임계영역은 한번에 하나의 프로세스만이 수행되도록 해야 합니다. 이러한 프로세스의 동기화 문제를 해결하는 데 IPC 설비를 사용하면 아주 유용합 니다. ㄴ. 프로세스 사이의 데이터 교환에 있어서 아주 소규모에서 대규모까지 효율적으로 처리 할 수 있습니다. 흔히 'fifo' 라고 부르는 '명명된 파이프'(파이프가 객관화 되어 이름이 붙여진 것)도 프로세스 간의 통신에 사용될 수 있지만 데이터 교환에는 그 용량에 한계 가 있습니다. 비교적 자그마한 데이터 일 경우에는 손쉬운 '메시지 큐'를 사용 할 수 있고, 수메가에 이르는 아주 큰 데이터 일 경우에는 '공유메모리'를 사용 하여 효율적으로 처리할 수 있습니다. ㄷ. IPC 함수들은 하나하나가 아주 잘 설계되어 있으며, 각 설비마다의 일관적인 인 터페이스를 사용하고 있으며 사용방법 또한 손쉽습니다. 시스템 V IPC 의 또다른 장점은 해당 함수들이 하나하나가 강력한 기능을 가지고 있으며 IPC 설비별로 마련된 함수들이 아주 유사하게 동작한다는 것입니다. 따라서 하나만 제대로 알면 나머지 것도 익히는 데 그리 어렵지 않습니다. ㄹ. 프로그램 상의 코드를 간략화 할 수 있습니다. 다른 설비를 사용하는 것보다 신경 쓸 부분이 줄어들며, 함수의 갯수도 적어질 것 이며, 소스의 코드 또한 간결하게 만들 수 있습니다. 이것은 나중에 실제로 코드 를 작성해 보시면 알 수 있습니다. 나. IPC 의 원리 이제, IPC 의 기본 원리를 살펴보도록 하겠습니다. 파이프나 여타의 인터페이스와는 조금 색다른 방법을 사용합니다. 즉, 프로세스간 통신을 위해 IPC 설비를 필요로 하는 프로세스는 시스템 전역에 걸쳐 사용할 수 있는 해당 설비를 만들 수 있다는 것입니다. 기존의 설비들이 지역적으로 유효하거나, 시스템 호출을 사용하여 커널에 요청하는 것과 같은 간접적인 방식을 사용해왔다면, IPC 설비는 좀 더 사용자가 직 접적으로 손쉽게 접근할 수 있는 인터페이스를 제공한다고 볼 수 있습니다. 이러한 점 때문에 처음에 IPC 가 등장했을 때, IPC 를 UNIX 에 있어서 아주 이색적인 것으 로 생각하는 사람이 많았던 것 같습니다. 지금이야 IPC 보다 좀 더 발전된 형태의 '프로세스간 통신 설비'를 연구가 진행되고 있지만요. +-------------+ +--------------+ | 프로세스 P1 | | 프로세스 P2 | +-------------+ +--------------+ | ^ \ ^ / ^ | ^ 사용자 프로세스 | | \ \ / / | | 영역 | | \ \ / / | | | | \ \ / / | | | | \ \ / / | | - - -| -| - -- \- -\ - - -- -/ - /- - -- - - |- |- -- - - - - -- - - - - | | \ \ / / | | V | \ \ V / V | 시스템 영역 +-----------+ V +-----------+ +-----------+ | 123 | | 342 | | 582 | +-----------+ +-----------+ +-----------+ | 139 | | 116 | | 632 | +-----------+ +-----------+ +-----------+ | 156 | | 400 | | 215 | +-----------+ +-----------+ +-----------+ 세마포어 공유메모리 메시지 큐 세그먼트 [ 그림3 - IPC 설비와 프로세스 ] 위에서 보시는 바와 같이, 프로세스간에 직접적으로 통신을 하는 것이 아니고, 시스 템 내부에 있는 IPC 설비들을 통하여 데이터를 주고 받는 것입니다. 이러한 설비들 은 어떠한 프로세스라도 만들 수 있으며, 없애는 것은 권한을 가진 프로세스라면 가 능합니다. 마치 파일의 접근권한과 유사하게 해당 IPC 설비들도 접근권한이 있으며 권한을 변경하는 것도 가능합니다. 그리고 위에서 숫자는 각 설비안의 하나의 객체 의 식별자(또는 아이디)입니다. 마치 우리가 보통 살고 있는 집을 주소로 참조하듯 이 하나의 설비를 고유한 숫자로 참조하는 것입니다. 물론 위의 숫자는 하나의 예 일 뿐입니다. 다. IPC 인터페이스 IPC 에 이렇게 서로다른 세마포어, 공유메모리, 메시지 큐가 있지만, 서로 접근하는 방법은 비슷합니다. 실제 함수를 설명할 때 이해하기 쉽도록 먼저 각 기능별로 묶 어서 말씀 드리겠습니다. ㄱ. IPC 설비 생성과 식별자 얻기 semget, shmget, msgget 함수가 세마포어, 공유메모리, 메시지 큐에서 각각 해당 설 비를 생성하고 식별자를 얻는 함수입니다. 이들 함수에서 매개변수에 IPC_CREAT 를 설정하면 관련 설비를 생성할 수 있으며, 접근권한도 동시에 파일접근권한과 마찬가 지로 '666' 등과 같이 설정할 수 있습니다. 이들 함수가 돌려주는 값은, 일반적으 로 해당 IPC 설비의 식별자입니다. 마치 파일을 열었을 경우에 얻을 수 있는, 파일 스트림이나 파일 디스크럽터 같은 것입니다. 파일 디스크럽터와 더 가깝겠군요. ㄴ. IPC 제어하기 semctl, shmctl, msgctl 함수가 세마포어, 공유메모리, 메시지 큐에서 각각 해당 설 비의 권한을 설정하거나 하는 등의 제어를 수행합니다. ㄷ. 해당 IPC 설비에 따른 인터페이스 세마포어에서는 semop 를 사용하여 세마포어 변수의 값을 변경시키며, 공유메모리에 서는 shmat 을 사용하여 공유메모리를 해당 프로세스의 주소영역에 덧붙여 사용가능 하게 만들며, shmdt 를 사용하여 공유메모리를 해당 프로세스의 주소영역에서 떼어 내어 사용하지 못하도록 하며, 메시지 큐에서는 msgsnd 와 msgrcv 를 사용하여 메시 지를 주고 받습니다. ㄹ. IPC 제거하기 IPC 를 제거하는 방법은 semctl, shmctl, msgctl 을 사용하여 해당 매개변수의 플래 그를 IPC_RMID 로 설정함으로써 없앨 수 있습니다. 여기에서 semget, shmget, msgget 함수에서 얻은 해당 설비의 식별자를 다른 함수에 서 사용합니다. (3장 세마포어가 계속 됩니다. ) 『리눅스 학당-리눅스 강좌 / 연재 (go LINUX)』 476번 제 목:[강좌2] 시스템 V IPC - 세마포어 올린이:ddoch (한동훈 ) 97/07/06 00:33 읽음:2199 관련자료 없음 ----------------------------------------------------------------------------- 3. 세마포어 세마포어에 대해서는 정말 말이 많습니다. 운영체제 개론서에도 세마포어는 빠지지 않는 단골 손님입니다. :) 아울러 Linux & UNIX 프로그래밍을 처음 배우시는 분에 게는 공포의 대상(?)이기도 합니다. ( 잡담: 좀 지난 이야기지만 리눅스 초보자 게시판에 세마포어에 관련된 질문이 올 라온 적이 있습니다. 물론 질문하신 분도 초보자라고 생각하셨는 지는 모르겠지 만, 리눅스 설치나 일반적인 질문을 다루는 게시판에 세마포어가 잘안된다시면서 소스에 대한 설명과 그 증상까지 친절하게 설명해주시는 바람에 게시판 담당자분 과 몇분이 누렇게 뜬 일이 있습니다. 누구보고 답변을 하라는 소리인지... 공부하시는 것도 좋지만 초보자 게시판에 이런 내용을 올려놓으면 이제 그나마 열 심히 리눅스 공부하려고 들러시는 분들의 의욕을 꺽어 놓을 수도 있겠죠? :) ) ( 잡담: 그렇긴 하지만, IPC 의 세마포어는 Linux & UNIX 프로그래밍을 공부하시려 면 기본적으로 터득하여야 할 기본적인 내용이라고 생각합니다. 물론 이러한 프 로세스 동기화에 관련된 다른 방법을 사용하신다던지 자체로 방법을 개발하여 사 용하신 다면 별로 사용할 일이 없겠지만, 그렇다 하더라도 기본 개념을 알아두시 면 도움이 반드시 될 겁니다. ) 가. 세마포어의 정의 왜 세마포어를 어렵게 생각할까요? 그 이유는 다른 두개의 IPC 설비와는 달리 세마 포어는 알고리즘이 개입되기 때문입니다. 다른 두개의 IPC 설비는 아이디어 차원이 지만 세마포어는 프로세스 동기화를 위해 학술적으로 연구된 개념입니다. 원래 'Dijkstra' 가 제안하였으며, 세마포어에 보면 두개의, wait 와 signal 에 해당하는 p(passeren) 와 v(vrjgeven) 가 있습니다. 세마포어는 실제 사용에 있어서는 프로세스 동기화에 관련하는 하나의 변수의 배열 을 말합니다. 가장 간단한 세마포어는 0과 1의 값만 사용하는 이진(바이너리)세마 포어입니다. 배열을 사용하는 세마포어는 보통 '일반적인' 세마포어라고 말하지요. 여기에서는 이진 세마포어를 사용하겠습니다. 물론 이진 세마포어만을 사용한다고 할지라도 어지간한 프로세스 동기화 문제를 해결하는 데는 충분합니다. 이제 p 와 v 에 대해서 알아보겠습니다. p 와 v 는 하나의 동작을 의미하는 데, 잘 살펴보면 재미있습니다. 여기에서 sv 는 0과 1의 값을 가지는 이진 세마포어 변 수를 의미합니다. * p(sv) sv 가 0보다 크다면, sv 를 감소시킨다. sv 가 0이라면, 이 프로세스 의 수행을 중단시킨다. * v(sv) 중단된 다른 프로세스의 수행을 재개시킨다. 중단된 프로세스가 없다 면 sv 를 증가시킨다. 세마포어는 임계영역에서 주로 사용된다고 앞에서 말씀드렸습니다. 위에서의 예와 같이 파일을 열어서 쓰는 부분까지를 임계영역으로 설정하고 p 와 v 의 동작을 설 명드리겠습니다. 이렇게 가정하면 해당코드의 임계영역은 다음과 같이 될 것이고 임계영역의 들어가는 부분과 나오는 부분을 의사코드로 표시하면 다음과 같이 될 것 입니다. 임계영역의 밖 (non-critical code section) p(sv); 해당파일을 연다. ---+ 임계 ( critical code 해당파일에 쓴다. ---+ 영역 section ) v(sv); 임계영역의 밖 (non-critical code section) 임계영역의 밖은 상관없지만, 임계영역의 안쪽은 한번에 하나의 프로세스만이 수행 되어야 합니다. 그렇지 않다면 위에서 설명한 바와 같은 크럽이 발생할 수 있습니 다. 보통 이진 세마포어 변수의 초기값은 처음에 1로 설정됩니다. 즉, 여기서는 sv 의 초기값이 1이라는 것입니다. 이제 프로세스 P1 이 파일에 쓰기 작업을 하기 위해 임계영역에 다가오게 되면, p 를 수행하게 됩니다. sv 의 값이 1이라는 것은 아직 임계영역이 사용중이 아니라 는 의미를 가지게 되므로 P1은 sv 를 0으로 설정하고 임계영역을 수행합니다. 프로 세스 P2 도 임계영역에 진입하기 위해 p 를 수행합니다. 하지만 sv 의 값이 이미 0이므로 임계영역이 사용중이라서 시스템에 의해 잠들게 됩니다. 그동안 P2 는 파일에 쓰는 작업까지 마치고 더이상 임계영역에 있을 필요가 없을 경우가 되어서 임계영역을 벗어나기 위해 v 를 수행합니다. v 를 수행하면서 sv 의 값을 1로 설정 하고 잠자는 프로세스를 일깨웁니다. 이때 P1 은 잠에서 깨어나서 sv 가 1로 설정 되었음을 알고 임계영역을 수행합니다. 이렇게 임계영역은 한번에 하나의 프로세스 만이 수행되도록 하는 것이 임계영역에서의 프로세스의 동기화 라고 보통 이야기 합 니다. 물론 프로세스가 많아도 이런 작업은 순식간에 처리되기 때문에 잠드는 시간 은 아주 짧은 시간이 됩니다. 여기에서 필요한 sv 는 시스템 전역에 걸친 변수가 되어야 하는 데 이러한 설비를 일반적으로 세마포어라고 이야기 하는 것입니다. (잡담: 물론 프로세스 동기화를 시키는 데 꼭 세마포어만 사용할 수 있는 것은 아닙 니다. 자신이 만든 어떠한 방법을 사용하거나 프로그램의 규모가 작을 경우에는 간단하게 파일을 만들어서 표시해 두는 방법을 사용하기도 합니다. 이럴 경우에 별 문제가 없을 수도 있지만 프로그램이 조금만 커지면 금방 문제가 드러납니다. 리눅스에서 통신프로그램으로 널리 알려진 seyon 도 이런 방법을 사용합니다. 보통 모뎀은 하나이므로 하나의 프로세스가 처음으로 seyon 을 띄우게 되면 다른 사람들 은 쓸 수 없도록 만들어야 합니다. 이 목적을 위해서 '잠금(lock)파일'을 만들어 두는 데, 프로그램이 실행될 때 해당 파일이 있으면, 실행을 하지 않고 에러 메시지 를 내는 경우입니다. 그러나, 프로그램이 정상적으로 종료하면서 잠금파일을 지워 야 하는 데 그렇지 못한 비정상적인 종료시에는 이러한 파일을 남길 수도 있습니다. 이럴 때는 사용자가 직접 해당 파일을 찾아서 지워줘야 합니다. 아마도 이런 경험 은 한번씩은 있으실 겁니다. 얼마전에 프로그램을 하나 짤 일이 있었는 데, 규모는 중간급 정도였지만 세마포어 를 사용하기가 귀찮아서 잠금파일을 만들어서 프로세스의 동기화를 처리한 적이 있 었습니다. 얼마동안은 프로그램이 잘 실행이 되더니 어느날 프로그램의 비정상적 인 중단이후에는 프로그램이 유독 한지점에서만 실행을 멈추더군요. 전 잠금파일은 생각도 안하고 어디가 잘못됐나 하고 오랜시간을 소스를 뒤져서 찾기에 정신이 없 었습니다만 잠금파일이 있는 것을 발견하고 쓴웃음을 지은 적이 있습니다. 잠금파일을 만드는 방법은 간단한 작업에는 쓸만할 수도 있으나, 규모가 큰 프로그 램에는 적당하지 못하다는 것을 느낀 적이 아니였나 합니다. ) 세마포어를 실제로 사용할 때는 생각보다 아주 쉽습니다. 조금있다 말씀드리겠지만 생각보다 어렵지 않다는 것을 알아두시기 바랍니다. 세마포어의 핵심적인 기능은 이미 다 갖추어져 있으므로 우리는 그것을 즐기기만 하면 된다는 것입니다. 나. 세마포어 함수 세마포어 설비는 관련되는 세개의 함수로 이루어져 있습니다. 관련 헤더파일은 자료 형 정의에 필요한 와 IPC 설비에 일반적으로 필요한 와 세마포어에 필요한 특수한 정의를 포함하기 위해서 가 필요합니다. 이것은 다른 공유메모리 (sys/shm.h)와 메시지 큐 (sys/msg.h) 도 마찬가지입니다. 함수를 하나씩 살펴볼까요? ㄱ. semget int semget(key_t key, int nsems, int semflg); semget 함수는 세마포어를 만들거나 key 에 해당하는 세마포어 식별자를 돌려줍니다. key 는 프로세스와는 독립적으로 동일한 세마포어에 접근하는 것을 가능하게 합니다. semget 은 이 key 값을 참고하여 해당 세마포어 식별자를 돌려줍니다. 세마포어에서 key 는 semget 에서만 사용하며, 다른 함수들에서는 semget 에서 반환된 세마포어 식별자를 사용합니다. key 값중 특별한 값이 있는 데, IPC_PRIVATE 가 그것입니다. IPC_PRIVATE 를 key 값으로 사용하여 세마포어를 만들게 되면 프로세스 자기만 세마 포어에 접근할 수 있게 되는 것입니다. 일종의 혼자만 알고 있는 'back door' 라고 할까요? :) nsems 는 사용할 세마포어의 변수의 갯수입니다. 보통 2개 이상 사용할 때도 있으 나 1개정도만 해도 대부분의 경우에 충분합니다. semflg 의 하위 9비트는 파일 접근권한을 나타날 때 사용되는 9비트와 동일합니다. 잘 아시다시피, '666' 은 모든 프로세스들이 읽고 쓸 수 있도록 하는 것이죠.. 이것과 함께 다른 플래그를 비트 OR 연산할 수 있습니다. IPC_CREAT 를 사용하면, 세마포어를 만듭니다. 만일 세마포어가 존재할 경우에는 IPC_CREAT 는 무시되어서, 해당 세마포어의 식별자만 돌려줍니다. IPC_EXCL 은 IPC_CREAT 와 함께 사용되는데, 이 경우에는 세마포어가 없으면 만들게 되지만, 있을 경우에는 에러를 반환합니다. 'man semget' 해보시면 아시겠지만, 이경우에는 errno 는 EEXIST 에러코드로 설정 됩니다. 해당 프로세스가 접근권한을 가지고 있지 않다면 errno 는 EACCES 로 설정 되겠죠? 이러한 자세한 사항과 시스템의 자원 제한에 대한 사항은 'man 해당함수' 로 더 자세히 알아보시기 바랍니다. 실제 사용의 예를 들어보겠습니다. int semid; semid = semget((key_t)1234, 1, 0666 | IPC_CREAT); 이 경우에는 key 값이 1234 이고, 접근권한을 모두에게 허용하는 세마포어 변수 한 개를 생성합니다. semid 에는 이후의 함수에 사용할 수 있는 식별자가 반환됩니다. int semid; if ((semid = semget((key_t)100, 1, 0666 | IPC_CREAT | IPC_EXCL)) == -1) { if (errno == EEXIST) { semid = semget((key_t)100, 1, 0); } } else { /* semctl 로 세마포어의 값을 초기화 */ } 보통 이렇게 많이 사용합니다. 처음에 semget 함수는 key 값이 100이고, 접권권한 이 0666인 세마포어를 하나 만들고 그 식별자를 semid 에 돌려줍니다. 그러나 해당 세마포어가 이미 존재할 경우에는 -1을 반환하고 errno 는 EEXIST 로 설정되기 때문 에 바로 밑부분에서 semget 함수를 다시 사용하여 semid 에 식별자를 얻고 있습니다. else 부분에서는 이후에 말씀드리겠지만 세마포어 변수의 초기화 작업을 수행합니다. 세마포어 변수의 최기화는 처음에 보통 한번만 수행되어야 하기 때문에 해당 세마포 어를 생성한 프로세스만이 수행하게 되겠지요? 처음의 semget 에서 IPC_EXCL 을 없 애버리고 사용하면 semid 를 얻는 데는 지장이 없지만 semget 의 반환값이 프로세스 마다 같아서 이후에 마땅히 semctl 로 세마포어의 값을 초기화할 방법이 없어집니다. 즉, 최초의 프로세스는 세마포어를 생성하고 세마포어의 값을 초기화하지만, 그 이 후의 프로세스는 세마포어 식별자만 얻도록 되어 있습니다. semget 은 수행이 실패했을 경우에는 -1, 성공했을 경우에는 해당 세마포어 식별자 를 돌려줍니다. ㄴ. semctl int semctl ( int semid, int semnum, int cmd, union semun arg ) semctl 은 이미 존재하는 세마포어에 대한 제어 작업을 수행합니다. 즉, semid 에 의해 지정된 세마포어 집합중에 semnum 번째 세마포어를 cmd 로 제어를 하는 것입니다. semid 는 바로 앞에서 살펴본 semget 에서 반환되는 세마포어 식별자입니다. semnum 은 제어를 수행할 해당 세마포어의 인덱스입니다. 첫번째 세마포어 변수는 0번입니다. 여기서는 하나의 세마포어를 사용하므로 계속 0번만 됩니다. cmd 에는 여러 값이 있지만 많이 사용되는 것만 말씀드리겠습니다. SETVAL 은 세마포어집합의 semnum번째 원소의 semval의 값을 arg.val로 설정합니다. arg 는 semun 공용체 변수인데 잠시뒤에 설명드리겠습니다. IPC_RMID 는 해당 세마포어를 제거하는 역할을 합니다. 나머지도 여러가지가 있지 만 자주 사용하게 되지는 않게 될 것입니다. semun 공용체는 다음과 같이 정의되어 있습니다. union semun { int val; /* used for SETVAL only */ struct semid_ds *buf; /* for IPC_STAT and IPC_SET */ ushort *array; /* for GETALL and SETALL */ }; 여기에서 val 멤버는 semval 의 값을 설정하는 데 사용됩니다. 이왕 말이 나왔으니, 자주 사용하지는 않지만 해당 세마포어의 정보를 얻고 설정하는 데 사용되는 semid_ds 구조체와 IPC_STAT, IPC_SET 에 대해서 알아봅시다. /* 세마포어 집합 중 각각의 세마포어 semid 데이터 구조체 */ struct semid_ds { struct ipc_perm sem_perm; /* permissions .. see ipc.h */ 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 */ ushort sem_nsems; /* no. of semaphores in array */ }; 간단한 설명이 옆에 주석으로 되어 있으니 무슨 뜻인지는 대충 아실 것입니다. IPC_STAT 는 식별자로 지정된 해당 세마포에 대한 정보를 arg.buf 로 복사를 합니다. IPC_SET 은 arg.buf 에 설정된 shmid_ds 구조체의 값을 식별자로 지정된 해당 세마 포어의 정보로 복사를 합니다. 주로 사용될 때는 이미 만들어진 세마포어에 대한 접근권한을 수정한다던지 uid, gid 등을 수정할 때 입니다. 실제로는 어떻게 사용하는 지 살펴볼까요? /* 세마포어의 값을 초기화 할 경우 */ union semun arg; arg.val = 1; semctl(semid, 0, SETVAL, arg); semun 변수로 arg 를 하나 선언하고, arg.val 을 먼저 1로 설정한 다음, semctl을 arg 매개변수와 SETVAL를 사용하여 호출하면, semid 식별자로 참조하는 세마포어의 값을 1로 초기화 하게 됩니다. /* 세마포어를 제거하는 경우 */ union semun arg; semctl(semid, 0, IPC_RMID, arg); semid 와 관련되는 세마포어를 제거하게 됩니다. semctl 은 실패시에는 -1을 돌려주며, 성공했을 경우에는 cmd 에 따라 음수가 아닌 수를 돌려줍니다. ㄷ. semop int semop ( int semid, struct sembuf *sops, unsigned nsops); semop 는 세마포어를 실질적으로 동작시키는 역할을 합니다. semid 는 마찬가지로 semget 에서 돌려준 세마포어 식별자입니다. sembuf 는 다음과 같은 구조체인데 semop 에서 핵심입니다. /* semop system calls takes an array of these. */ struct sembuf { ushort sem_num; /* semaphore index in array */ short sem_op; /* semaphore operation */ short sem_flg; /* operation flags */ }; semop 시스템 호출은 sembuf 의 배열을 취하게 되며, 따라서 일반적으로 필요한 세마포어 배열의 크기만큼 설정하게 됩니다. 여기서는 하나의 세마포어만을 사용 하는 관계로 배열로 선언하지 않고 하나의 변수로 선언합니다. sem_num 은 배열에서 세마포어의 인덱스를 나타냅니다. (물론 0부터 시작합니다.) sem_op 는 해당 세마포어 변수에 더하게 될 값입니다. 보통 '-1' 로 많이 사용하게 됩니다. 세마포어의 값을 위에서 1로 초기화 하면, semop 함수는 수행하면서 이 값 에 sem_op ('-1')을 더하게 되어 결론적으로 0으로 만들게 되며, 다른 프로세스의 임계영역 진입을 막게 됩니다. sem_flg 는 semop의 수행을 제어합니다. sem_flg 에 올 수 있는 값은 IPC_NOWAIT 와 SEM_UNDO 가 가능합니다. IPC_NOWAIT 는 세마포어의 값이 0일 경우, 임계영역 에서 기다리지 않고 즉각 리턴합니다. SEM_UNDO 도 보통 많이 사용하는 데, 이것 은 시스템이 현재 프로세스의 세마포어에 대한 동작을 추적하여 프로세스가 비정상 적인 종료를 수행하였을 경우에 세마포어의 값이 비정상적으로 되는 것을 막기위해 지금까지 수행한 프로세스의 작업을 모두 취소시키는 역할을 합니다. 가령 프로세스가 세마포어의 값을 0으로 설정하고 난 후에 임계영역을 수행하던중, 어떠한 이유로 비정상적으로 중단되었을 경우에, 이 프로세스가 수행한 이전의 작 업을 원상복구하여 세마포어의 값을 1로 다시 설정되지 않으면, 다른 프로세스들이 영원히 임계영역에 들어오지 못하는 수가 생길 수 있습니다. 이럴 경우를 대비해서 SEM_UNDO 를 사용합니다. semop 함수에서 두번째 매개변수인 sops 는 값이 설정된 sembuf 에 대한 포인터입니 다. nsops 는 semop 가 작업할 세마포어 배열의 갯수입니다. 여기에서는 하나 뿐 이므로 1로 설정합니다. semop 함수는 보통 임계영역에서의 p 와 v 에서 세마포어의 값을 변경시키는 용도로 사용됩니다. 위에서 살펴본 임계영역에서의 의사 코드를 다시 살펴 봅시다. semaphore sv = 1; loop forever { p(sv); critical code section; v(sv); non-critical code section; } 여기에서 p 와 v 는 실제로 다음과 같이 구현됩니다. 물론, 세마포어 배열이 아닌 하나의 세마포어 일 경우입니다. int p(int semid) { struct sembuf p_buf; p_buf.sem_num = 0; /* 0번째 세마포어 */ p_buf.sem_op = -1; /* sv + (-1) */ p_buf.sem_flg = SEM_UNDO; if (semop(semid, &p_buf, 1) == -1) { perror("p(semid) failed\n"); return 0; } return 1; } int v(int semid) { struct sembuf v_buf; v_buf.sem_num = 0; /* 0번째 세마포어 */ v_buf.sem_op = 1; /* sv + 1 */ v_buf.sem_flg = SEM_UNDO; if (semop(semid, &v_buf, 1) == -1) { perror("v(semid) failed\n"); return 0; } return 1; } 이제, 세마포어 함수에 대한 내용은 모두 살펴보았습니다. 이 정도면 실제 사용시에 별 무리는 없을 것이라 보여지며 더 자세한 내용은 man 페이지를 참고하시기 바랍니 다. 이제 두개의 예제 소스를 만들어 보겠습니다. 첫번째 것은 세마포어를 간단히 테스트 하는 것이고, 두번째 것은 실제 응용 프로그램을 작성할 때의 세마포어 사용방법에 대해서 간단한 프로그램을 만들어 보면서 말씀드리겠습니다. 다. 실제 예제 소스 - 와~ 너무 쉽다~ :-) ---------------------------------------------------------------------------- /* 세마포어 테스트 예제 - sem1.c */ #include #include #include #include #include #include #define SEMKEY 0x100 /* * 세마포어를 생성하거나 식별자를 얻는다. * * 매개변수 : semkey - 생성하거나 식별자를 얻을 세마포어에 사용하는 키값 * 반환값 : 에러시 -1, 성공시 해당 세마포어의 식별자 * */ int initsem(int semkey) { int semid, status = 0; union semun sem_union; if((semid = semget(semkey, 1, 0666 | IPC_CREAT | IPC_EXCL)) == -1) { if(errno == EEXIST) { semid = semget(semkey, 1, 0); /* 이미 존재할 경우에 식별자만 얻는다. */ } } else { sem_union.val = 1; /* 세마포어를 생성한 프로세스만 그 값을 초기화 */ status = semctl(semid, 0, SETVAL, sem_union); } if (semid == -1 || status == -1) { perror("initsem"); return -1; } /* 식별자가 0이 될 수 있으므로 에러시 0을 반환하지 않도록 주의 */ return semid; } int p(int semid) { struct sembuf p_buf; p_buf.sem_num = 0; p_buf.sem_op = -1; p_buf.sem_flg = SEM_UNDO; if(semop(semid, &p_buf, 1) == -1) { perror("p(semid)"); return -1; } return 0; } int v(int semid) { struct sembuf v_buf; v_buf.sem_num = 0; v_buf.sem_op = 1; v_buf.sem_flg = SEM_UNDO; if(semop(semid, &v_buf, 1) == -1) { perror("v(semid)"); return -1; } return 0; } void handlesem(int semkey) { int semid, pid = getpid(); if((semid = initsem(semkey)) < 0) exit(1); printf("\nprocess %d before critical section\n", pid); p(semid); printf("process %d in critical section\n", pid); sleep(2); printf("process %d leaving critical section\n", pid); v(semid); printf("process %d exiting\n", pid); exit(0); } void main() { if(fork() == 0) handlesem(SEMKEY); if(fork() == 0) handlesem(SEMKEY); if(fork() == 0) handlesem(SEMKEY); } ---------------------------------------------------------------------------- 위의 소스에서 initsem 은 세마포어를 초기화 하고, p 와 v 함수는 세마포어 연산을 수행합니다. 이 세개의 함수는 서로 독립적으로 설계되어 있으므로 이후에는 그냥 프로세스 동기화가 필요한 부분에 가져다 쓰시면 되겠습니다. 위에서의 handlesem 과 같은 함수에서는 semkey 의 값을 가지고 initsem을 실행시켜 semid 를 얻고, 이 후에 p 와 v 함수를 수행하고 있습니다. 실제의 코드에서도 이와 비슷한 모양으로 사용이 될 것입니다. main 에서는 세개의 자식 프로세스를 생성하여 동일한 handlesem 함수를 동일한 세마포어 키를 사용하여 실행시키고 있습니다. 하지만, fork 로 생성된 자식 프로세스는 비록 이후의 동일한 코드를 수행하지만 각자의 데 이터 영역은 각자 가지므로 (부모 프로세스에서 복사해서 사용하므로) handlesem에 서 어떤 지역적인(!) 변수를 사용하여 프로세스의 실행횟수를 기록한다던지 하는 것 은 불가능함을 알아두시기 바랍니다. 이제, 컴파일을 해서 실행을 시켜봅시다. $ gcc -o sem1 sem1.c $ ./sem1 process 257 before critical section process 257 in critical section process 258 before critical section process 259 before critical section process 257 leaving critical section process 257 exiting process 258 in critical section process 258 leaving critical section process 258 exiting process 259 in critical section process 259 leaving critical section process 259 exiting $ 역시, 우리가 예상하던 데로 임계영역은 한번에 하나의 프로세스만이 수행을 하고 있 습니다. (잡담: 1년 쯤 전, 위와 유사한 코드를 가지고 테스트를 한적이 있었는 데, 이상하 게 제대로 원하는 결과가 나타나지 않아서 속을 태운 적이 있었습니다. 아무리 머 리를 굴려봐도 책의 예제와 꼭 같이 작성을 했는 데, 책대로 되지 않는 경우였습니 다. :( - 이럴 때는 정말 황당합니다. - 그래서 '책이 오래되어서 뭔가가 바뀌었나' 하는 의구심과 함께 'Linux 에 뭔가 문 제가 있을거야' 하면서 죄없는 Linux 시스템만 의심하면서 1년 동안 고통을 받아왔 습니다. - Linux 시스템에서 뭔가 바라는 바대로 제대로 안될 때 시스템을 의심 하는 것은 비단 저 뿐만은 아닌 것 같더군요. :) - 그러다가 얼마전에 'Beginning Linux Programming' 의 세마포어 예제를 실행시켜보 니 웬걸~ 제대로 되는 게 아니겠습니까? 이게 웬 조화일 까 싶어서 위의 소스를 찬찬이 뜯어보니..아뿔싸...!! 원인은 코딩에러에 있었지요. 그 황당함이란.. 정말 울고 싶더군요.. -.- initsem 에서 '}', '{' 를 잘못 사용하여 세마포어 값을 초기화 시키는 semctl 함 수가 실행이 되지 않은 거였습니다. 그때에는 한줄짜리 코드에는 블럭괄호를 생략 하던 습관이 있었는 데, 이게 화를 불렀지요. 이런 이유로 프로세스들이 임계영역 에 절대로 들어가지 않는 사태가 발생을 했더랬습니다. 1년동안 고생하면서 생각한 결론은 '예제소스를 어떠한 방식으로던 제공을 하지 않 는 책은 사지말자' 하는 거였습니다. 그때 예제 소스만 어떻게 구할 수 있었어도 이런 봉변은 당하지 않았을 겁니다. 아울러 혼자서 공부하시는 분들은 코딩상에 어떤 문제가 생겼을 때 도움을 요청할 수 있는 도우미(?)를 한분 꼬셔두십시요. 골치아픈 프로그래밍 관련 질문은 게시판에 올려도 잘 답변이 없습니다. -.- ) (계속..) 『리눅스 학당-리눅스 강좌 / 연재 (go LINUX)』 477번 제 목:[강좌3] 시스템 V IPC - 세마포어2 올린이:ddoch (한동훈 ) 97/07/06 00:34 읽음:1839 관련자료 없음 ----------------------------------------------------------------------------- 위의 예제에서 세마포어를 만들어 놓기만 하고 제거를 하지 않았습니다. 프로그램이 실행되고난 이후부터 시스템이 끝날 때 까지 실행되는 프로그램이거나, 또는 중간 중간에 여러번 실행되는 프로그램이면 모르겠으나, 그렇지 않은 경우에는 세마포어 를 제거해주는 것이 좋습니다. 즉, 더이상 사용할 필요가 없으면 시스템 자원을 절 약한다는 차원에서 없애주는 것이지요. 보통 프로그램 내에서 세마포어가 더이상 필요없다고 판단을 내릴 만한 어떤 조건이 참인가를 검사해서 없애는 방법이 제일 편하겠습니다만 그렇지 않고, 프로그램을 실행시킬 때 환경변수를 확인하거나 인자 를 주어서 처리하는 방법도 있습니다. 여기서는 먼저 IPC 가 제공하는 명령행에서 실행할 수 있는 명령어를 살펴보겠습니다. 위에서 남게 된 세마포어를 먼저 살펴볼까요? $ ipcs -s ------ Semaphore Arrays -------- semid owner perms nsems status 512 host 666 1 세마포어 식별자가 512 이고 접근권한이 '666' 인 세마포어가 하나 있군요. 이 녀석이 위의 코드에서의 임계영역에서 파수꾼이 되었던 놈입니다. $ ipcs ------ Shared Memory Segments -------- shmid owner perms bytes nattch status ------ Semaphore Arrays -------- semid owner perms nsems status 512 host 666 1 ------ Message Queues -------- msqid owner perms used-bytes messages 'ipcs' 는 현재 시스템에 있는 각각의 IPC 설비인 '세마포어', '공유메모리', '메시지 큐' 에 대한 전체 정보를 출력합니다. 세마포어만 보려면, '-s', 공유메모리는 '-m', 메시지 큐는 '-q' 를 사용합니다. IPC 의 명령행 프로그램은 해당 IPC 설비를 삭제할 수 있습니다. 좀 불쌍하긴 하지 만 위의 세마포어를 없애볼까요? $ ipcrm sem 512 resource deleted IPC 설비를 삭제하는 명령은 'ipcrm' 이고, 세마포어는 'sem', 공유메모리는 'shm', 메시지 큐는 'msg' 를 각각 사용합니다. 당연히 마지막에 해당 식별자를 명시해야 합니다. 자세한 내용은 'ipcs -h' 나 'ipcrm -h' 를 사용하거나 'man ipcs', 'man ipcrm' 하셔서 참고하시기 바랍니다. %%% 도대체 나의 프로그램에서 임계영역은 어디인가? %%% 여러분의 프로그램이 다중 프로세스, 다중 유저 환경에서 돌아가도록 만들어져 있다 면 (Linux & Unix 에서는 기본 환경이죠..) 여러곳이 임계영역이 될 수 있습니다. 여러 프로세스가 하나의 파일에 쓰기위해 접근할 때, 파일을 여는 곳부터 파일을 닫 는 곳까지가 임계영역이 될 수 있습니다. 또는 해당 시스템에서 한정된 자원에 그 이상의 프로세스가 사용을 원할 때 임계영역이 있을 수 있습니다. 실제에 있어서 임계영역의 판별기준은 자신의 프로그램에서 여러 프로세스가 동시에 실행되어서는 문제가 생길 수 있는 부위가 될 것입니다. 동시에 여러 프로세스가 읽기만을 수행 하는 것은 별 문제가 되지 않습니다. 이제 실제적으로 응용 프로그램을 작성할 경우에 어떻게 사용하는지를 살펴볼까요? 다양한 분야에서 세마포어를 사용할 수 있겠지만, 여기서는 간단하게 어떤 프로그램 의 일부분으로 들어갈 수 있는, 해당 프로세스의 로긴 일지를 기록하는 루틴을 세 마포어를 사용하여 만들어 보겠습니다. 먼저, 위의 initsem, p, v 루틴을 재사용가능하도록 다른 파일에 담습니다. 이후에 편하게 사용할 수 있도록 만들어 볼까요? 여기에 세마포어를 제거하는 delsem 함수 를 추가합니다. 이 파일은 ipc_sem.c 라고 하겠습니다. ---------------------------------------------------------------------------- /* ipc_sem.c : 재사용가능한 세마포어 루틴 */ #include #include #include #include #include #include int initsem(int semkey); int delsem(int semid); int p(int semid); int v(int semid); int initsem(int semkey) { int semid, status = 0; union semun sem_union; if((semid = semget(semkey, 1, 0666 | IPC_CREAT | IPC_EXCL)) == -1) { if(errno == EEXIST) { semid = semget(semkey, 1, 0); } } else { sem_union.val = 1; status = semctl(semid, 0, SETVAL, sem_union); } if (semid == -1 || status == -1) { perror("initsem"); return -1; } return semid; } int delsem(int semid) { union semun sem_union; if (semctl(semid, 0, IPC_RMID, sem_union) == -1) { perror("semaphore delete"); return -1; } return 0; } int p(int semid) { struct sembuf p_buf; p_buf.sem_num = 0; p_buf.sem_op = -1; p_buf.sem_flg = SEM_UNDO; if(semop(semid, &p_buf, 1) == -1) { perror("p(semid)"); return -1; } return 0; } int v(int semid) { struct sembuf v_buf; v_buf.sem_num = 0; v_buf.sem_op = 1; v_buf.sem_flg = SEM_UNDO; if(semop(semid, &v_buf, 1) == -1) { perror("v(semid)"); return -1; } return 0; } ---------------------------------------------------------------------------- 이제 만드는 프로그램은 간단하게 위의 인터페이스를 사용하여 현재 프로세스의 실행 시작시간과 종료시간을 기록하는 record.c 입니다. ---------------------------------------------------------------------------- /* record.c : 현재 프로세스의 실행시간 측정 */ #include #include #include #include "ipc_sem.h" #define SEMKEY 0x100 #define RECORD_FILE "record.file" struct reg_list { pid_t pid; /* 프로세스 번호 */ time_t start; /* 프로세스 실행 시작 시간 */ time_t end; /* 프로세스 실행 종료 시간 */ }; struct reg_list reg; void reg_start(); void reg_end(int); void reg_start() { reg.pid = getpid(); /* 프로세스 번호 */ reg.start = time(NULL); /* 현재 시간 */ reg.end = (time_t)0; } void reg_end(int sem_delete_flag) { int semid; FILE *fp; if ((semid = initsem(SEMKEY)) < 0) exit(1); reg.end = time(NULL); p(semid); /* 임계영역의 입구 */ if ((fp = fopen(RECORD_FILE, "a+")) == NULL) { perror(RECORD_FILE); return; /* 쓰기 실패 , SEM_UNDO 로 인해 세마포어값은 원래대로 돌아감 */ } fwrite(®, sizeof(struct reg_list), 1, fp); fclose(fp); v(semid); /* 임계영역의 출구 */ if (sem_delete_flag) { /* 세마포어 삭제 플래그가 설정되었다면 제거 */ delsem(semid); } } void main(int argc, char *argv[]) { reg_start(); sleep(2); /* 실제에 있어서의 어떤 작업 */ if (argc > 1) { /* 세마포어를 조건적으로 제거 */ reg_end(1); } else { reg_end(0); } #ifdef DEBUG /* 디버깅 코드 */ { char tbuf1[20], tbuf2[20]; FILE *fp; if ((fp = fopen(RECORD_FILE, "r")) == NULL) { perror(RECORD_FILE); exit(1); } while (fread(®, sizeof(struct reg_list), 1, fp) == 1) { strftime(tbuf1, 20, "%m/%d %I:%M:%S", localtime(&(reg.start))); strftime(tbuf2, 20, "%m/%d %I:%M:%S", localtime(&(reg.end))); printf("프로세스 : %5d , 시작시간 : %s , 종료시간 : %s\n", reg.pid, tbuf1, tbuf2); } printf("\n"); } #endif } ---------------------------------------------------------------------------- 여기에서, '#ifdef DEBUG' 는 reg_end 함수가 기록한 레코드 파일의 내용을 알아 보기 위한 코드입니다. main 에서는 간단히 reg_start 를 수행하여 시작 시간을 reg.start 에 기록하고, reg_end 를 호출하여 종료시간을 기록합니다. 세마포어를 제거하는 방법을 제공 하기 위하여 main 에서 매개변수가 2개 이상이면 reg_end 로 하여금 세마포어를 삭제하도록 지시했습니다. 이제 컴파일하여 실행을 해볼까요? 컴파일할 때 '-DDEBUG' 옵션을 사용하여 봅시다. ---------------------------------------------------------------------------- $ gcc -o record record.c ipc_sem.c -DDEBUG $ ./record 프로세스 : 668 , 시작시간 : 07/04 06:50:20 , 종료시간 : 07/04 06:50:22 $ ipcs -s ------ Semaphore Arrays -------- semid owner perms nsems status 384 host 666 1 $ record 1 프로세스 : 668 , 시작시간 : 07/04 06:50:20 , 종료시간 : 07/04 06:50:22 프로세스 : 670 , 시작시간 : 07/04 06:50:51 , 종료시간 : 07/04 06:50:53 $ ipcs -s ------ Semaphore Arrays -------- semid owner perms nsems status $ ---------------------------------------------------------------------------- 여기서는 간단히 실행만 시켜보았지만, 세마포어의 진가는 여러 프로세스가 예측 할 수 없는 시간에 실행될 때 그 효과가 있다는 사실을 알아두시기 바랍니다. 이번 장에서는 세마포어에 대한 여러 함수들을 살펴보면서, 예제를 두개 만들어 보 았습니다. 이제, 다음 장에서는 IPC 설비에서 빼놓을 수 없는 공유 메모리에 대해서 자세히 알아보겠습니다. (계속) 『리눅스 학당-리눅스 강좌 / 연재 (go LINUX)』 478번 제 목:[강좌4] 시스템 V IPC - 공유메모리 올린이:ddoch (한동훈 ) 97/07/06 00:35 읽음:1978 관련자료 없음 ----------------------------------------------------------------------------- 4. 공유메모리 보통, 프로세스는 자신만의 독자적인 메모리 세그먼트를 가지게 됩니다. fork 로 생성된 자식 프로세스의 경우에도 대부분의 부모의 정보를 복사하게 되며 자신만의 메모리 주소공간을 확보합니다. 물론 쓰레드(경량 프로세스)같은 경우에는 각 쓰 레드별 주소공간을 공유할 수도 있습니다. 아울러 프로세스에서도 공유 라이브러리 나 프로그램 코드는 공유될 수도 있습니다. 물론 이러한 경우에도 데이터 영역은 각자 보유하게 되며, 코드영역은 읽기만 가능할 것입니다. 따라서 일반적인 프로세 스의 개념에서 '원하기만 하면 모든 프로세스들이 메모리상의 일정 주소공간을 공유 하여 읽기 쓰기를 할 수 있다.'는 '공유메모리 세그먼트'의 개념은 혁신적인 것임에 틀림없습니다. 경우에 따라 응용 프로그램에서 아주 유용하게 사용될 수 있습니다. 일반적으로, 온라인 통신망의 '대화방' 시스템에서 공유메모리를 활용하는 경우가 많 으며, '폰트공유' 시스템의 구성도 가능합니다. Uterm 이라는 '유니코드 터미널' (동호회 자료실에 있음) 프로그램은 유니코드에 필요한 폰트를 시작할 때 공유메모리 에 로딩을 해서 사용을 하더군요. 이렇게 하면 각자의 응용 프로그램마다 폰트를 다 시 불러들이거나 메모리에 축적할 필요가 없다는 장점이 있습니다. 또다른 아이템 을 생각해 본다면, '시스템 전역의 메모장' 같은 아기자기한 것도 나올 수 있겠군 요. 물론 그 필요성은 프로세스간의 데용량 데이터 교환시에나, 시스템에서의 수 많은 프로세스들이 일정한 메모리를 공유하는 것이 필요하다거나, 이렇게 하는 것이 효율적일 경우에 사용할 수 있겠지요. 그럼, 공유메모리를 어떻게 사용하는지 알아볼까요? 보통, 공유메모리에 대한 처리는 다음의 순서로 하게 됩니다. * 공유메모리를 확보한다. * 공유메모리의 주소를 프로세스의 자신의 자료영역으로 덧붙인다. (접속) 그리고 작업을 한다. * 공유메모리의 주소를 프로세스와 분리를 시킨다. (접속끊기) * 공유메모리를 제거한다. 이제 차례대로 하나씩 살펴보죠. 가. 공유메모리 확보하기 공유메모리를 확보하는 함수는.. int shmget(key_t key, int size, int shmflg); key_t 자료형은 리눅스에서는 int와 같습니다. key는 공유메모리를 확보하기 위한 '키값' 입니다. 사용자의 임의대로 지정해 줄 수 있습니다. key가 같으면 반환되는 값도 같습니다. size는 공유메모리에 확보할 byte 수입니다. shmflg는 공유메모리를 확보하는 방법이겠지요. 여기에 일반적으로 들어가는 값은, IPC_CREAT : 공유메모리를 만든다. IPC_EXCL : IPC_CREAT와 같이 사용된다. 이미 지정한 키값의 공유메모리가 존재 할 경우에는 실패한다. mode_flags: 파일퍼미션과 같은 형태의 공유메모리 접근권한을 지정한다. 이 값들을 'or'연산을 하여 사용할 수 있습니다. 아래와 같이 사용할 수 있겠네요. int shmid; shmid = shmget(0x10, 20, IPC_CREAT|IPC_EXCL|0600); 키값 0x10으로 공유메모리 영역을 20bytes만큼 만드는 것입니다. 접근권한은 '0600'이 되지요. 여기서의 반환값인 shmid는 이후의 공유메모리 처리 함수들에 쓰이는 파일 기술자 와 비슷한 아이디입니다. 나. 공유메모리에 접속하기 이제 프로세스 자신의 논리적 자료영역으로 공유메모리를 접속하는 방법을 알아 보지요. chat *shmat(int shmid, chat *shmaddr, int shmflg); shmid는 앞에서 반환된 시스템에서 공유메모리를 구별하는 아이디입니다. shmaddr의 값을 통해서 공유메모리가 접속되는 영역을 지정할 수 있습니다. 이 값이 NULL ((char *)0) 이면 시스템이 알아서 접속을 시켜주지요. 만일, 공유메모리가 접속될 주소를 직접 지정하게 되면 시스템과 하드웨어에 의존적 이 되어서 포팅시에 문제가 많이 발생합니다. 특별한 경우가 아니면 주소값을 지정하지 않는 것이 좋습니다. shmflg의 값 중 주로 쓰이는 것은 다음과 같습니다. SHM_RDONLY : 접속되는 영역에 읽기만 허용된다. SHM_RND : shmaddr의 값이 (char *)0이 아닌 경우에 shmaddr주소 주위로 접속을 한다. 이 함수의 반환값은 공유메모리에 대한 주소입니다. 다음과 같이 사용할 수 있겠습니다. char *memptr; memptr= shmat(shmid, (char *)0, 0); shmid로 공유메모리가 접속되는 구역을 시스템에 맡겨버리는 것입니다. (참고로 뒤에 설명이 되는 것이지만 shmat을 호출하여 성공하면 구조체 shmid_ds 의 몇가지가 변경됩니다. shm_atime : 현재 시간으로 놓여집니다. shm_lpid : 호출한 프로세스의 pid로 놓여집니다. shm_nattch: 접근 프로세스의 갯수가 하나 증가합니다. ) 다. 공유메모리와 접속 끊기 이제 공유메모리에서 작업을 하고 나서 접속을 끊는 방법을 알아봅시다. int shmdt(char *shmaddr); shmaddr은 공유메모리가 접속한 주소로, 앞서의 shmat에서 반환된 memptr 값입니다. 이제 프로세스의 논리적 자료영역이 공유메모리와 분리가 되었습니다. 이때에 다시 공유메모리를 사용하기를 시도하면 segmentation fault 가 발생합니다. (마찬가지로 구조체 shmid_ds의 멤버 몇가지가 변경이 됩니다. shm_dtime : 현재 시간으로 놓여집니다. shm_lpid : 호출한 프로세스의 pid로 놓여집니다. shm_nattch: 하나가 감소합니다. ) 라. 공유메모리 제거하기 및 shmctl함수 익히기 shmctl함수를 통해서 여러가지를 할 수 있습니다. * 공유메모리 세그먼트에 대한 정보얻기 * 공유메모리 세그먼트의 소유자, 그룹, 접근권한 설정하기 * 공유메모리 제거하기 shmctl함수의 원형은 다음과 같습니다. int shmctl(int shmid, int cmd, struct shmid_ds *buf); 위의 여러가지 기능들은 shmid에 대해 적용되며 struct shmid_ds를 통해 이루어 집니다. struct shmid_ds는 하나의 공유메모리 세그먼트에 대한 정보를 담은 'linux/ shm.h'에 정의된 구조체입니다. struct shmid_ds { struct ipc_perm shm_perm; /* 퍼미션 */ int shm_segsz; /* 세그먼트의 크기 (bytes) */ time_t shm_atime; /* 마지막 접근한 시간 */ time_t shm_dtime; /* 마지막 제거된 시간 */ time_t shm_ctime; /* 마지막 변경된 시간 */ unsigned short shm_cpid; /* 만든 프로세스 아이디 */ unsigned short shm_lpid; /* 마지막 작동한 프로세스 아이디 */ short shm_nattch; /* 현재 접근한 프로세스 수 */ unsigned short shm_npages;/* 세그먼트의 크기 (페이지) */ unsigned long *shm_pages; struct shm_desc *attaches;/* 접근을 위한 기술자 */ }; ipc_perm의 구조는 다음과 같습니다. struct ipc_perm { key_t key; /* 키값 */ ushort uid; /* 소유자의 유효사용자 아이디 */ ushort gid; /* 소유자의 유효그룹 아이디 */ ushort cuid; /* 만든이의 유효사용자 아이디 */ ushort cgid; /* 만든이의 유효그룹 아이디 */ ushort mode; /* 접근 권한 */ ushort seq; /* sequence number */ }; shmctl 함수의 두번째 인자인 'cmd'는 다음의 값들이 가능합니다. IPC_STAT : 공유메모리 세그먼트에 대한 정보를 읽어서 buf(3번째 인자)에 저장합니다. IPC_SET : 현재의 사용자가 가진 uid, gid, 그리고 shm_perms의 필드의 mode를 변경하는 데 사용됩니다. 이값들은 당연히 shmid_ds를 통해서 주어져야 하겠지요. mode를 사용할 때는 하위 9비트만이 사용됩니다. 이 기능을 호출하면 shm_ctime의 내용이 변경됩니다. 그리고 이것을 호출할려면 소유자, 만든이, 또는 슈퍼유저여야 합 니다. IPC_RMID : 해당하는 공유메모리 세그먼트를 제거하는 데 사용됩니다. 당연히 소유자, 만든이, 슈퍼유저만이 가능합니다. shmid_ds 구조체의 멤버인 shm_nattch(접근하고 있는 프로세스의 수)를 0으로 만듭니다. 이 외에도 몇가지가 더 있는 데, 자주 쓰이는 것이 아닌 까닭에 생략하겠습니다. 여기까지는 몇가지 공유메모리를 다루는 함수들과 이에 관련된 구조체를 알아보았 습니다. 이제 이것을 이용해서 간단한 소스를 통해 손에 익히는 시간을 마련하겠 습니다. 마. 예제를 통해서 익히기 먼저, 몇개의 공유메모리 함수를 사용하여 간단하게 공유메모리 세그먼트를 생성해 서 없애는 것을 짜볼까요? ----------------------------------------------------------------------------- /* shmtest.c : 공유메모리 예제 첫번째 - 세그먼트를 생성하고 없애기 */ #include #include #include #include #include #define KEY 0x10 /* 접근 키값*/ #define PERM 0660 /* 퍼미션 */ #define SIZE 20 /* 공유메모리의 크기바이트 */ void main() { int shmid; /* 공유메모리 id */ char *memptr; /* 공유메모리의 주소 */ /* 공유메모리 만들기 */ if((shmid= shmget(KEY, SIZE, PERM|IPC_CREAT|IPC_EXCL)) < 0) { perror("shmget"); exit(1); } /* 공유메모리에의 현재 실행프로세스의 접속, memptr에는 그 주소 반환 */ if((memptr= shmat(shmid, (char *)0, 0)) == (char *)(-1)) { perror("shmat"); exit(1); } /* 공유메모리의 주소에 문자열 테스트 */ strcpy(memptr, "Linux is Best!"); printf("shmkey = %d, shmid = %d\n", KEY, shmid); printf("memptr = %p : %s\n", memptr, memptr); sleep(1); printf("\nAfter shmget...\n"); system("ipcs -m"); /* 공유메모리 상태보기 */ if(shmdt(memptr) < 0) { /* 프로세스와의 접속 끊기 */ perror("shmdt"); exit(1); } /* 공유메모리 제거 */ if(shmctl(shmid, IPC_RMID, (struct shmid_ds *)0) < 0) { perror("shmctl"); exit(1); } printf("\nAfter remove...\n"); system("ipcs -m"); } ----------------------------------------------------------------------------- 컴파일을 해서 실행을 시켜볼까요? $ gcc -o shmtest shmtest.c $ shmtest shmkey = 16, shmid = 640 memptr = 0x40000000 : Linux is Best! After shmget... ------ Shared Memory Segments -------- shmid owner perms bytes nattch status 640 root 660 20 1 After remove... ------ Shared Memory Segments -------- shmid owner perms bytes nattch status 프로그램 자체내에서 공유메모리의 상태를 알기 위해서 system함수를 사용하 였습니다. 간단해서 쉽게 이해할 수 있을 것 같습니다. 그럼, 이제 shmctl함수를 사용해서 공유메모리에 대한 정보를 가져와봅시다. --------------------------------------------------------------------------- /* shminfo.c : 공유메모리 두번째 예제 - 세그먼트에 대한 정보얻기 */ #include #include #include #include #include #define SNULL ((struct shmid_ds *)0) #define ERR ((char *)-1) void main() { int shmid; char *memptr; struct shmid_ds SHM; if((shmid= shmget(0x10, 20, 0600|IPC_CREAT|IPC_EXCL)) < 0) { perror("shmget"); exit(1); } if((memptr= shmat(shmid, NULL, 0)) == ERR) { perror("shmat"); exit(1); } if(shmctl(shmid, IPC_STAT, &SHM) < 0) { /* SHM에 정보얻기 */ perror("shmctl"); exit(1); } printf("===============================\n"); printf(" Shared Memory Information \n"); printf("===============================\n\n"); printf("Key Value : %d\n", SHM.shm_perm.key); printf("Owner Euid : %d\n", SHM.shm_perm.uid); printf("Owner Egid : %d\n", SHM.shm_perm.gid); printf("Creator Euid : %d\n", SHM.shm_perm.cuid); printf("Creator Egid : %d\n", SHM.shm_perm.cgid); printf("Access Mode : %o\n", SHM.shm_perm.mode); printf("Size of Segment (bytes) : %d\n", SHM.shm_segsz); printf("Last Attach Time : %s\n", ctime(&SHM.shm_atime)); printf("Last Detach Time : %s\n", ctime(&SHM.shm_dtime)); printf("Last Change Time : %s\n", ctime(&SHM.shm_ctime)); printf("Pid of Creator : %d\n", SHM.shm_cpid); printf("Pid of Last Operator : %d\n", SHM.shm_lpid); printf("No. of Current Attaches : %d\n", SHM.shm_nattch); printf("Size of Segment (pages) : %d\n", SHM.shm_npages); if(shmdt(memptr) < 0) { /* 공유메모리와의 단절 */ perror("shmdt"); exit(1); } if(shmctl(shmid, IPC_RMID, SNULL) < 0) { /* 공유메모리 제거 */ perror("shmctl"); exit(1); } exit(0); } --------------------------------------------------------------------------- 컴파일 해서 실행을 시켜볼까요? $ gcc -o shminfo shminfo.c $ shminfo =============================== Shared Memory Information =============================== Key Value : 16 Owner Euid : 501 Owner Egid : 100 Creator Euid : 501 Creator Egid : 100 Access Mode : 600 Size of Segment (bytes) : 20 Last Attach Time : Sat Jul 20 20:40:35 1996 Last Detach Time : Thu Jan 1 00:00:00 1970 Last Change Time : Sat Jul 20 20:40:35 1996 Pid of Creator : 572 Pid of Last Operator : 572 No. of Current Attaches : 1 Size of Segment (pages) : 0 따로 설명은 필요없을 것 같습니다. 이번에는 shmctl함수에서 IPC_SET을 사용해 서 접근 권한을 변경해 봅시다. --------------------------------------------------------------------------- /* shmcmode.c : 공유메모리 세번째 예제 - 접근 권한 바꾸기 */ #include #include #include #include #define SNULL ((struct shmid_ds *)0) #define ERR ((char *)-1) void main() { int shmid; char *memptr; struct shmid_ds SHM; if((shmid= shmget(0x10, 20, 0600|IPC_CREAT|IPC_EXCL)) < 0) { perror("shmget"); exit(1); } if((memptr= shmat(shmid, NULL, 0)) == ERR) { perror("shmat"); exit(1); } if(shmctl(shmid, IPC_STAT, &SHM) < 0) { perror("shmctl"); exit(1); } printf("Before IPC_SET\n"); printf("Access Mode : %o\n", SHM.shm_perm.mode); SHM.shm_perm.mode = 0666; /* 접근권한 바꾸기 */ if(shmctl(shmid, IPC_SET, &SHM) < 0) { perror("shmctl"); exit(1); } if(shmctl(shmid, IPC_STAT, &SHM) < 0) { /* 정보 다시 얻기 */ perror("shmctl"); exit(1); } printf("After IPC_SET\n"); printf("Access Mode : %o\n", SHM.shm_perm.mode); /* 바뀐 접근 권한 출력*/ if(shmdt(memptr) < 0) { perror("shmdt"); exit(1); } if(shmctl(shmid, IPC_RMID, SNULL) < 0) { perror("shmctl"); exit(1); } exit(0); } --------------------------------------------------------------------------- 실행을 시켜볼까요? $ gcc -o shmcmode shmcmode.c $ shmcmode Before IPC_SET Access Mode : 600 After IPC_SET Access Mode : 666 이번에는 만들어진 공유메모리에 프로세스가 접속을 하지 않고 접근한다면 어떤 결과가 나타나는 지 실험을 해보도록 하지요. 아마 예상들은 하고 계시겠지만. --------------------------------------------------------------------------- /* shmacces.c : 공유메모리 네번째 예제 - 공유메모리와의 접속 끊어짐 후의 접근 */ #include #include #include #include #include #define SNULL ((struct shmid_ds *)0) #define ERR ((char *)-1) void main() { int shmid; char *memptr; if((shmid= shmget(0x10, 20, 0600|IPC_CREAT|IPC_EXCL)) < 0) { if((shmid= shmget(0x10, 20, 0)) < 0) { perror("shmget"); exit(1); } } if((memptr= shmat(shmid, NULL, 0)) == ERR) { perror("shmat"); exit(1); } strcpy(memptr, "Linux is Best!"); printf("%p : %s\n", memptr, memptr); if(shmdt(memptr) < 0) { perror("shmdt"); exit(1); } printf("%p : %s\n", memptr, memptr); if(shmctl(shmid, IPC_RMID, SNULL) < 0) { perror("shmctl"); exit(1); } exit(0); } --------------------------------------------------------------------------- $ gcc -o shmaccess shmaccess.c $ shmaccess 0x40000000 : Linux is Best! Segmentation fault 예상했던 결과가 나왔지요. 공유메모리에 접속을 하였을 때는 정상적인 작동을 하나 접속을 끊고 나서는 함부로 자신의 영역이 아닌 메모리를 참조할 수 없음 으로 그 유명한 'Segmentation fault' 에러가 나왔습니다. 첫부분에서 키값에 의한 공유메모리 만들기를 시도하고 이미 만들어져 있으면 shmid값만 얻어내는 루틴이 한 줄 더 들어가 있다는 것 빼고는 특별히 달라진 것이 없습니다. 『리눅스 학당-리눅스 강좌 / 연재 (go LINUX)』 480번 제 목:[강좌5] 시스템 V IPC - 메시지 큐 올린이:ddoch (한동훈 ) 97/07/11 23:49 읽음:1805 관련자료 없음 ----------------------------------------------------------------------------- 바. 공유메모리의 활용영역 위에서도 잠깐 말씀드렸지만, 생각하기에 따라서 여러군데 응용할 수 있습니다. 여기서는 간단하게 온라인 시스템의 '대화방'의 경우를 고려해 보지요. 대화방 시스템은 보통 다양한 여러종류의 설비를 사용하여 구축할 수 있습니다. 당연히 시스템의 여러 프로세스들이 통신할 수 있는 방법을 사용하는 데, 많이 사용 하는 방법은 1) 공유메모리 세그먼트, 2) 사용자디바이스에 직접쓰기, 3) 메시지 큐, 4) 소켓 등이 있을 것입니다. 물론 이들중 하나이상을 결합하여 사용하는 경우도 많으며, 코드의 임계영역을 보호하기 위해서 앞에서 언급한 세마포어를 사용하기도 합니다. 이 중 한가지만을 사용하는 경우보다 2-3 가지를 함께 사용하여, 각 설비 의 장점을 고루 사용하는 것이 좋습니다. 대화방 시스템에는 대화방 제목, 참여인원, 참여 프로세스 PID 등의 많은 정보가 필 요하며, 제일 중요하고 핵심적인 부분은 한명의 사용자가 입력하는 글을 다른 프로세스에게 전달하여 해당 사용자의 화면으로 뿌리는 것입니다. 대화방에서 해당 프로세스들이 다 같이 참조해야할 기본적인 정보인 대화방제목, 참여자 등은 공유메모리를 사용하는 것이 여러모로 효율적이겠지만, 간편성을 위해 특정한 파일에 데이터를 저장해서 사용하기도 합니다. 이 경우에는, 각각의 참여 프로세스가 해당 정보를 변경하여야 할 필요가 있는 데, 이때 이 필요성을 위해 공유메모리에 접근할 수 있습니다. 동시에 여러 프로세스가 해당 메모리에 쓰거나 읽을 수가 있기 때문에 임계영역의 보호라는 문제가 등장하며, 세마포어를 사용하여 해결할 수 있습니다. 더 큰 문제는 사용자의 입력을 다른 사용자에게 전달하는 부 분입니다. 메시지 전달에 공유메모리를 사용하면, 해결하기 힘든 기본적인 문제점이 발생할 수 있습니다. 이제 대화방에서 채팅을 하는 모습을 머리속에 그리면서 생각 해 볼까요? 메시지 전달에 공유메모리를 사용할 경우, 다음과 같은 흐름을 생각할 수 있습니다. * 하나의 프로세스가 해당 사용자에게서 문자열을 입력받는다. * 메시지를 받을 다른 프로세스의 갯수(수신자 카운터)를 얻어서, 그 숫자와 함께 메시지를 공유메모리 세그먼트에 전송한다. * 다른 프로세스들은 공유메모리에 수신자 카운터를 읽어서 0이 아닐경우 공유메모 리 세그먼트에서 문자열을 읽어들이고, 수신자 카운터를 1 감소시킨다. * 마지막으로 문자열을 읽는 프로세스는 문자열을 읽어와서 수신자 카운터를 0으로 설정한다. * 수신자 카운터가 0이라면 다음 문자열이 도착할 때까지 대기한다. 여기에서도 물론, 공유메모리 세그먼트를 동시에 읽고 쓸수도 있기 때문에, 코드의 임계영역을 보호해야 하는 문제가 발생할 수 있습니다. 공유메모리 설비 자체는 임계영역을 보호할 수 있는 어떤 방법을 제공하지 않기 때문입니다. 위의 흐름에서 해결하기가 좀 힘든 부분이 있습니다. 해당 프로세스가 공유메모리 세그먼트에 문 자열이 도착하는 시간을 어떻게 아느냐 하는 것입니다. 세그먼트에서 하나의 변수 로 존재할 수신자 카운터가 0이라는 것을 계속 확인하기 위해 쉬지도 않고 while 문으로 검사를 할 경우, 시스템 전체의 CPU 자원을 엄청나게 잡아먹기 때문에 이렇 게 해서는 안됩니다. 문자열이 도착했을 때 SIGNAL 을 보내는 것도 마땅한 방법이 아닙니다. 그렇다고 어떤 인터럽트 핸들러를 설치하기에도 곤란한 문제이며, 메시 지 큐를 사용할 경우 인터페이스가 쓸데없이 복잡해지는 문제가 있습니다. 여기에서 생각해볼 만한 문제는 대화방 시스템의 전체정보는 공유메모리를 사용하여 유지하고, 메시지 전달에는 메시지 큐를 사용하는 방법입니다. 대화방에서 한번 입력하는 문자열은 그리 크지 않기 때문에 메시지 큐를 사용하는 것이 효율적일 수 있다는 이야기입니다. 사용자의 입력을 받아들인 사용자 프로세스는, 현재 대화에 참여하고 있는 프로세스의 PID 를 얻어서, 이들에게 각각 하나의 메시지를 메시지 큐로 전달하는 것입니다. 메시지를 전달받는 다른 프로세스들은 메시지가 없을 경 우 시스템에 의해 블럭될 것이기 때문에 시스템의 자원을 많이 소모하지는 않을 것 입니다. 아울러 자신에게 온 메시지만 받아서 사용자의 터미널에 출력하면 되겠지 요. 이후에 설명하겠지만, 메시지 큐에서 하나의 메시지는 프로세스가 읽고나면 없 어진다는 특징이 있습니다. 이후에 간단한 대화방 시스템을 직접 설계해볼 지도 모르겠지만, 먼저 이에 사용할 메시지 큐를 알고 넘어가도록 하지요. 5. 메시지 큐 이제 IPC 설비의 마지막인 메시지 큐에 대해서 알아봅시다. 가. 미리보기 메시지 큐는 fifo와 비슷하긴 하나, 파이프를 열고 닫는 것 같은 복잡한 것 은 없습니다. 메시지 큐를 사용한다 하더라도, fifo에서 처럼 파이프가 가득 차 서 블럭되는 것과 문제점에서 벗어날 수는 없습니다. 메시지 큐를 사용하면 하나의 프로세스가 다른 프로세스에게 데이터를 보낼 수 있으 며, 해당 데이터에는 수신자 프로세스가 식별하여 받을 수 있도록 어떤 특정한 형 의 정보를 함께 보내야 합니다. 메시지 큐의 장점은 fifo에서 나타날 수 있는, 동기화 문제와 블럭킹 문제를 해결할 수 있습니다. 단점은 하나의 데이터 블럭의 최대크기의 제한과, 시스템 상의 모든 큐에 있는 블럭의 전체 최대 크기에 제한이 있다는 점입니다. 이러한 제한값으로 Linux 에서는 MSGMAX(4096)과 MSGMNB(16384)의 두 값이 정의되어 있습니다. MSGMAX 는 메시지 하나의 최대크기(바이트)이고 MSGMNB 는 하나의 큐의 최대크기입니다. 이 값들은 시스템에 따라 다를 수 있고, 어떠한 이유로 정의되어 있지 않을 수도 있습니다. 나. 메시지 큐 함수 메시지 큐의 함수들은 다음과 같습니다. #include int msgctl(int msqid, int cmd, struct msqid_ds *buf); int msgget(key_t key, int msgflg); int msgrcv(int msqid, void *msg_ptr, size_t msg_sz, long int msgtype, int msgflg); int msgsnd(int msqid, const void *msg_ptr, size_t msg_sz, int msgflg); ㄱ. msgget msgget 함수를 사용하면 메시지 큐를 생성하고 접근할 수 있습니다. int msgget(key_t key, int msgflg); 'key' 는 다른 IPC 설비와 마찬가지로 특정한 메시지 큐를 지칭하는 값입니다. 특수한 'key' 값으로 IPC_PRIVATE 가 있는 데, 이것은 프로세스의 개인적인 큐를 생성하고, 현재의 프로세스만이 접근할 수 있도록 합니다. msgflg 의 하위 9비트는 9개의 권한 플래그입니다. IPC_CREAT 와 다른 권한 플래그를 OR 연산으로 사용하여 새로운 메시지 큐를 생성할 수 있습닙니다. msgget 에서 IPC_CREAT 플래그를 설 정하고 이미 존재하는 메시지 큐의 키값을 넘겨주는 것은 에러는 아닙니다. 메시지 큐가 이미 존재할 경우에 IPC_CREAT 플래그를 사용하면 그냥 무시됩니다. msgget 함수가 성공적으로 수행되면 큐 식별자로 음수가 아닌 값을 넘겨주고 에러 가 발생할 경우에는 -1을 돌려줍니다. ㄴ. msgsnd msgsnd 함수는 그 이름에서도 알 수 있듯이 메시지 큐로 메시지를 전송하는 역할을 합닙니다. int msgsnd(int msqid, const void *msg_ptr, size_t msg_sz, int msgflg); 메시지를 전송하는 데 사용되는 구조체는 다음 두가지 사항을 준수하여야 합니다. 먼저, 메시지 구조체는 시스템의 제한보다는 적어야 합니다. 두번째는 long int 형의 데이터를 구조체의 첫 멤버로 해야 한다는 점입니다. 이것은 메시지를 받는 함 수에서 사용되는 메시지 형입니다. 메시지 구조체는 다음과 같은 형태로 정의할 수 있습니다. struct my_message { long int message_type; /* The data you wish to transfer */ } 'message_type' 은 메시지를 주고받을 때 사용되기 때문에, 없어서는 안되겠죠? 당연히 구조체에는 이것을 포함해야 할 뿐만 아니라, 적당한 값으로 초기화 하여야 합니다. 첫번째 매개변수인 msqid 는 msgget 이 반환한 메시지 큐 식별자입니다. 두번째 매개변수인 msg_ptr 은 보낼 메시지를 가리키는 포인터 입니다. 세번째 매개변수인 msg_sz 은 msg_ptr 이 가르키는 메시지의 크기입니다. 여기에서 'long int' 형의 크기는 포함되지 않습니다. 네번째 매개변수인 msgflg 는 메시지 큐가 가득 찼다던지, 메시지 큐의 시스템 제한 을 초과한다 든지 할 때에 발생하는 일을 제어합니다. 만일, 메시지 큐가 가득 차 고 msgflg 에 IPC_NOWAIT 플래그가 설정되었다면, 함수는 메시지를 보내지 않고 즉각 리턴하며 반환값은 -1 이 됩니다. msgflg 에 IPC_NOWAIT 가 설정되어 있지 않다면, 메시지를 전송하는 프로세스는 큐에 서 빈 공간이 생길 때까지 기다리게 될 것입니다. 성공적으로 함수가 수행되었다면 0을 반환하고, 실패했을 경우에는 -1을 반환합니다. 함수 호출이 성공하였다면 메시지 데이터의 복사본은 메시지 큐에 저장됩니다. ㄷ. msgrcv msgrcv 함수는 메시지 큐로 부터 메시지를 전송받는 역할을 합니다. int msgrcv(int msqid, void *msg_ptr, size_t msg_sz, long int msgtype, int msgflg); 첫번째 매개변수인 msqid 는 msgget 에서 반환된 메시지 큐 식별자입니다. 두번째 매개변수인 msg_ptr 은 메시지를 전송받아서 저장하게 될 구조체에 대한 포인 터입니다. 전송받을 구조체는 msgsnd 함수에서 설명한 것처럼 'long int' 형으로 시작합니다. 세번째 매개변수인 msg_sz 은 msg_ptr 이 가르키는 메시지 저장소의 크기입니다. 이 크기에서는 처음의 'long int' 형의 크기는 제외됩니다. 네번째 매개변수인 msgtype 은 'long int' 형입니다. msgtype 은 메시지를 전송받을 때 간단한 우선순위를 적용할 수 있습니다. msgtype 이 0이라면, 메시지 큐에 있는 첫번째 유효한 메시지를 전송받고, 0보다 크다면 msgtype 과 같은 값을 가지고 있는 메시지를 받게 되고, 0보다 작다면 msgtype의 절대값과 같거나 작은 첫번째 메시지를 받게 됩니다. 이렇게 설명하니 실제 사용할 때 보다 더 복잡하게 보이지만, msgtype 을 간단히 0으 로 설정하면 메시지 큐에 들어온 순서대로 메시지를 가져올 수 있습니다. 어떤 특정 한 메시지만 전송받고자 한다면 msgtype 을 해당 값으로 설정하면 됩니다. n 이나 n 보다 작은 형태의 메시지만 받고자 한다면 msgtype 을 -n 으로 설정하면 됩니다. 다섯번째 매개변수인 msgflg 는 메시지 큐에 해당하는 형태의 메시지가 없을 경우에 전송받을 때까지 기다릴지를 결정합니다. msgflg 에 IPC_NOWAIT 가 설정되어 있다 면, 호출은 즉시 -1 을 돌려주면서 반환할 것입니다. IPC_NOWAIT 가 설정되어 있지 않다면, 해당하는 형태의 메시지가 도착할 때 까지 기다릴 것입니다. msgrcv 함수가 성공적으로 수행되면, 사용자 버퍼에 전송된 메시지의 바이트 수를 반 환하고, 사용자가 할당한 버퍼를 가르키는 msg_ptr에 메시지가 복사되고, 메시지 큐 에서 해당 메시지는 삭제됩니다. 에러가 발생했을 경우에는 -1을 반환합니다. ㄹ. msgctl 마지막으로 살펴볼 메시지 큐 함수는 msgctl 입니다. 이 함수는 공유메모리를 제어 할 때 사용하는 함수와 매우 비슷합니다. int msgctl(int msqid, int command, struct msqid_ds *buf); msqid_ds 구조체는 최소한 다음의 멤버를 가집니다. struct msqid_ds { uid_t msg_perm.uid; uid_t msg_perm.gid; mode_t msg_perm.mode; } 첫번째 매개변수인 msqid 는 msgget 에서 반환된 식별자입니다. 두번째 매개변수인 command 는 취할 행동입니다. 가능한 값들은 다음과 같습니다. ---------------------------------------------------------------------------- 명 령 설 명 ---------------------------------------------------------------------------- IPC_STAT 메시지 큐에 대한 정보를 msqid_ds 구조체로 복사합니다. IPC_SET msqid_ds 구조체에 담긴 메시지 큐에 대한 정보를 해당 메시지 큐 로 복사하여 관련 정보를 변경합니다. 프로세스는 이에 필요한 해당 권한을 가지고 있어야 합니다. IPC_RMID 메시지 큐를 제거합니다. ---------------------------------------------------------------------------- msgctl 함수가 성공적으로 수행되면 0을 반환하고, 실패했을 경우에는 -1을 반환한 다. 프로세스가 msgsnd 나 msgrcv 함수에서 기다리고 있는 과정에서 해당 메시지 큐가 삭제된다면 관련 함수는 실패하게 됩니다. 지금까지 메시지 큐에 관련한 함수를 살펴보았습니다. 이제 지금까지 살펴본 메시 지 큐를 테스트 하는 예제를 만들어 봅시다. ---------------------------------------------------------------------------- /* msg.c : 메시지 큐의 예제 - 두개의 프로세스간 데이터 전송 테스트 */ #include #include #include #include #include #include #include #define MSGKEY 100 struct my_msg_st { long int my_msg_type; char some_text[BUFSIZ]; }; struct my_msg_st some_data; int receiver(key_t msgkey) { int msgid, done = 1; msgid = msgget((key_t)msgkey, 0666 | IPC_CREAT); if (msgid == -1) { fprintf(stderr, "msgget failed\n"); exit(EXIT_FAILURE); } while (done) { if (msgrcv(msgid, (void *)&some_data, BUFSIZ, 0, IPC_NOWAIT) == -1) { if (errno == ENOMSG) { fprintf(stderr, "더 이상 메시지가 없습니다.\n"); } else { fprintf(stderr, "msgrcv 실패\n"); } exit(EXIT_FAILURE); } printf("받은 메시지: %s", some_data.some_text); if (strncmp(some_data.some_text, ".", 1) == 0) { done = 0; } } if (msgctl(msgid, IPC_RMID, 0) == -1) { fprintf(stderr, "msgctl(IPC_RMID) failed\n"); exit(EXIT_FAILURE); } printf("\n메시지 수신을 종료합니다.\n\n"); exit(EXIT_SUCCESS); } int sender(key_t msgkey) { int msgid, done = 1; char buffer[BUFSIZ]; msgid = msgget((key_t)msgkey, 0666 | IPC_CREAT); if (msgid == -1) { fprintf(stderr, "msgget failed\n"); exit(EXIT_FAILURE); } printf("전송할 메시지를 입력하세요.\n"); printf("메시지 입력 종료는 첫칸에 '.'를 입력하세요.\n\n"); while (done) { printf("전송할 메시지: "); fgets(buffer, BUFSIZ, stdin); some_data.my_msg_type = 1; strcpy(some_data.some_text, buffer); if (msgsnd(msgid, (void *)&some_data, BUFSIZ, 0) == -1) { fprintf(stderr, "msgsnd failed\n"); exit(EXIT_FAILURE); } if (strncmp(buffer, ".", 1) == 0) { done = 0; } } printf("\n메시지 전송을 종료합니다.\n\n"); exit(EXIT_SUCCESS); } void main(int argc, char *argv[]) { if (argc > 1) { receiver(MSGKEY); } else { sender(MSGKEY); } } ---------------------------------------------------------------------------- 프로그램을 컴파일해서 실행해볼까요? $ gcc -o msg msg.c $ msg 전송할 메시지를 입력하세요. 메시지 입력 종료는 첫칸에 '.'를 입력하세요. 전송할 메시지: 이글은 메시지큐로 전송됩니다. 전송할 메시지: 나중에 수신해서 볼 수 있습니다. 전송할 메시지: . 메시지 전송을 종료합니다. queen:~/ipc$ msg r 받은 메시지: 이글은 메시지큐로 전송됩니다. 받은 메시지: 나중에 수신해서 볼 수 있습니다. 받은 메시지: . 메시지 수신을 종료합니다. $ 메시지 큐를 간단하게 테스트 해보았습니다. 원하는 데로 잘 되는군요.. 그럼, 이제 지금까지 배운 세마포어, 공유메모리, 메시지 큐를 함께 사용하여, 앞에 서 잠시 언급한 대화방 시스템을 만들어 봅시다. $$$$$$$ 세마포어, 공유메모리, 메시지 큐를 함께 사용한 대화방 만들기 $$$$$$$$ 앞서도 말씀드렸지만, 대화방 같은 경우는 요즘 socket 이나 device 에 직접 쓰기 방식으로 많이 구현하기도 합니다. 하지만, 여기서는 IPC 기능들을 마지막으로 총 정리 할 겸, 좀 더 섬세한 제어가 가능한 세마포어, 공유메모리, 메시지 큐를 함께 사용하겠습니다. 사실 IPC 설비들은 socket 과 함께 서버/클라이언트 프로그래밍 에서 아주 유용하게 사용될 수 있습니다. 이것은 여러분들이 직접 경험을 하시면서 느껴 보시기 바라겠습니다. 위에서도 잠시 말씀드렸지만, 메시지 전달의 효율성을 위해서 메시지 큐를 사용하기 로 하지요. 아울러 전체 정보를 유지하기 위해서 공유메모리 세그먼트를 활용하기 로 하고, 공유메모리를 다루는 데서 생기는 프로세스 동기화 문제는 세마포어를 사 용하여 해결하도록 하겠습니다. 다음의 프로그램에서 사용하고 있는 구조체는 다음과 같습니다. typedef struct { long int msg_type; pid_t sender_pid; char sender_id[12]; char sender_nick[12]; char text[256]; int text_type; } CHAT; CHAT 구조체는 실제 대화를 할 때, 메시지 송수신에 필요한 내용을 실어나르는 역 할을 합니다. msg_type 에는 수신하는 프로세스의 번호를 지정함으로써 수신자를 하나씩 지정할 수 있습니다. sender_pid 는 메시지를 송신하는 프로세스의 번호입 니다. 이것은 메시지를 수신하는 자식 프로세스가, 종료메시지를 보낸 부모프로세스 를 확인하는 데 사용됩니다. sender_id 와 sender_nick 와 text 는 수신하는 프로 세스가 사용자의 화면에 출력할 때 사용됩니다. text_type 은 대화의 종류로서, 입장, 퇴장, 귓속말, 일반대화 등을 나타냅니다. 아래의 정의문장은 text_type 에서 사용되는 것입니다. #define JOIN_TEXT 0 /* 입장 */ #define GEN_TEXT 1 /* 일반적인 대화 */ #define EAR_TEXT 2 /* 귓속말 */ #define EXIT_TEXT 3 /* 퇴장 */ typedef struct { char joiner_id[MAX_JOINER][12]; char joiner_nick[MAX_JOINER][12]; pid_t joiner_pid[MAX_JOINER]; /* 참여자의 프로세스 번호 */ int cur_joiner_num; } ROOM; ROOM 구조체는 대화에 참여하는 모든 프로세스가 읽고 쓸 수 있는 공유메모리 세그 먼트에 위치할 내용입니다. 현재 대화에 참여하고 있는 사용자의 id, 별명, 프로 세스 번호의 내용을 담고 있습니다. 사용자의 대화참여 및 퇴장에 따라 계속 데이 터가 변하게 됩니다. 물론, 구미에 따라 방제목, 참여인원제한 등의 내용을 첨삭 할 수 있습니다. typedef struct { char id[12]; char nick[12]; pid_t pid; } JOINER; JOINER 는 해당 프로세스 사용자의 기본 정보입니다. 아래에서, send 는 메시지를 전송할 때 사용하고, receive 는 메시지를 수신할 때 사용합니다. CHAT send, receive; ROOM room; JOINER joiner; 대화방을 하나로 구성한다면, 공유메모리 세그먼트도 하나로 충분합니다. 물론 편 의에 따라 대화방이 여러개라도 공유메모리는 하나로 할 수 있겠지요? 메시지 큐도 하나를 사용하고, 여러 프로세스로부터의 동시 접근으로 인한 데이터 의 보호를 위해 하나의 바이너리 세마포어를 사용하였습니다. 접근하는 메모리 세그먼트가 여러곳일 경우에는 여러개의 세마포어를 사용하는 것이 좋을 겁니다. int semid, shmid, msgid; memptr 은 공유메모리 세그먼트의 시작부분을 가르킵니다. char *memptr; 여기에서, main 과 세마포어 함수를 제외하면, 4개의 함수가 사용됩니다. join_chat_room 은 대화에 참여하는 프로세스가 실행을 하면, 공유메모리 세그먼트 의 내용을 적절하게 변경하는 역할을 합니다. sender 는 stdin 에서 대화내용을 입력받으며, send_msg 는 sender 수행중에서 실제로 메시지를 전송하기 위해 호출 합니다. receiver 는 자식 프로세스가 수행하며, 메시지 큐로 부터 자신에게 온 내용을 사용자의 화면에 출력하는 역할을 합니다. int receiver(); int send_msg(CHAT *send_msg); int sender(); int join_chat_room(); (계속..) 『리눅스 학당-리눅스 강좌 / 연재 (go LINUX)』 481번 제 목:[강좌6] 시스템 V IPC - 예제 소스 올린이:ddoch (한동훈 ) 97/07/11 23:49 읽음:1992 관련자료 없음 ----------------------------------------------------------------------------- 실제로, 대부분의 대화방 시스템은 입력과 출력이 분리가 되어 있습니다. 대화방에서 채팅을 할 경우를 생각해 봅시다. 우리가 입력하는 것과는 별도로 상대방의 내용이 계속 화면에 출력되는 것을 알 수 있습니다. 이럴 경우에 kbhit 이나 글쇠입력이 될 때까지 기다리지 않는 getch 를 사용하여 해결하는 것은 비효율적이고 상당히 힘든 작업이 될 것 입니다. 따라서, fork 를 사용하여 입력 받는 프로세스와 출력하는 프로세스를 분리하는 것도 하나 생각해 볼 수 있는 방법 이겠지요. main 에서 보면, fork 전까지는 하나의 프로세스가 수행하나, fork 부터는 sender 는 부모프로세스가, receiver 는 자식 프로세스가 수행하여 역할을 분리하고 있습 니다. 자식이 종료하는 싯점은, 부모가 대화방을 빠져나가면서, text_type 으로 EXIT_TEXT 를 자신의 프로세스의 PID 와 함께 전송할 때, 자식 프로세스는 자신의 부모 프로세스가 종료함을 확인하고 wait 하는 부모에게 exit 를 하는 방법으로 종 료를 하게 됩니다. 물론 자식 프로세스에게 특정한 시그널을 보내서 처리하는 방법 도 괜찮을 겁니다. 그 이후에 부모 프로세스는 참여자 숫자를 하나 줄이고 자신이 마지막 참여자이면 시스템의 자원을 제거하고 종료하게 됩니다. 여기서 또하나 생각해 볼만한 문제는 공유메모리 세그먼트에 현재 대화에 참여하고 있는 참여자의 정보를 어떻게 유지하느냐 하는 것입니다. 다음과 같이 간단하게 생각해 볼 수 있습니다. 대화에 참여하는 사람을 순서대로 메모리에 적재한다고 하더라도, 퇴장할 때는 먼저 들어온 사람이 먼저 나갈 수도 있기 때문에 순차적으로 참여자 정보를 관리하는 것은 문제가 생길 수 있습니다. 여기서는 간단하게, 입장하는 참여자의 정보를 차례로 적고, 퇴장할 때에는 해당 프로세스 번호 (joiner_pid) 를 찾아서 0번으로 표시를 하고, 해당 인덱스의 참여 자 정보는 무시하는 방법을 사용합니다. 이후의 새로운 참여자의 정보를 기록할 때에는 joiner_pid 배열 중 첫번째로 0번인 엔트리를 찾아서 새롭게 데이터를 기록 합니다. 아래의 joiner_pid 배열 중 0번 엔트리는 퇴장한 참여자이거나, 아직 비어 있는 곳입니다. cur_joiner_num = 4; +----+----+----+----+----+----+----+----+----+----+----+----+ joiner_pid |251 |253 | 0 |356 | 0 | 0 |562 | 0 | 0 | 0 | 0 | 0 | +----+----+----+----+----+----+----+----+----+----+----+----+ +----+----+----+----+----+----+----+----+----+----+----+----+ joiner_id |aaa |bbb |ccc |ddd |eee |fff |ggg |hhh |iii |jjj |kkk |lll | +----+----+----+----+----+----+----+----+----+----+----+----+ +----+----+----+----+----+----+----+----+----+----+----+----+ joiner_nick |111 |222 |333 |444 |555 |666 |777 |888 |999 |000 |&&& |$$$ | +----+----+----+----+----+----+----+----+----+----+----+----+ [ 공유메모리 세그먼트 내의 정보 ] 마지막으로, 세마포어에 대해서 잠깐 살펴볼까요? 여기에서는 실제적으로 공유메모리에서 위의 정보를 한꺼번에 읽어와서 부분적으로 수정한 다음 다시 한꺼번에 적는 방법을 사용하기 때문에 중요한 임계영역은 하나 입니다. 따라서 읽고 쓸 경우에만 하나의 이진 세마포어를 사용하여 임계영역을 보호하는 방법을 취하고 있습니다. 따라서 읽기만 하는 경우에는 굳이 임계영역을 보호하지 않아도 큰 무리는 없을 것입니다. 아래의 소스에서 #ifndef NO_SEMAPHORE ... #endif 부분이 프로세스 동기화를 위해 세마포어를 첨삭한 곳이니 참고하시기 바랍니다. 이제, 소스를 만들어 봅시다. ----------------------------------------------------------------------------- /* * chat.c : system v ipc 기능을 사용한 간단한 대화방 시스템 * * Designed by Han-donghun, 1997.7.11 * * E-mail : ddoch@hitel.kol.co.kr * * name : chat.c * * compile : ipc_sem.c 와 함께 컴파일하려면, * * gcc -o chat chat.c ipc_sem.c * * semaphore 를 사용하지 않으려면, * * gcc -o chat chat.c -DNO_SEMAPHORE * * usage : ./chat * * 설명 : 대화방 시스템 중 메시지 전송은 메시지큐를 사용하고, 전체적인 * 정보는 공유메모리를 사용하였으며, 임계영역 보호는 세마포어를 * 사용하였음. */ #ifndef _POSIX_SOURCE #define _POSIX_SOURCE #endif #ifndef __STDC__ #define __STDC__ #endif #include #include #include #include #include #include #include #include #include #include #include #ifndef NO_SEMAPHORE #include "ipc_sem.h" /* 세마포어 함수들 */ #endif #define MAX_JOINER 12 #define KEY 1 #define CHAT_SIZE (sizeof(CHAT)-sizeof(long int)) /* 하나의 메시지 */ typedef struct { long int msg_type; pid_t sender_pid; char sender_id[12]; char sender_nick[12]; char text[256]; int text_type; } CHAT; /* 대화의 종류 CHAT.text_type */ #define JOIN_TEXT 0 /* 입장 */ #define GEN_TEXT 1 /* 일반적인 대화 */ #define EAR_TEXT 2 /* 귓속말 */ #define EXIT_TEXT 3 /* 퇴장 */ /* 공유메모리의 대화방 정보 */ typedef struct { char joiner_id[MAX_JOINER][12]; char joiner_nick[MAX_JOINER][12]; pid_t joiner_pid[MAX_JOINER]; /* 참여자의 프로세스 번호 */ int cur_joiner_num; } ROOM; /* 참여자의 신상명세 */ typedef struct { char id[12]; char nick[12]; pid_t pid; } JOINER; CHAT send, receive; ROOM room; JOINER joiner; #ifndef NO_SEMAPHORE int semid; #endif int shmid; int msgid; /* 세가지 IPC 식별자 */ char *memptr; /* 공유메모리 주소 */ int receiver(); int send_msg(CHAT *send_msg); int sender(); int join_chat_room(); int receiver() { msgid = msgget((key_t)KEY, 0666); if (msgid == -1) { perror("msgget"); return -1; } while (1) { if (msgrcv(msgid, (void *)&receive, CHAT_SIZE, getppid(), 0) == -1) { perror("msgrcv"); return -1; } switch (receive.text_type) { case JOIN_TEXT : printf(" *** %s(%s:%s) 님이 들어오셨습니다!!\n", receive.sender_nick, receive.sender_id, receive.sender_nick); break; case GEN_TEXT : if (receive.sender_pid == getppid()) { printf(" \033[7m%-8s\033[m(%s) %s\n", receive.sender_id, receive.sender_nick, receive.text); } else { printf(" %-8s(%s) %s\n", receive.sender_id, receive.sender_nick, receive.text); } break; case EAR_TEXT : printf(" \033[7m(귓속말)\033[m %-8s(%s) %s\n", receive.sender_id, receive.sender_nick, receive.text); break; case EXIT_TEXT : printf(" *** %s(%s) 님이 나가셨습니다.\n", receive.sender_id, receive.sender_nick); if (receive.sender_pid == getppid()) { shmdt(memptr); usleep(200000); /* 부모가 기다릴 시간적 여유 */ exit(1); } break; } memset((void *)&receive, 0, sizeof(CHAT)); #ifdef DEBUG memcpy((void *)&room, (void *)memptr, sizeof(ROOM)); printf("cur_joiner_num = %d\n", room.cur_joiner_num); { int i; for (i = 0; i < MAX_JOINER; i++) { if (room.joiner_pid[i] != 0) { printf("joiner_nick = %s , joiner_pid = %d\n", room.joiner_nick[i], room.joiner_pid[i] ); } } /* for */ } #endif } /* while */ } int send_msg(CHAT *send_msg) { int i; /* 공유메모리에서 정보를 읽어오기 */ memcpy((void *)&room, (void *)memptr, sizeof(ROOM)); send_msg->sender_pid = joiner.pid; strcpy(send_msg->sender_id, joiner.id); strcpy(send_msg->sender_nick, joiner.nick); for (i = 0; i < MAX_JOINER; i++) { if (room.joiner_pid[i] != 0) { send_msg->msg_type = room.joiner_pid[i]; if (msgsnd(msgid, (void *)send_msg, CHAT_SIZE, 0) == -1) { perror("msgsnd"); exit(1); } } /* if 0 */ } return 0; } int sender() { char buffer[60]; int done = 0; int status, delete; msgid = msgget(KEY, 0666 | IPC_CREAT); if (msgid == -1) { perror("msgget"); return -1; } send.text_type = JOIN_TEXT; send_msg(&send); while (!done) { fgets(buffer, 60, stdin); buffer[strlen(buffer)-1] = '\0'; if (strcmp(buffer, "/q") == 0) { /* 퇴장하기 위한 여러가지 준비 1. 자신의 퇴장메시지를 마지막으로 보낸다. 2. 자식 프로세스에게 종료 메시지 자식은 메시지를 수령하고, 공유메모리와 접속을 끊고 부모프로세스에게 귀가 3. 공유메모리 room 에서 cur_joiner_num 을 하나 감소시킨다. 4. 부모는 wait 를 수행한다. 5. 공유메모리와의 접속을 끊고 종료한다. */ send.text_type = EXIT_TEXT; send_msg(&send); #ifndef NO_SEMAPHORE p(semid); /* 읽고 쓰기 위해 세그먼트에 접근하는 임계영역의 시작 부분 */ #endif memcpy((void *)&room, (void *)memptr, sizeof(ROOM)); for (delete = 0; delete < MAX_JOINER; delete++) { if (joiner.pid == room.joiner_pid[delete]) { room.joiner_pid[delete] = 0; break; } } room.cur_joiner_num--; memcpy((void *)memptr, (void *)&room, sizeof(ROOM)); #ifndef NO_SEMAPHORE v(semid); /* 임계영역의 출구 */ #endif wait(&status); shmdt(memptr); if (room.cur_joiner_num == 0) { /* 시스템 자원 제거 */ #ifndef NO_SEMAPHORE delsem(semid); #endif shmctl(shmid, IPC_RMID, (struct shmid_ds *)0); msgctl(msgid, IPC_RMID, 0); } done = 1; } else { send.text_type = GEN_TEXT; strcpy(send.text, buffer); send_msg(&send); } } return 0; } int join_chat_room() { int empty; #ifndef NO_SEMAPHORE /* 세마포어 초기화 */ if ((semid = initsem(KEY)) < 0) { perror("initsem"); exit(1); } #endif if ((shmid = shmget(KEY, 1024, 0666|IPC_CREAT|IPC_EXCL)) < 0) { if (errno == EEXIST) { /* 이미 방이 만들어져 있을 경우 */ shmid = shmget(KEY, 1024, 0666|IPC_CREAT); } if ((memptr = shmat(shmid, (char *)0, 0)) == (char *)-1) { perror("shmat"); exit(1); } } else { /* 방을 처음으로 만들었을 경우 */ if ((memptr = shmat(shmid, (char *)0, 0)) == (char *)-1) { perror("shmat"); exit(1); } /* 방에 대한 정보를 초기화 한다. */ memset((void *)&room, 0, sizeof(ROOM)); memset((void *)memptr, 0, 1024); } #ifndef NO_SEMAPHORE p(semid); /* 임계영역의 출구 */ #endif memcpy((void *)&room, (void *)memptr, sizeof(ROOM)); if (room.cur_joiner_num >= MAX_JOINER) { printf("대화방의 정원이 찼습니다.\n"); exit(1); } /* 공유메모리내에서 비어있는 프로세스 테이블 엔트리 찾기 */ for (empty = 0; empty < room.cur_joiner_num; empty++) { if (room.joiner_pid[empty] == 0) /* 빈 항목 */ break; } strcpy(room.joiner_id[empty], joiner.id); strcpy(room.joiner_nick[empty], joiner.nick); room.joiner_pid[empty] = joiner.pid; room.cur_joiner_num++; memcpy((void *)memptr, (void *)&room, sizeof(ROOM)); #ifndef NO_SEMAPHORE v(semid); /* 임계영역의 출구 */ #endif return 0; } void main() { pid_t receiver_pid; setbuf(stdout, NULL); /* 참여자 정보 얻기 */ strcpy(joiner.id, getenv("LOGNAME")); joiner.pid = getpid(); printf(" 별명 : "); fgets(joiner.nick, 12, stdin); joiner.nick[strlen(joiner.nick)-1] = '\0'; join_chat_room(); if ((receiver_pid = fork()) < 0) { perror("fork"); } else if (receiver_pid > 0) { /* parent sender process */ sender(); } else { /* child sender process */ receiver(); } } ----------------------------------------------------------------------------- 위의 대화방 기능을 좀 더 추가하여 그럴 듯 하게 한번 만들어 보시길 바랍니다. 아울러 curses 나 X 윈도우 위젯을 입혀서 좀 더 편리하게 사용할 수도 있을 것입니 다. 지금까지, IPC 기능을 사용하여 쓸만한 예제를 하나 만들어 보았습니다. 6. 나오는 말 날씨가 점점 무더워 지는 것 같군요. -.-;;; 여러분들이 공부하는 부분에 좀 도움이 됐을 지 모르겠군요. 아뭏던 IPC 를 사용하여 근사한 프로그램을 하나 짜보시기 바랍니다. 좀 엉성하긴 하지만, IPC (세마포어, 공유메모리, 메시지 큐)강좌는 이것으로 마치 기로 하겠습니다. 그럼, 안녕히~~ ddoch 한동훈 드림