用ipcs调试共享内存
测试源程序如下:
#include
#include
#include
#include
#include
#include
#include
void error_out(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
int main (int argc, char *argv[])
{
key_t mykey = 12345678;
const size_t region_size = sysconf(_SC_PAGE_SIZE);
int smid = shmget(mykey, region_size, IPC_CREAT|0666);
if(smid == -1)
error_out("shmget");
void *ptr;
ptr = shmat(smid, NULL, 0);
if (ptr == (void *) -1)
error_out("shmat");
pid_t pid = fork();
if (pid == 0){
u_long *d = (u_long *)ptr;
*d = 0xdeadbeef;
exit(0);
}
else{
int status;
waitpid(pid, &status, 0);
printf("child wrote %#lx\n", *(u_long *)ptr);
}
sleep(30);
int r = shmdt(ptr);
if (r == -1)
error_out("shmdt");
r = shmctl(smid, IPC_RMID, NULL);
if (r == -1)
error_out("shmdt");
return 0;
}
编译:
gcc smem.c -o smem
注:这个程序会申请共享内存,父子进程都会向共享内存写数据,达到IPC通讯的目的.
终端1)
./smem
child wrote 0xdeadbeef
终端2)
ipcs -m
------ Shared Memory Segments --------
key shmid owner perms bytes nattch status
0x00bc614e 18874397 root 666 4096 1
注:
key栏中列出的信息是应用程序定义的键值,如果是私有对象的键值则为0,在这里我们定义键值为12345678,也就是输出的0x00bc614e(十六进制)
shmid栏中列出共享内存的ID,这个值是唯一的.
owner栏中列出创建共享内存的用户是root.
perms栏中列出共享内存的权限.
bytes栏中列出这块共享内存的大小,我们通过调用sysconf(_SC_PAGE_SIZE)得到要创建的共享内存大小为4096个字节.
nattch栏中列出连接在关联的共享内存段的进程数.
status栏中列出当前共享内存的状态,当该段内存的mode字段设置了SHM_DEST位时就会显示"dest"字样,
当用户调用shmctl的IPC_RMID时,内核首先看有多少个进程还和这段内存关联着,如果关联数为0,就会销毁(释放)这段内存,否则就设置这段内存的mode位SHM_DEST,
并设置它的key为IPC_PRIVATE,这意味着关联着的进程仍可合法存取这端内存,但是它不能再被新的进程关联了.
在上面的输出中,我们没有看到smem用到的共享内存有dest的状态,而此时我们用ipcrm -m 18874397手工删除该段共享内存时,
此时该段的共享内存键值将会是0x00000000(IPC_PRIVATE),而程序通过调用shmdt来释放该段共享内存时,这段共享内存才会真正的消失.
为完成这个测试,我们修改上面的程序,在shmdt()后面增加:
printf("shmdt function run finished\n");
sleep(30);
在shmctl函数后面增加:
printf("shmctl function run finished\n");
终端1,重新编译,运行
gcc smem.c -o smem
./smem
child wrote 0xdeadbeef
终端2
运行ipcs -m查看共享内存,程序进入第一个sleep(30);,此时status为空
ipcs -m
------ Shared Memory Segments --------
key shmid owner perms bytes nattch status
0x00bc614e 0 root 666 4096 1
删除shmid为32768的共享内存,此时status为dest,而key变为0x00000000
ipcrm -m 32768
------ Shared Memory Segments --------
key shmid owner perms bytes nattch status
0x00000000 32768 root 666 4096 1 dest
过30秒后,此时程序运行了shmdt函数释放共享内存,我们用ipcs -m再看不到该共享内存,虽然它没有运行到shmctl(smid, IPC_RMID, NULL);
最后smem再过30秒后,运行了shmctl(smid, IPC_RMID, NULL);删除共享内存,这时会报错shmdt: Invalid argument,因为我们手工删除了共享内存,
又程序到最后再去删除共享内存,所以报错.
我们通过ipcs -mi 32768可以看到更详细的信息,如下:
Shared memory Segment shmid=327680
uid=0 gid=0 cuid=0 cgid=0
mode=0666 access_perms=0666
bytes=4096 lpid=3263 cpid=3263 nattch=0
att_time=Mon Mar 14 09:42:52 2011
det_time=Mon Mar 14 09:43:22 2011
change_time=Mon Mar 14 09:42:52 2011
注:
cuid=0代表创建这个共享内存的用户ID为0
cgid=0代表创建这个共享内存的组ID为0
lpid=3263代表最后一次访问这个共享内存段的PID为3263
cpid=3263代表最后一产创建这个共享内存段的PID为3263
att_time=Mon Mar 14 09:42:52 2011代表最后一次调用shmat()的时间
det_time=Mon Mar 14 09:43:22 2011代表最后一次调用shmdt()的时间
change_time=Mon Mar 14 09:42:52 2011代表最后一次用shmctl()修改共享内存段的时间.
最后system v共享内存的最大值可以通过修改/proc/sys/kernel/shmmax进行调整.
2)system v系统消息队列
用ipcs调试消息队列.
测试源程序如下:
#include
#include
#include
#include
#include
#include
#include
#include
#include
struct message {
long int mtype;
char mtext[128];
};
int send_msg(int qid, int mtype, const char text[]){
struct message msg = {
.mtype = mtype
};
strncpy (msg.mtext, text, sizeof(msg.mtext));
int r = msgsnd(qid, &msg, sizeof(msg), 0);
if (r == -1){
perror("msgsnd");
}
}
void producer(int mqid)
{
send_msg(mqid, 1, "type 1 - first");
send_msg(mqid, 2, "type 2 - second");
send_msg(mqid, 1, "type 1 - third");
}
void consumer(int qid)
{
struct message msg;
int r;
int i;
for (i = 0;i<3; i++){
r = msgrcv(qid, &msg, sizeof(struct message), -2, 0);
printf("'%s'\n", msg.mtext);
}
}
int main (int argc, char *argv[])
{
int mqid;
mqid = msgget (IPC_PRIVATE, S_IREAD|S_IWRITE);
if (mqid == -1) {
perror("msgget");
exit (1);
}
pid_t pid = fork();
if (pid == 0){
sleep(60);
consumer(mqid);
exit (0);
}
else{
int status;
producer(mqid);
wait(&status);
}
int r = msgctl(mqid, IPC_RMID, 0);
if (r)
perror("msgctl");
return 0;
}
编译mesg.c
gcc mesg.c -o mesg
注:这个程序中,父进程会将三条消息发送到消息队列,子进程在等待60秒后,再收接消息.
在60秒中,消息存在于消息队列,以便于我们查看.
执行mesg
./mesg&
ipcs -q
------ Message Queues --------
key msqid owner perms used-bytes messages
0x00000000 229376 root 600 408 3
注:
key栏中列出的信息是应用程序定义的键值.
msgid栏中列出的值是系统定义的键值.
正如所期望的,系统定义的键值是唯一的,而在本例中应用程序定义的键值全部是0,这意味着这些消息队列是使用IPC_PRIVATE键值创建的.
owner栏中列出创建消息队列的用户是root.
perms栏中列出这个消息队列的权限.
used-bytes栏中列出这个消息队列所占用的空间大小,在这里我们的结构体:
struct message {
long int mtype;
char mtext[128];
};
long int mtype占用8个字节,因为它是64位系统,如果是32位系统,它占用的字节为4个,
char mtext[128]占用128个字节,也就是一条消息就是136,三条消息正好是408.
messages栏中列出这条消息队列中有几条消息,我们发送了三条消息,所以这里正好是3.
用ipcs -q -i PID的方式可以看到更详细的信息,如下面:
ipcs -q -i 294912
Message Queue msqid=294912
uid=0 gid=0 cuid=0 cgid=0 mode=0600
cbytes=408 qbytes=16384 qnum=3 lspid=4036 lrpid=0
send_time=Fri Mar 11 20:52:21 2011
rcv_time=Not set
change_time=Fri Mar 11 20:52:21 2011
注:
cuid一栏列出创建这个消息队列的用户ID
cgid一栏列出创建这个消息队列的组ID
qbytes一栏列出SYSTEM V消息队列的最大值,可以通过修改/proc/sys/kernel/msgmnb和/proc/sys/kernel/msgmax进行调整.
lspid一栏列出最后一个发送消息到这个消息队列的进程.
lrpid一栏列出最后一个从这个消息队列接收消息的进程.
send_time一栏列出发送消息到这个消息队列的最后时间.
rcv_time一栏列出从这个消息队列接收消息的最后时间.
change_time一栏列出更改这个消息队列的最后时间.
最后可以用ipcrm -q 来删除消息队列
3)system v系统的信号量
用ipcs调试信号量
测试源程序如下:
#include
#include
#include
#include
#include
#include
#include
#include
int
main (int argc, char *argv[])
{
key_t semkey = ftok("/tmp", 'a');
int semid =
semget(semkey, 1, IPC_CREAT|IPC_EXCL|S_IRUSR|S_IWUSR);
if(semid != -1){
printf("Created new semaphore\n");
}
else
if(errno == EEXIST){
printf("semaphore exists\n");
semid = semget(semkey, 1, 0);
}
assert(semid != -1);
if (argc == 2){
int op = atoi(argv[1]);
struct sembuf sb={
.sem_num = 0,
.sem_op = op,
.sem_{敏感词} = 0
};
int r = semop (semid,&sb,1);
assert(r != -1);
printf("Operation %d done\n", op);
}
else {
printf("no operation \n");
}
printf("semid %d value %d\n", semid ,semctl(semid,0,GETVAL));
return 0;
}
编译sysv_sem.c
gcc sysv_sem.c -o sysv_sem
注:
这个程序通过semget函数创建了一个信号量集,semop函数操作了信号量集中的一个集号,这样来增加或减少信号量中含的值,从而达到程序同步和资源互斥的目的.
执行程序,此时创建了一个信号量,初始值.sem_num为0,所以它通过semctl函数获取的值为0.
./sysv_sem 0
Created new semaphore
Operation 0 done
semid 196608 value 0
执行程序,将参数换成1,此时它的值为1,如下:
./sysv_sem 1
semaphore exists
Operation 1 done
semid 196608 value 1
用ipcs -s来查看信号量信息,如下:
ipcs -s
------ Semaphore Arrays --------
key semid owner perms nsems
0x61018001 196608 root 600 1
注:
key栏中列出的信息是应用程序定义的键值,这里我们用ftok来生成它的ID.
semid栏中列出系统定义的键值.
owner栏中列出创建该信号量集的用户是root
perms栏中列出这个信号量集的权限.
nsems栏中列出这个信号量集中指定了多少个信号量,我们的例子中指定了1个,可以通过semget函数指定多个,如:
segmet(semkey, 5, IPC_CREAT|IPC_EXCL|S_IRUSR|S_IWUSR);
这样就在这个信号集中指定了5个信号量.
用-i参数可以看到更详细的信息,如下;
ipcs -s -i 196608
Semaphore Array semid=196608
uid=0 gid=0 cuid=0 cgid=0
mode=0600, access_perms=0600
nsems = 1
otime = Tue Mar 15 11:44:49 2011
ctime = Tue Mar 15 11:43:38 2011
semnum value ncount zcount pid
0 1 0 0 2791
注:
cuid=0列出创建这个信号量集的用户ID.
cgid=0列出创建这个信号量集的组ID.
mode=0600列出创建这个信号量集时的权限.
access_perms=0600列出这个信号量集的访问权限.
otime = Tue Mar 15 11:44:49 2011列出这个信号量集的访问操作时间,如semop函数对信号量集的操作.
ctime = Tue Mar 15 11:43:38 2011列出这个信号量集的创建时间,如semget函数创建这个信号量集.
semnum列出了信号量集中信号量的序列,如果我们在semget函数中指定了两个信号量,这里的输出,将会是下面的信息:
semnum value ncount zcount pid
0 8 0 0 3270
1 0 0 0 0
ncount列出等待信号量增加的进程的个数.
例如我们指定op为负值,此时负值的绝对值大于当前的信号量值,这时将会阻塞,也就是等待资源的进程数会增加,如下:
./sysv_sem -6
semaphore exists
此时阻塞.
我们在另一个终端下查看当前的信号量集,如下:
ipcs -s -i 425984
Semaphore Array semid=425984
uid=0 gid=0 cuid=0 cgid=0
mode=0600, access_perms=0600
nsems = 2
otime = Tue Mar 15 12:14:06 2011
ctime = Tue Mar 15 12:08:15 2011
semnum value ncount zcount pid
0 0 1 0 3337
1 0 0 0 0
此时等待信号量增加的进程个数为1,即ncount为1,表示有一个进程等待信号量值增加.
zcount列出正在等待信号量变成零的进程的个数
例如我们使当前的信号量值大于0,此时指定op的值为0,这时将会阻塞,直到这个信号量变为0,在阻塞期间等待信号量变成零的进程个数就是zcount,如下:
增加信号量值为1.
./sysv_sem 1
semaphore exists
Operation 1 done
semid 425984 value 0
再次运行sysv_sem程序,指定op为0
./sysv_sem 0
semaphore exists
此时阻塞.
我们在另一个终端查看当前的信号量集,如下:
ipcs -s -i 425984
Semaphore Array semid=425984
uid=0 gid=0 cuid=0 cgid=0
mode=0600, access_perms=0600
nsems = 2
otime = Tue Mar 15 12:23:19 2011
ctime = Tue Mar 15 12:08:15 2011
semnum value ncount zcount pid
0 1 0 1 3499
1 0 0 0 0
此时等待信号量变成零的进程个数为1,即zcount为1,表示有一个进程等待信号量值变为零.
最后我们可以修改/proc/sys/kernel/sem,来达到修改信号量最大数及相关限制的目的.
例如:
cat /proc/sys/kernel/sem
250 32000 32 128
第一列,表示每个信号集中的最大信号量数目.
第二列,表示系统范围内的最大信号量总数目.
第三列,表示每个信号发生时的最大系统操作数目.
第四列,表示系统范围内的最大信号集总数目.
