linux命令详解--ipcs和ipcrm

ipcs和ipcrm用法简介

命令名称：ipcs

使用权限：所有使用者

使用方式：

ipcs [-m|-q|-s]

-m       输出有关共享内存(shared memory)的信息

-q       输出有关信息队列(message queue)的信息

-s       输出有关“遮断器”(semaphore)的信息

命令名称：ipcrm

使用权限：所有使用者

使用方式：

ipcrm [ -M key | -m id | -Q key | -q id | -S key | -s id ] ...

说明：删除消息队列、共享内存、信号灯

参数：

-M   以shmkey删除共享内存

-m   以shmid删除共享内存

-Q   以msgkey删除消息队列

-q    以msgid删除消息队列

-S    以semkey删除信号灯

-s    以semid删除信号灯

设定HP-UX的核心环境，对核心环境进行管理。但修改后不能立即对核心参数进行管理。
因为系统会向boot.config读出参数，所以只有移走boot.config，然后再用getkinfo
重建boot.config文件。在SAM--》Kernel configuration--> Parameter会自动运行
getkinfo 命令。

先修改/usr/conf/master.d/core-hpux：

*range maxfiles<=60000
*range maxfiles_lim<=60000

把/var/sam/boot.config文件mv成boot.config.bak

mv /var/sam/boot.config /var/sam/boot.config.bak

然后运行

/usr/sam/lbin/getkinfo -b

 

vmstat 是用来实时查看内存使用情况,反映的情况比用top直观一些.
如果直接使用,只能得到当前的情况,最好用个时间间隔来采集
vmstat T 其中T用具体的时间标示,单位是 秒 例如:vmstat 5 表格每隔5秒采集一次.
这样在刷新的时候就能比较系统的看到那个列不正常的
procs:
r-->;在运行队列中等待的进程数
b-->;在等待io的进程数
w-->;可以进入运行队列但被替换的进程

memoy
swap-->;现时可用的交换内存（k表示）
free-->;空闲的内存（k表示）

pages
re－－》回收的页面
mf－－》非严重错误的页面
pi－－》进入页面数（k表示）
po－－》出页面数（k表示）
fr－－》空余的页面数（k表示）
de－－》提前读入的页面中的未命中数
sr－－》通过时钟算法扫描的页面

disk 显示每秒的磁盘操作。 s表示scsi盘，0表示盘号

fault 显示每秒的中断数
in－－》设备中断
sy－－》系统中断
cy－－》cpu交换

cpu 表示cpu的使用状态
cs－－》用户进程使用的时间
sy－－》系统进程使用的时间
id－－》cpu空闲的时间

其中:
如果 r经常大于 4 ，且id经常少于40，表示cpu的负荷很重。
如果pi，po 长期不等于0，表示内存不足。
如果disk 经常不等于0， 且在 b中的队列 大于3， 表示 io性能不好。

 

