세마포에대해...질문!

질문 1에 대한 답변은 네 그 구조체 자체가 헤더 파일에 없기 때문에 해
주어야 합니다.

그리고 이렇게 에러가 나는이유는 세마포를 사용하는 목적이 동기화인데

세마포 값이 0,1 이라고 볼때 0일때 1일때로 바뀔때까지 기다리는 루틴이
없기 때문에 이런 결과가 나는 것 같네요.

while문으로 기다려 줘야 겠지요..

자세한건 semtool.c 로 구글 검색해서 되는 소스 찾아 보셔두 되고요. 근
데 이건 조금 힘들더군요.. 소스가 안돌아 가는 것들이 있어서

세마포 예제 제대로 돌아가는건 Begging Linux Programming (정보문화사)
13장 참고 하시면 됩니다.

아래 예제는 제가 사용하는 세마포 함수 루틴입니다.
기존의 semtool 이용해서 my_lock() my_unlock()로 구현한것입니다.

/********************************************************************
*********
Excerpt from "Linux Programmer's Guide - Chapter 6"
(C)opyright 1994-1995, Scott Burkett

*********************************************************************
********
MODULE semtool.c

*********************************************************************
********
A command line tool for tinkering with SysV style Semaphore Sets

*********************************************************************
********/

#include
#include
#include
#include
#include
#include
#include
#include
//#include

#include "lock.h"

#define SEM_RESOURCE_MAX 1 /* Initial value of all
semaphores */
#define SEMMSL 250 /* <= 8 000 max num of semaphores
per id */
union semun {
int val;
struct semid_ds *buf;
unsigned short int *array;
struct seminfo *__buf;
};
key_t key = 1111;
int semset_id;

/*
void opensem(int *sid, key_t key);
void createsem(int *sid, key_t key, int members);
void locksem(int sid, int member);
void unlocksem(int sid, int member);
void removesem(int sid);
unsigned short get_member_count(int sid);
int getval(int sid, int member);
void dispval(int sid, int member);
void changemode(int sid, char *mode);
void usage(void);
*/

void
my_lock(int num)
{

/* Create unique key via call to ftok() */
//key = ftok(".", 's');

my_opensem(&semset_id,key,6);

opensem(&semset_id, key);
locksem(semset_id, num);
}

void
my_unlock(int num)
{
//key_t key;
//int semset_id;
/* Create unique key via call to ftok() */
//key = ftok(".", 's');
//key=1234;

opensem(&semset_id, key);
unlocksem(semset_id, num);
}

void my_opensem(int *sid, key_t key,int member)
{
/* Open the semaphore set - do not create! */

if((*sid = semget(key, 0, 0666)) == -1)
{
createsem(sid,key,member);
}


}

void opensem(int *sid, key_t key)
{
/* Open the semaphore set - do not create! */

if((*sid = semget(key, 0, 0666)) == -1)
{
printf("Semaphore set does not exist!\n");
exit(1);
}


}

void createsem(int *sid, key_t key, int members)
{
int cntr;
//union semnum semopts;
union semun semopts;

if(members > SEMMSL) {
printf("Sorry, max number of semaphores in a set is %
d\n",
SEMMSL);
exit(1);
}

printf("Attempting to create new semaphore set with %d
members\n",
members);

if((*sid = semget(key, members, IPC_CREAT|IPC_EXCL|0666))
== -1)
{
fprintf(stderr, "Semaphore set already exists!\n");
exit(1);
}

semopts.val = SEM_RESOURCE_MAX;

/* Initialize all members (could be done with SETALL)
*/
for(cntr=0; cntr semctl(*sid, cntr, SETVAL, semopts);
}

void locksem(int sid, int member)
{
struct sembuf sem_lock={ 0, -1, IPC_NOWAIT};
int t=1;

if( member<0 || member>(get_member_count(sid)))
{
fprintf(stderr, "semaphore member %d out of
range\n", member);
fprintf(stderr, "semaphore member %d out of
range\n", get_member_count(sid));

return;
}

/* Attempt to lock the semaphore set
if(!getval(sid, member))
{
fprintf(stderr, "Semaphore resources exhausted (no
lock)!\n");
exit(1);
}
*/
/* Attempt to lock the semaphore set */
while(!getval(sid, member))
{
//fprintf(stderr, "Semaphore resources exhausted (no
lock)!\n");
//exit(1);
sleep(t%10);
t++;
}

sem_lock.sem_num = member;

if((semop(sid, &sem_lock, 1)) == -1)
{
fprintf(stderr, "Lock failed\n");
exit(1);
}
else
printf("Semaphore resources decremented by one
(locked)\n");


dispval(sid, member);
}

void unlocksem(int sid, int member)
{
struct sembuf sem_unlock={ member, 1, IPC_NOWAIT};
int semval;

if( member<0 || member>(get_member_count(sid)))
{
fprintf(stderr, "semaphore member %d out of
range\n", member);
return;
}

/* Is the semaphore set locked? */
semval = getval(sid, member);
if(semval == SEM_RESOURCE_MAX) {
fprintf(stderr, "Semaphore not locked!\n");
exit(1);
}

sem_unlock.sem_num = member;

/* Attempt to lock the semaphore set */
if((semop(sid, &sem_unlock, 1)) == -1)
{
fprintf(stderr, "Unlock failed\n");
exit(1);
}
else
printf("Semaphore resources incremented by one
(unlocked)\n");

dispval(sid, member);
}

void removesem(int sid)
{
semctl(sid, 0, IPC_RMID, 0);
printf("Semaphore removed\n");
}

unsigned short get_member_count(int sid)
{
union semun semopts;
struct semid_ds mysemds;

semopts.buf = &mysemds;

/* Return number of members in the semaphore set */
return(semopts.buf->sem_nsems);
}

int getval(int sid, int member)
{
int semval;

semval = semctl(sid, member, GETVAL, 0);
return(semval);
}

void changemode(int sid, char *mode)
{
int rc;
union semun semopts;
struct semid_ds mysemds;

/* Get current values for internal data structure */
semopts.buf = &mysemds;

rc = semctl(sid, 0, IPC_STAT, semopts);

if (rc == -1) {
perror("semctl");
exit(1);
}

printf("Old permissions were %o\n", semopts.buf-
>sem_perm.mode);

/* Change the permissions on the semaphore */
sscanf(mode, "%ho", &semopts.buf->sem_perm.mode);

/* Update the internal data structure */
semctl(sid, 0, IPC_SET, semopts);

printf("Updated...\n");

}

void dispval(int sid, int member)
{
int semval;

semval = semctl(sid, member, GETVAL, 0);
printf("semval for member %d is %d\n", member, semval);
}

void usage(void)
{
fprintf(stderr, "semtool - A utility for tinkering with
semaphores\n");
fprintf(stderr, "\nUSAGE semtool4 (c)reate \n");
fprintf(stderr, " (l)ock \n");
fprintf(stderr, " (u)nlock \n");
fprintf(stderr, " (d)elete\n");
fprintf(stderr, " (m)ode \n");
exit(1);
}

---------------------------------------------------------------
---------------------------------------------------------------
lock.h
#include
void my_lock(int num);
void my_unlock(int num);
void my_opensem(int *sid, key_t key,int member);
void opensem(int *sid, key_t key);
void createsem(int *sid, key_t key, int members);
void locksem(int sid, int member);
void unlocksem(int sid, int member);
void removesem(int sid);
unsigned short get_member_count(int sid);
int getval(int sid, int member);
void dispval(int sid, int member);
void changemode(int sid, char *mode);
void usage(void);