16.信号量互斥编程

我们先来看一个例子。就是两个进程访问同一个文件，由于线程的先后，导致内容的异常。即是数据内容的混乱。

Student1.c:

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

void main(){

//open file

int fd = 0;

fd = open("/home/wen",O_RDWR|O_APPEND);

//write something into file

write(fd,"forfish!",8);

//rest

sleep(10);

//write something else.

write(fd,"is die!",7);

close(fd);

}

Student2.c:

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

void main(){

int fd = 0;

fd = open("/home/wen",O_RDWR|O_APPEND);

write(fd,"fish!",5);

close(fd);

}

运行的结果：

最后是两个人都die了。这信息错误就严重了。所以我们要有机制来控制对资源的使用，才不会产生混乱。

这就引出了信号量的概念：信号量(又名：信号灯)与其他进程间通信方式不大相同，主要用途是保护临界资源(进程互斥)。进程可以根据它判定是否能够访问某些共享资源。除了用于访问控制外，还可用于进程同步。

信号量的分类：

二值信号灯：信号灯的值只能取0或1
计数信号灯：信号灯的值可以取任意非负数。

接下来是使用信号量：

信号量的函数：semget:

Man 2 semget的信息：

NAME

semget - get a semaphore set identifier

SYNOPSIS

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

int semget(key_t key, int nsems, int semflg);

DESCRIPTION

The semget() system call returns the semaphore set identifier associ-

ated with the argument key. A new set of nsems semaphores is created

if key has the value IPC_PRIVATE or if no existing semaphore set is

associated with key and IPC_CREAT is specified in semflg.

If semflg specifies both IPC_CREAT and IPC_EXCL and a semaphore set

already exists for key, then semget() fails with errno set to EEXIST.

(This is analogous to the effect of the combination O_CREAT | O_EXCL

for open(2).)

Upon creation, the least significant 9 bits of the argument semflg

define the permissions (for owner, group and others) for the semaphore

set. These bits have the same format, and the same meaning, as the

mode argument of open(2) (though the execute permissions are not mean-

ingful for semaphores, and write permissions mean permission to alter

semaphore values).

The values of the semaphores in a newly created set are indeterminate.

(POSIX.1-2001 is explicit on this point.) Although Linux, like many

other implementations, initializes the semaphore values to 0, a

portable application cannot rely on this: it should explicitly initial-

ize the semaphores to the desired values.

When creating a new semaphore set, semget() initializes the set's asso-

ciated data structure, semid_ds (see semctl(2)), as follows:

sem_perm.cuid and sem_perm.uid are set to the effective user ID

of the calling process.

sem_perm.cgid and sem_perm.gid are set to the effective group ID

of the calling process.

The least significant 9 bits of sem_perm.mode are set to the

least significant 9 bits of semflg.

sem_nsems is set to the value of nsems.

sem_otime is set to 0.

sem_ctime is set to the current time.