ipcs命令和ipcrm命令
===========================================================
作者: edeed(http://edeed.itpub.net)
发表于:2007.04.27 17:11
分类: Unix
出处：http://edeed.itpub.net/post/679/283978
---------------------------------------------------------------

ipcs：check the shared memory allocation on a system
ipcrm：manually deallocate shared memory on a system
取得ipc信息：
ipcs [-m|-q|-s]
-m 输出有关共享内存(shared memory)的信息
-q 输出有关信息队列(message queue)的信息
-s 输出有关“遮断器”(semaphore)的信息
# ipcs -m
IPC status from as of 2007年04月10日 星期二 18时32分18秒 CST
T ID KEY MODE OWNER GROUP
Shared Memory:
m 0 0x50000d43 --rw-r--r-- root root
m 501 0x1e90c97c --rw-r----- oracle dba
#ipcs |grep oracle|awk '{print $2}
501

删除ipc(清除共享内存信息)
ipcrm -m|-q|-s shm_id
%ipcrm -m 501
for i in `ipcs |grep oracle|awk '{print $2}'`
do
ipcrm -m $i
ipcrm -s $i
done

ps -ef|egrep "ora_|asm_"|grep -v grep |grep -v crs|awk '{print $2}' |xargs kill -9

如何删除共享内存段?

问题描述

如何删除一个正处于删除暂停状态的全局共享内存段?

背景信息:

全局共享内存段正处于删除暂停状态:

# ipcs -mob | grep D
T      ID     KEY        MODE        OWNER GROUP NATTCH  SEGSZ
m   58382 0x00000000 D-rw-r-----   doracle dba     2 270606336

但是，shminfo 工具显示没有人在使用该段:

# ./shminfo -s 58382
libp4 (7.120): Opening /stand/vmunix /dev/kmem

从 /stand/vmunix 安装符号

shminfo (3.8)

Shmid 58382:
struct shmid_ds at 0x9dbd80
Pseudo vas at 0x68f84d00
Pseudo pregion at 0x9e296300
Shared region at 0xaf789c00
Segment at 0xf54c00.0xd7841000
Segment allocated out of "Global 32-bit quadrant 4"

使用SAM列出 Kernel参数与sysdef的比较

问题描述

我正在尝试确定为什么在 SAM 中看到的 Kernel 参数与运行
/usr/lbin/sysadm/system_prep -s system 时
生成的 "system" 文件存在差异。

例如，在 SAM 中我看到 "maxusers" 设置为了 32，但是
在 "system" 文件中却没有列出该参数。

SAM 使用的 "system’ 文件与在命令行手动创建新的 Kernel 时
system_prep 创建的 "system" 文件不同吗?

另外，为什么 sysdef 命令列出的 maxdsiz 和 maxdsz_64 值
与 SAM -> Kernel Configuration 中列出的值不同?

配置信息
10.X  11.X

解决方法

 system_prep

请运行下列命令:

       # /usr/lbin/sysadm/system_prep -s /tmp/system

       # more /tmp/system

unix/linux下的共享内存、信号量、队列信息管理
在unix/linux下，经常有因为共享内存、信号量，队列等共享信息没有干净地清楚而引起一些问题。
查看共享信息的内存的命令是ipcs [-m|-s|-q]。

默认会列出共享内存、信号量，队列信息，-m列出共享内存，-s列出共享信号量，-q列出共享队列
清除命令是ipcrm [-m|-s|-q] id。
-m 删除共享内存，-s删除共享信号量，-q删除共享队列。

[oracle@trade_as02 ~]$ ipcs -a
 
------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status     
0x30024289 32768      futures   777        528384     1                      
0xca2fd414 491521     oracle    640        1730150400 16                     
 
------ Semaphore Arrays --------
key        semid      owner      perms      nsems    
0x00028009 0          futures   666        1        
0x0002800c 32769      futures   666        1        
0x30024003 262146     futures   777        3        
0x3002428a 294915     futures   777        2        
0x3002428b 327684     futures   777        2        
0x3002428c 360453     futures   777        2        
0x3002428d 393222     futures   777        2        
0x3002428e 425991     futures   777        2        
0x52dff7d0 3964936    oracle    640        151      
0x52dff7d1 3997705    oracle    640        151      
0x52dff7d2 4030474    oracle    640        151      
0x52dff7d3 4063243    oracle    640        151      
0x52dff7d4 4096012    oracle    640        151      
 
------ Message Queues --------
key        msqid      owner      perms      used-bytes   messages

共享内存段有时不能马上删除，需使用这个内存段的所有进程向OS发送detach命令时才有释放，此时可以考虑删除进程使用的信号量,帮助释放共享内存段

 

 

 

关键知识：信号量、资源释放、 ipcs 、 ipcrm

信号量又称为信号灯，它是用来协调不同 进程 间的数据对象的，而最主要的应用是共享内存方式的 进程 间通信。本质 上，信号量是一个计数器，它用来记录对某个资源（如共享内存）的存取状况；共享内存是运行在同一台机器上的 进 程 间通信最快的方式，因为数据不需要在不同的 进程 间复制。通常由一个 进程 创建一块共享内存区，其余 进程 对这块 内存区进行读写。在 Linux 系统下 ， 常用的方式是通过 shmXXX 函数族来实现利用共享内存进行存储的。 如 Shmget ，类似于 malloc 函数

相关知识：
ipcs 可用来显示当前 Linux 系统中的共享内存段、信号量集、消息队列等的使用情况。
命令示例：
ipcs -a 或 ipc 显示当前系统中共享内存段、信号量集、消息队列的使用情况；
ipcs -m 显示共享内存段的使用情况；
ipcs -s 显示信号量集的使用情况；
ipcs -q 显示消息队列的使用情况；
ipcrm 可用来删除对应的共享内存段、信号量、消息队列；
命令示例：
ipcrm -s semid 删除对应的信号量集
ipcrm -m shmid 删除对应的共享内存段
ipcrm -q msqid 删除对应的消息队列
ipcrm 本身只能实现单个资源的删除，利用以下命令可实现批量删除（ zhangsj 版权所有，呵呵）：
1.ipcs -s|grep 用户名 |cut -d" " -f2|xargs -n1 ipcrm -s
2.ipcs -s|awk '/ 用户名 /{print $2}'|xargs -n1 ipcrm -s
3.ipcs -s|awk '/ 用户名 /{system("ipcrm -s "$2)}'
4.for i in echo `ipcs|grep 用户名 |cut -d" " -f2`; do ipcrm -s $i; done

1)system v系统共享内存

用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
第一列,表示每个信号集中的最大信号量数目.
第二列,表示系统范围内的最大信号量总数目.
第三列,表示每个信号发生时的最大系统操作数目.
第四列,表示系统范围内的最大信号集总数目.

进程间通信概述

进程间通信有如下的目的：1、数据传输，一个进程需要将它的数据发送给另一个进程，发送的数据量在一个字节到几M之间；2、共享数据，多个进程想要操作共享数据，一个进程对数据的修改，其他进程应该立刻看到；3、通知事件，一个进程需要向另一个或一组进程发送消息，通知它们发生了某件事情；4、资源共享，多个进程之间共享同样的资源。为了做到这一点，需要内核提供锁和同步机制；5、进程控制，有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

Linux进程间通信由以下几部分发展而来：

早期UNIX进程间通信：包括管道、FIFO、信号。

基于System V的进程间通信：包括System V消息队列、System V信号灯（Semaphore）、System V共享内存。

基于Socket进程间通信。

基于POSIX进程间通信：包括POSIX消息队列、POSIX信号灯、POSIX共享内存。

Linux中，与IPC相关的命令包括：ipcs、ipcrm（释放IPC）、

IPCS命令是Linux下显示进程间通信设施状态的工具。我们知道，系统进行进程间通信（IPC）的时候，可用的方式包括信号量、共享内存、消息队列、管道、信号（signal）、套接字等形式[2]。使用IPCS可以查看共享内存、信号量、消息队列的状态。

例如在CentOS6.0上执行ipcs

具体的用法总结如下：

1、显示所有的IPC设施

# ipcs -a

2、显示所有的消息队列Message Queue

# ipcs -q

3、显示所有的信号量

# ipcs -s

4、显示所有的共享内存

# ipcs -m

5、显示IPC设施的详细信息

# ipcs -q -i id

id 对应shmid、semid、msgid等。-q对应设施的类型（队列），查看信号量详细情况使用-s，查看共享内存使用-m。

6、显示IPC设施的限制大小

# ipcs -m -l

-m对应设施类型，可选参数包括-q、-m、-s。

7、显示IPC设施的权限关系

# ipcs -c

# ipcs -m -c

# ipcs -q -c

# ipcs -s -c

8、显示最近访问过IPC设施的进程ID。

# ipcs -p

# ipcs -m -p

# ipcs -q -p

9、显示IPC设施的最后操作时间

# ipcs -t

# ipcs -q -t

# ipcs -m -t

# ipcs -s -t

10、显示IPC设施的当前状态

# ipcs -u

Linux上的ipcs命令，不支持UNIX上的-b、-o指令，同样UNIX中不支持-l、-u指令，所以在编写跨平台的脚本时，需要注意这个问题。