The argument nsems can be 0 (a don't care) when a semaphore set is not

being created. Otherwise nsems must be greater than 0 and less than or

equal to the maximum number of semaphores per semaphore set (SEMMSL).

If the semaphore set already exists, the permissions are verified.

RETURN VALUE

If successful, the return value will be the semaphore set identifier (a

non-negative integer), otherwise -1 is returned, with errno indicating

the error.

ERRORS

On failure errno will be set to one of the following:

EACCES A semaphore set exists for key, but the calling process does not

have permission to access the set, and does not have the

CAP_IPC_OWNER capability.

EEXIST A semaphore set exists for key and semflg specified both

IPC_CREAT and IPC_EXCL.

EINVAL nsems is less than 0 or greater than the limit on the number of

semaphores per semaphore set (SEMMSL), or a semaphore set corre-

sponding to key already exists, and nsems is larger than the

number of semaphores in that set.

ENOENT No semaphore set exists for key and semflg did not specify

IPC_CREAT.

ENOMEM A semaphore set has to be created but the system does not have

enough memory for the new data structure.

ENOSPC A semaphore set has to be created but the system limit for the

maximum number of semaphore sets (SEMMNI), or the system wide

maximum number of semaphores (SEMMNS), would be exceeded.

CONFORMING TO

SVr4, POSIX.1-2001.

NOTES

IPC_PRIVATE isn't a flag field but a key_t type. If this special value

is used for key, the system call ignores everything but the least sig-

nificant 9 bits of semflg and creates a new semaphore set (on success).

The following limits on semaphore set resources affect the semget()

call:

SEMMNI System wide maximum number of semaphore sets: policy dependent

(on Linux, this limit can be read and modified via the fourth

field of /proc/sys/kernel/sem).

SEMMSL Maximum number of semaphores per semid: implementation dependent

(on Linux, this limit can be read and modified via the first

field of /proc/sys/kernel/sem).

SEMMNS System wide maximum number of semaphores: policy dependent (on

Linux, this limit can be read and modified via the second field

of /proc/sys/kernel/sem). Values greater than SEMMSL * SEMMNI

makes it irrelevant.

BUGS

The name choice IPC_PRIVATE was perhaps unfortunate, IPC_NEW would more

clearly show its function.

The semaphores in a set are not initialized by semget(). In order to

initialize the semaphores, semctl(2) must be used to perform a SETVAL

or a SETALL operation on the semaphore set. (Where multiple peers do

not know who will be the first to initialize the set, checking for a

non-zero sem_otime in the associated data structure retrieved by a sem-

ctl(2) IPC_STAT operation can be used to avoid races.)

SEE ALSO

semctl(2), semop(2), ftok(3), capabilities(7), sem_overview(7),

svipc(7)

COLOPHON

This page is part of release 3.22 of the Linux man-pages project. A

description of the project, and information about reporting bugs, can

be found at http://www.kernel.org/doc/man-pages/.

创建/打开信号量集合的函数：semget：

函数的原型：

int semget(key_t key, int nsems, int semflg);

函数的功能是：获取信号量集合的标示符。当key所指定的信号量不存在的时候，并且semflg里面包含了IPC_CREAT，这个时候，就会创建一个信号量集合。

该函数要包含的头文件：

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

该函数的返回值：成功返回信号量集合的标示符。失败返回-1.

参数说明：

Key：键值。

Semflg：标志，可以取IPC_CREAT.

Nsems：创建的这个信号量集合里面包含的信号数目。

键值：

查看帮助文档：man 3 ftok:

NAME

ftok - convert a pathname and a project identifier to a System V IPC key

SYNOPSIS

#include <sys/types.h>

#include <sys/ipc.h>

key_t ftok(const char *pathname, int proj_id);

DESCRIPTION

The ftok() function uses the identity of the file named by the given pathname

(which must refer to an existing, accessible file) and the least significant 8

bits of proj_id (which must be non-zero) to generate a key_t type System V IPC

key, suitable for use with msgget(2), semget(2), or shmget(2).

The resulting value is the same for all pathnames that name the same file, when

the same value of proj_id is used. The value returned should be different when

the (simultaneously existing) files or the project IDs differ.

RETURN VALUE

On success the generated key_t value is returned. On failure -1 is returned,

with errno indicating the error as for the stat(2) system call.

CONFORMING TO

POSIX.1-2001.

NOTES

Under libc4 and libc5 (and under SunOS 4.x) the prototype was:

key_t ftok(char *pathname, char proj_id);

Today proj_id is an int, but still only 8 bits are used. Typical usage has an

ASCII character proj_id, that is why the behavior is said to be undefined when

proj_id is zero.

Of course no guarantee can be given that the resulting key_t is unique. Typi-

cally, a best effort attempt combines the given proj_id byte, the lower 16 bits

of the inode number, and the lower 8 bits of the device number into a 32-bit

result. Collisions may easily happen, for example between files on /dev/hda1

and files on /dev/sda1.

SEE ALSO

msgget(2), semget(2), shmget(2), stat(2), svipc(7)

COLOPHON

This page is part of release 3.22 of the Linux man-pages project. A description

of the project, and information about reporting bugs, can be found at

http://www.kernel.org/doc/man-pages/.

函数的原型：

key_t ftok(const char *pathname, int proj_id);

该函数的功能是创建一个键值。第一个参数是信号量文件的路径，绝对路径。第二个参数是项目编号，编号不一样，键值就不一样。

返回值就是信号量的键值。

操作信号量

函数semop自动执行信号量集合上的操作数组，这是个原子操作。

帮助文档信息：

NAME

semop, semtimedop - semaphore operations

SYNOPSIS

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

int semop(int semid, struct sembuf *sops, unsigned nsops);

int semtimedop(int semid, struct sembuf *sops, unsigned nsops,

struct timespec *timeout);

Feature Test Macro Requirements for glibc (see feature_test_macros(7)):

semtimedop(): _GNU_SOURCE

DESCRIPTION

Each semaphore in a semaphore set has the following associated values:

unsigned short semval; /* semaphore value */

unsigned short semzcnt; /* # waiting for zero */

unsigned short semncnt; /* # waiting for increase */

pid_t sempid; /* process that did last op */

semop() performs operations on selected semaphores in the set indicated by

semid. Each of the nsops elements in the array pointed to by sops specifies an

operation to be performed on a single semaphore. The elements of this structure

are of type struct sembuf, containing the following members:

unsigned short sem_num; /* semaphore number */

short sem_op; /* semaphore operation */

short sem_flg; /* operation flags */

Flags recognized in sem_flg are IPC_NOWAIT and SEM_UNDO. If an operation speci-

fies SEM_UNDO, it will be automatically undone when the process terminates.

The set of operations contained in sops is performed in array order, and atomi-

cally, that is, the operations are performed either as a complete unit, or not

at all. The behavior of the system call if not all operations can be performed

immediately depends on the presence of the IPC_NOWAIT flag in the individual

sem_flg fields, as noted below.

Each operation is performed on the sem_num-th semaphore of the semaphore set,

where the first semaphore of the set is numbered 0. There are three types of

operation, distinguished by the value of sem_op.

If sem_op is a positive integer, the operation adds this value to the semaphore

value (semval). Furthermore, if SEM_UNDO is specified for this operation, the

system updates the process undo count (semadj) for this semaphore. This opera-

tion can always proceed — it never forces a process to wait. The calling pro-

cess must have alter permission on the semaphore set.

If sem_op is zero, the process must have read permission on the semaphore set.

This is a "wait-for-zero" operation: if semval is zero, the operation can imme-

diately proceed. Otherwise, if IPC_NOWAIT is specified in sem_flg, semop()

fails with errno set to EAGAIN (and none of the operations in sops is per-

formed). Otherwise semzcnt (the count of processes waiting until this

semaphore's value becomes zero) is incremented by one and the process sleeps

until one of the following occurs:

· semval becomes 0, at which time the value of semzcnt is decremented.

· The semaphore set is removed: semop() fails, with errno set to EIDRM.

· The calling process catches a signal: the value of semzcnt is decremented and

semop() fails, with errno set to EINTR.

· The time limit specified by timeout in a semtimedop() call expires: semop()

fails, with errno set to EAGAIN.

If sem_op is less than zero, the process must have alter permission on the

semaphore set. If semval is greater than or equal to the absolute value of

sem_op, the operation can proceed immediately: the absolute value of sem_op is

subtracted from semval, and, if SEM_UNDO is specified for this operation, the

system updates the process undo count (semadj) for this semaphore. If the abso-

lute value of sem_op is greater than semval, and IPC_NOWAIT is specified in

sem_flg, semop() fails, with errno set to EAGAIN (and none of the operations in

sops is performed). Otherwise semncnt (the counter of processes waiting for

this semaphore's value to increase) is incremented by one and the process sleeps

until one of the following occurs:

· semval becomes greater than or equal to the absolute value of sem_op, at

which time the value of semncnt is decremented, the absolute value of sem_op

is subtracted from semval and, if SEM_UNDO is specified for this operation,

the system updates the process undo count (semadj) for this semaphore.

· The semaphore set is removed from the system: semop() fails, with errno set

to EIDRM.

· The calling process catches a signal: the value of semncnt is decremented and

semop() fails, with errno set to EINTR.

· The time limit specified by timeout in a semtimedop() call expires: the sys-

tem call fails, with errno set to EAGAIN.

On successful completion, the sempid value for each semaphore specified in the

array pointed to by sops is set to the process ID of the calling process. In

addition, the sem_otime is set to the current time.

semtimedop() behaves identically to semop() except that in those cases were the

calling process would sleep, the duration of that sleep is limited by the amount

of elapsed time specified by the timespec structure whose address is passed in

the timeout argument. If the specified time limit has been reached, semtime-

dop() fails with errno set to EAGAIN (and none of the operations in sops is per-

formed). If the timeout argument is NULL, then semtimedop() behaves exactly

like semop().

RETURN VALUE

If successful semop() and semtimedop() return 0; otherwise they return -1 with

errno indicating the error.

ERRORS

On failure, errno is set to one of the following:

E2BIG The argument nsops is greater than SEMOPM, the maximum number of opera-

tions allowed per system call.

EACCES The calling process does not have the permissions required to perform the

specified semaphore operations, and does not have the CAP_IPC_OWNER capa-

bility.

EAGAIN An operation could not proceed immediately and either IPC_NOWAIT was

specified in sem_flg or the time limit specified in timeout expired.

EFAULT An address specified in either the sops or the timeout argument isn't

accessible.

EFBIG For some operation the value of sem_num is less than 0 or greater than or

equal to the number of semaphores in the set.

EIDRM The semaphore set was removed.

EINTR While blocked in this system call, the process caught a signal; see sig-

nal(7).

EINVAL The semaphore set doesn't exist, or semid is less than zero, or nsops has

a non-positive value.

ENOMEM The sem_flg of some operation specified SEM_UNDO and the system does not

have enough memory to allocate the undo structure.

ERANGE For some operation sem_op+semval is greater than SEMVMX, the implementa-

tion dependent maximum value for semval.

VERSIONS

semtimedop() first appeared in Linux 2.5.52, and was subsequently backported

into kernel 2.4.22. Glibc support for semtimedop() first appeared in version

2.3.3.

CONFORMING TO

SVr4, POSIX.1-2001.

NOTES

The sem_undo structures of a process aren't inherited by the child produced by

fork(2), but they are inherited across an execve(2) system call.

semop() is never automatically restarted after being interrupted by a signal

handler, regardless of the setting of the SA_RESTART flag when establishing a

signal handler.

semadj is a per-process integer which is simply the (negative) count of all

semaphore operations performed specifying the SEM_UNDO flag. When a semaphore's

value is directly set using the SETVAL or SETALL request to semctl(2), the cor-

responding semadj values in all processes are cleared.

The semval, sempid, semzcnt, and semnct values for a semaphore can all be

retrieved using appropriate semctl(2) calls.

The following limits on semaphore set resources affect the semop() call:

SEMOPM Maximum number of operations allowed for one semop() call (32) (on Linux,

this limit can be read and modified via the third field of /proc/sys/ker-

nel/sem).

SEMVMX Maximum allowable value for semval: implementation dependent (32767).

The implementation has no intrinsic limits for the adjust on exit maximum value

(SEMAEM), the system wide maximum number of undo structures (SEMMNU) and the

per-process maximum number of undo entries system parameters.

BUGS

When a process terminates, its set of associated semadj structures is used to

undo the effect of all of the semaphore operations it performed with the

SEM_UNDO flag. This raises a difficulty: if one (or more) of these semaphore

adjustments would result in an attempt to decrease a semaphore's value below

zero, what should an implementation do? One possible approach would be to block

until all the semaphore adjustments could be performed. This is however unde-

sirable since it could force process termination to block for arbitrarily long

periods. Another possibility is that such semaphore adjustments could be

ignored altogether (somewhat analogously to failing when IPC_NOWAIT is specified

for a semaphore operation). Linux adopts a third approach: decreasing the

semaphore value as far as possible (i.e., to zero) and allowing process termina-

tion to proceed immediately.

In kernels 2.6.x, x <= 10, there is a bug that in some circumstances prevents a

process that is waiting for a semaphore value to become zero from being woken up

when the value does actually become zero. This bug is fixed in kernel 2.6.11.

EXAMPLE

The following code segment uses semop() to atomically wait for the value of

semaphore 0 to become zero, and then increment the semaphore value by one.

struct sembuf sops[2];

int semid;

/* Code to set semid omitted */

sops[0].sem_num = 0; /* Operate on semaphore 0 */

sops[0].sem_op = 0; /* Wait for value to equal 0 */

sops[0].sem_flg = 0;

sops[1].sem_num = 0; /* Operate on semaphore 0 */

sops[1].sem_op = 1; /* Increment value by one */

sops[1].sem_flg = 0;

if (semop(semid, sops, 2) == -1) {

perror("semop");

exit(EXIT_FAILURE);

}

SEE ALSO

semctl(2), semget(2), sigaction(2), capabilities(7), sem_overview(7), svipc(7),

time(7)

COLOPHON

This page is part of release 3.22 of the Linux man-pages project. A description

of the project, and information about reporting bugs, can be found at

http://www.kernel.org/doc/man-pages/.

该函数里：函数的原型：

int semop(int semid, struct sembuf *sops, unsigned nsops);

该函数的功能是操作信号量，通常是以集合出现的。

需要的头文件：

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

该函数的返回值：成功返回0，失败返回-1.

参数说明：

semid:要操作的信号量集合的标示符。

nsops:要操作多少个信号量。

Sops:对信号量执行的操作：是获取还是释放。获取-1，释放+1.Sem_op:正数是释放，负数是获取。如果获取不成功则会进入等待状态。

实例：

semaphoreA.c:

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <sys/ipc.h>

#include <sys/sem.h>

void main(){

//open file

int fd = 0;

key_t key;

int semid;

struct sembuf sops;

key = ftok("/home",1);

//create semaphore

semid = semget(key,1,IPC_CREAT);

fd = open("/home/wen",O_RDWR|O_APPEND);

//get semaphore

sops.sem_num = 0;

sops.sem_op = -1;

semop(semid,&sops, 1);

//write something into file

write(fd,"forfish!",8);

//rest

sleep(10);

//write something else.

write(fd,"is die!",7);

//free semaphore

sops.sem_num = 0;

sops.sem_op = 1;

semop(semid,&sops, 1);

close(fd);

}

semaphoreB.c：

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <sys/ipc.h>

#include <sys/sem.h>

void main(){

int fd = 0;

key_t key;

int semid;

struct sembuf sops;

key = ftok("/home",1);

semid = semget(key,1,IPC_CREAT);

//open sem

fd = open("/home/wen",O_RDWR|O_APPEND);

sops.sem_num = 0;

sops.sem_op = -1;

semop(semid,&sops, 1);

write(fd,"fish!",5);

sops.sem_num = 0;

sops.sem_op = 1;

semop(semid,&sops, 1);

close(fd);

}

编译运行：

结果看不见B等待，结果：

还是没能实现！这是因为我们忽略了信号量的初始值。我们在操作之前应该确保信号量的值是1.所以接下来就是设置我们的信号量为1.

设置信号量：

在命令行:man 2 semctl:

NAME

semctl - semaphore control operations

SYNOPSIS

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

int semctl(int semid, int semnum, int cmd, ...);

DESCRIPTION

semctl() performs the control operation specified by cmd on the semaphore set

identified by semid, or on the semnum-th semaphore of that set. (The semaphores

in a set are numbered starting at 0.)

This function has three or four arguments, depending on cmd. When there are

four, the fourth has the type union semun. The calling program must define this

union as follows:

union semun {

int val; /* Value for SETVAL */

struct semid_ds *buf; /* Buffer for IPC_STAT, IPC_SET */

unsigned short *array; /* Array for GETALL, SETALL */

struct seminfo *__buf; /* Buffer for IPC_INFO

(Linux-specific) */

};

The semid_ds data structure is defined in <sys/sem.h> as follows:

struct semid_ds {

struct ipc_perm sem_perm; /* Ownership and permissions */

time_t sem_otime; /* Last semop time */

time_t sem_ctime; /* Last change time */

unsigned short sem_nsems; /* No. of semaphores in set */

};

The ipc_perm structure is defined in <sys/ipc.h> as follows (the highlighted

fields are settable using IPC_SET):

struct ipc_perm {

key_t __key; /* Key supplied to semget(2) */

uid_t uid; /* Effective UID of owner */

gid_t gid; /* Effective GID of owner */

uid_t cuid; /* Effective UID of creator */

gid_t cgid; /* Effective GID of creator */

unsigned short mode; /* Permissions */

unsigned short __seq; /* Sequence number */

};

Valid values for cmd are:

IPC_STAT Copy information from the kernel data structure associated with semid

into the semid_ds structure pointed to by arg.buf. The argument sem-

num is ignored. The calling process must have read permission on the

semaphore set.

IPC_SET Write the values of some members of the semid_ds structure pointed to

by arg.buf to the kernel data structure associated with this semaphore

set, updating also its sem_ctime member. The following members of the

structure are updated: sem_perm.uid, sem_perm.gid, and (the least sig-

nificant 9 bits of) sem_perm.mode. The effective UID of the calling

process must match the owner (sem_perm.uid) or creator (sem_perm.cuid)

of the semaphore set, or the caller must be privileged. The argument

semnum is ignored.

IPC_RMID Immediately remove the semaphore set, awakening all processes blocked

in semop(2) calls on the set (with an error return and errno set to

EIDRM). The effective user ID of the calling process must match the

creator or owner of the semaphore set, or the caller must be privi-

leged. The argument semnum is ignored.

IPC_INFO (Linux-specific)

Returns information about system-wide semaphore limits and parameters

in the structure pointed to by arg.__buf. This structure is of type

seminfo, defined in <sys/sem.h> if the _GNU_SOURCE feature test macro

is defined:

struct seminfo {

int semmap; /* Number of entries in semaphore

map; unused within kernel */

int semmni; /* Maximum number of semaphore sets */

int semmns; /* Maximum number of semaphores in all

semaphore sets */

int semmnu; /* System-wide maximum number of undo

structures; unused within kernel */

int semmsl; /* Maximum number of semaphores in a

set */

int semopm; /* Maximum number of operations for

semop(2) */

int semume; /* Maximum number of undo entries per

process; unused within kernel */

int semusz; /* Size of struct sem_undo */

int semvmx; /* Maximum semaphore value */

int semaem; /* Max. value that can be recorded for

semaphore adjustment (SEM_UNDO) */

};

The semmsl, semmns, semopm, and semmni settings can be changed via

/proc/sys/kernel/sem; see proc(5) for details.

SEM_INFO (Linux-specific)

Returns a seminfo structure containing the same information as for

IPC_INFO, except that the following fields are returned with informa-

tion about system resources consumed by semaphores: the semusz field

returns the number of semaphore sets that currently exist on the sys-

tem; and the semaem field returns the total number of semaphores in

all semaphore sets on the system.

SEM_STAT (Linux-specific)

Returns a semid_ds structure as for IPC_STAT. However, the semid

argument is not a semaphore identifier, but instead an index into the

kernel's internal array that maintains information about all semaphore

sets on the system.

GETALL Return semval (i.e., the current value) for all semaphores of the set

into arg.array. The argument semnum is ignored. The calling process

must have read permission on the semaphore set.

GETNCNT The system call returns the value of semncnt (i.e., the number of pro-

cesses waiting for the value of this semaphore to increase) for the

semnum-th semaphore of the set (i.e., the number of processes waiting

for an increase of semval for the semnum-th semaphore of the set).

The calling process must have read permission on the semaphore set.

GETPID The system call returns the value of sempid for the semnum-th

semaphore of the set (i.e., the PID of the process that executed the

last semop(2) call for the semnum-th semaphore of the set). The call-

ing process must have read permission on the semaphore set.

GETVAL The system call returns the value of semval for the semnum-th

semaphore of the set. The calling process must have read permission

on the semaphore set.

GETZCNT The system call returns the value of semzcnt (i.e., the number of pro-

cesses waiting for the value of this semaphore to become zero) for the

semnum-th semaphore of the set (i.e., the number of processes waiting

for semval of the semnum-th semaphore of the set to become 0). The

calling process must have read permission on the semaphore set.

SETALL Set semval for all semaphores of the set using arg.array, updating

also the sem_ctime member of the semid_ds structure associated with

the set. Undo entries (see semop(2)) are cleared for altered

semaphores in all processes. If the changes to semaphore values would

permit blocked semop(2) calls in other processes to proceed, then

those processes are woken up. The argument semnum is ignored. The

calling process must have alter (write) permission on the semaphore

set.

SETVAL Set the value of semval to arg.val for the semnum-th semaphore of the

set, updating also the sem_ctime member of the semid_ds structure

associated with the set. Undo entries are cleared for altered

semaphores in all processes. If the changes to semaphore values would

permit blocked semop(2) calls in other processes to proceed, then

those processes are woken up. The calling process must have alter

permission on the semaphore set.

RETURN VALUE

On failure semctl() returns -1 with errno indicating the error.

Otherwise the system call returns a non-negative value depending on cmd as fol-

lows:

GETNCNT the value of semncnt.

GETPID the value of sempid.

GETVAL the value of semval.

GETZCNT the value of semzcnt.

IPC_INFO the index of the highest used entry in the kernel's internal array

recording information about all semaphore sets. (This information

can be used with repeated SEM_STAT operations to obtain information

about all semaphore sets on the system.)

SEM_INFO As for IPC_INFO.

SEM_STAT the identifier of the semaphore set whose index was given in semid.

All other cmd values return 0 on success.

ERRORS

On failure, errno will be set to one of the following:

EACCES The argument cmd has one of the values GETALL, GETPID, GETVAL, GETNCNT,

GETZCNT, IPC_STAT, SEM_STAT, SETALL, or SETVAL and the calling process

does not have the required permissions on the semaphore set and does not

have the CAP_IPC_OWNER capability.

EFAULT The address pointed to by arg.buf or arg.array isn't accessible.

EIDRM The semaphore set was removed.

EINVAL Invalid value for cmd or semid. Or: for a SEM_STAT operation, the index

value specified in semid referred to an array slot that is currently

unused.

EPERM The argument cmd has the value IPC_SET or IPC_RMID but the effective user

ID of the calling process is not the creator (as found in sem_perm.cuid)

or the owner (as found in sem_perm.uid) of the semaphore set, and the

process does not have the CAP_SYS_ADMIN capability.

ERANGE The argument cmd has the value SETALL or SETVAL and the value to which

semval is to be set (for some semaphore of the set) is less than 0 or

greater than the implementation limit SEMVMX.

CONFORMING TO

SVr4, POSIX.1-2001.

NOTES

The IPC_INFO, SEM_STAT and SEM_INFO operations are used by the ipcs(8) program

to provide information on allocated resources. In the future these may modified

or moved to a /proc file system interface.

Various fields in a struct semid_ds were typed as short under Linux 2.2 and have

become long under Linux 2.4. To take advantage of this, a recompilation under

glibc-2.1.91 or later should suffice. (The kernel distinguishes old and new

calls by an IPC_64 flag in cmd.)

In some earlier versions of glibc, the semun union was defined in <sys/sem.h>,

but POSIX.1-2001 requires that the caller define this union. On versions of

glibc where this union is not defined, the macro _SEM_SEMUN_UNDEFINED is defined

in <sys/sem.h>.

The following system limit on semaphore sets affects a semctl() call:

SEMVMX Maximum value for semval: implementation dependent (32767).

For greater portability it is best to always call semctl() with four arguments.

SEE ALSO

ipc(2), semget(2), semop(2), capabilities(7), sem_overview(7), svipc(7)

COLOPHON

This page is part of release 3.22 of the Linux man-pages project. A description

of the project, and information about reporting bugs, can be found at

http://www.kernel.org/doc/man-pages/.

该函数的原型：

int semctl(int semid, int semnum, int cmd, ...);

第一个参数是要操作信号量的集合，第二个是集合里的第几个信号，第三个参数是命令，即是进行的操作：

GETNCNT the value of semncnt.

GETPID the value of sempid.

GETVAL the value of semval.

GETZCNT the value of semzcnt.

IPC_INFO the index of the highest used entry in the kernel's internal array

recording information about all semaphore sets. (This information

can be used with repeated SEM_STAT operations to obtain information

about all semaphore sets on the system.)

SEM_INFO As for IPC_INFO.

SEM_STAT the identifier of the semaphore set whose index was given in semid.

返回值就是信号量的值。

semaphoreA.c：

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <sys/ipc.h>

#include <sys/sem.h>

void main(){

//open file

int fd = 0;

key_t key;

int semid;

struct sembuf sops;

int temp;

key = ftok("/home",1);

//create semaphore

semid = semget(key,1,IPC_CREAT);

temp = semctl(semid,0,GETVAL);

printf("sem of init is %d ",temp);

fd = open("/home/wen",O_RDWR|O_APPEND);

//get semaphore

sops.sem_num = 0;

sops.sem_op = -1;

semop(semid,&sops, 1);

//write something into file

write(fd,"forfish!",8);

//rest

sleep(10);

//write something else.

write(fd,"is die!",7);

//free semaphore

sops.sem_num = 0;

sops.sem_op = 1;

semop(semid,&sops, 1);

close(fd);

}

运行的效果：

我们看到信号量的初值为2，所以我们上面才会失败。所以我们需要把信号量的初值设置为1.也是在semctl函数修改：

temp = semctl(semid,0,GETVAL,1);

最后的代码：

semaphoreA.c：

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <sys/ipc.h>

#include <sys/sem.h>

void main(){

//open file

int fd = 0;

key_t key;

int semid;

struct sembuf sops;

int temp;

key = ftok("/home",1);

//create semaphore

semid = semget(key,1,IPC_CREAT);

temp = semctl(semid,0,SETVAL,1);

printf("sem of init is %d ",temp);

fd = open("/home/wen",O_RDWR|O_APPEND);

//get semaphore

sops.sem_num = 0;

sops.sem_op = -1;

semop(semid,&sops, 1);

//write something into file

write(fd,"forfish!",8);

//rest

sleep(10);

//write something else.

write(fd,"is die!",7);

//free semaphore

sops.sem_num = 0;

sops.sem_op = 1;

semop(semid,&sops, 1);

close(fd);

}

semaphoreB.c:

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <sys/ipc.h>

#include <sys/sem.h>

void main(){

int fd = 0;

key_t key;

int semid;

struct sembuf sops;

int temp;

key = ftok("/home",1);

semid = semget(key,1,IPC_CREAT);

//open sem

temp = semctl(semid,0,GETVAL,1);

printf("sem of value is %d ",temp);

fd = open("/home/wen",O_RDWR|O_APPEND);

sops.sem_num = 0;

sops.sem_op = -1;

semop(semid,&sops, 1);

write(fd,"fish!",5);

sops.sem_num = 0;

sops.sem_op = 1;

semop(semid,&sops, 1);

close(fd);

}

运行结果：

写入的结果：

可以看到现在两个进程往同一个文件写入内容就不会混乱了。这是因为我们设置了初始的信号量是1，当semaphoreA往里面写东西，然后休息10秒，由于在这段时间，信号量被A占有着，没有释放。所以即使B想往该文件写入内容。因为此时被A占有着，信号量为0，此时B只能等待。我们看到执行中，B确实在等待。直到A写完成，释放了信号量。B才能占有信号量，往文件写内容。显示的结果和我们想要的一样。操作成功。