struct ngx_shm_zone_s {
//指向自定义数据结构，一般用来初始化时使用，可能指向本地地址
void *data;
//真正的共享内存
ngx_shm_t shm;
//初始化函数
ngx_shm_zone_init_pt init;
//标记
void *tag;
};

ngx_shm_zone_t *
ngx_shared_memory_add(ngx_conf_t *cf, ngx_str_t *name, size_t size, void *tag)
{
    ngx_uint_t        i;
    ngx_shm_zone_t   *shm_zone;
    ngx_list_part_t  *part;
 
    part = &cf->cycle->shared_memory.part;
    shm_zone = part->elts;
//先查找所有已经存在的共享内存，看看要创建的共享内存是否存在于这里面，如果存在的话就直接返回，否则
//创建一个新的共享内存结构体再返回
for (i = 0; /* void */ ; i++) {
 
        if (i >= part->nelts) {
            if (part->next == NULL) {
                break;
            }
            part = part->next;
            shm_zone = part->elts;
            i = 0;
        }
 
        if (name->len != shm_zone[i].shm.name.len) {
            continue;
        }
 
        if (ngx_strncmp(name->data, shm_zone[i].shm.name.data, name->len)
            != 0)
        {
            continue;
        }
 
        if (size && size != shm_zone[i].shm.size) {
            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                            "the size %uz of shared memory zone \"%V\" "
                            "conflicts with already declared size %uz",
                            size, &shm_zone[i].shm.name, shm_zone[i].shm.size);
            return NULL;
        }
 
        if (tag != shm_zone[i].tag) {
            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                            "the shared memory zone \"%V\" is "
                            "already declared for a different use",
                            &shm_zone[i].shm.name);
            return NULL;
        }
//此共享内存已经存在，直接返回
        return &shm_zone[i];
    }
//插入一个新的共享内存结构体结点
    shm_zone = ngx_list_push(&cf->cycle->shared_memory);
 
    if (shm_zone == NULL) {
        return NULL;
    }
 
    shm_zone->data = NULL;
    shm_zone->shm.log = cf->cycle->log;
    shm_zone->shm.size = size;
    shm_zone->shm.name = *name;
    shm_zone->shm.exists = 0;
    shm_zone->init = NULL;
    shm_zone->tag = tag;
 
    return shm_zone;
}

ngx_cycle_t *
ngx_init_cycle(ngx_cycle_t *old_cycle)
{
。。。
 
    /* create shared memory */
 
    part = &cycle->shared_memory.part;
    shm_zone = part->elts;
 
    for (i = 0; /* void */ ; i++) {
 
        if (i >= part->nelts) {
            if (part->next == NULL) {
                break;
            }
            part = part->next;
            shm_zone = part->elts;
            i = 0;
        }
 
        if (shm_zone[i].shm.size == 0) {
            ngx_log_error(NGX_LOG_EMERG, log, 0,
                          "zero size shared memory zone \"%V\"",
                          &shm_zone[i].shm.name);
            goto failed;
        }
//注意这里，没有设置init函数的共享内存是被视为不使用的
        if (shm_zone[i].init == NULL) {
            /* unused shared zone */
            continue;
        }
 
        shm_zone[i].shm.log = cycle->log;
//这里主要是考虑reload操作
        opart = &old_cycle->shared_memory.part;
        oshm_zone = opart->elts;
 
        for (n = 0; /* void */ ; n++) {
 
            if (n >= opart->nelts) {
                if (opart->next == NULL) {
                    break;
                }
                opart = opart->next;
                oshm_zone = opart->elts;
                n = 0;
            }
 
            if (shm_zone[i].shm.name.len != oshm_zone[n].shm.name.len) {
                continue;
            }
 
            if (ngx_strncmp(shm_zone[i].shm.name.data,
                            oshm_zone[n].shm.name.data,
                            shm_zone[i].shm.name.len)
                != 0)
            {
                continue;
            }
//如果新的共享内存和旧的共享内存大小一样，就无需再次分配了，直接指过去即可
            if (shm_zone[i].shm.size == oshm_zone[n].shm.size) {
                shm_zone[i].shm.addr = oshm_zone[n].shm.addr;
//这里还需要重新初始化一下，因为可能会有对本地内存的操作
                if (shm_zone[i].init(&shm_zone[i], oshm_zone[n].data)
                    != NGX_OK)
                {
                    goto failed;
                }
 
                goto shm_zone_found;
            }
//如果老的共享内存和新的要分配的共享内存大小不一致，那就只能释放掉了
            ngx_shm_free(&oshm_zone[n].shm);
 
            break;
        }
//真正分配共享内存的调用 
        if (ngx_shm_alloc(&shm_zone[i].shm) != NGX_OK) {
            goto failed;
        }
//初始化共享内存，为用slab来管理内存池做准备
        if (ngx_init_zone_pool(cycle, &shm_zone[i]) != NGX_OK) {
            goto failed;
        }
//调用设置的init函数
        if (shm_zone[i].init(&shm_zone[i], NULL) != NGX_OK) {
            goto failed;
        }
 
    shm_zone_found:
 
        continue;
    }
。。。
}

static ngx_int_t
ngx_init_zone_pool(ngx_cycle_t *cycle, ngx_shm_zone_t *zn)
{
    u_char           *file;
    ngx_slab_pool_t  *sp;
//通过slab来管理内存
    sp = (ngx_slab_pool_t *) zn->shm.addr;
 
    if (zn->shm.exists) {
 
        if (sp == sp->addr) {
            return NGX_OK;
        }
 
        ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
                      "shared zone \"%V\" has no equal addresses: %p vs %p",
                      &zn->shm.name, sp->addr, sp);
        return NGX_ERROR;
    }
//初始化slab分配器
    sp->end = zn->shm.addr + zn->shm.size;
    sp->min_shift = 3;
    sp->addr = zn->shm.addr;
 
#if (NGX_HAVE_ATOMIC_OPS)
 
    file = NULL;
 
#else
 
    file = ngx_pnalloc(cycle->pool, cycle->lock_file.len + zn->shm.name.len);
    if (file == NULL) {
        return NGX_ERROR;
    }
 
    (void) ngx_sprintf(file, "%V%V%Z", &cycle->lock_file, &zn->shm.name);
 
#endif
//创建共享内存的锁
    if (ngx_shmtx_create(&sp->mutex, (void *) &sp->lock, file) != NGX_OK) {
        return NGX_ERROR;
    }
 
    ngx_slab_init(sp);
 
    return NGX_OK;
}

//该结构用来维护内存池的数据部分，供用户分配内存使用
typedef struct {
u_char               *last;//当前内存分配结束的位置
u_char               *end;//内存池结束位置
ngx_pool_t           *next;//指向下一个内存池
ngx_uint_t            failed;//统计内存池不能满足分配请求的次数
} ngx_pool_data_t;
//该结构维护整个内存池链表的头部信息
struct ngx_pool_s {
ngx_pool_data_t       d;//数据块
size_t                max;//数据块的大小，即可分配的内存的最大值
ngx_pool_t           *current;//当前内存池
ngx_chain_t          *chain;//这一部分暂不涉及
ngx_pool_large_t     *large;//分配大内存使用，即请求分配的内存大小超过max
ngx_pool_cleanup_t   *cleanup;//用来指向内存池释放时同时释放的资源
ngx_log_t            *log;
};

void *ngx_palloc(ngx_pool_t *pool, size_t size);
void *ngx_pnalloc(ngx_pool_t *pool, size_t size);
void *ngx_pcalloc(ngx_pool_t *pool, size_t size);
void *ngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment);

#define ngx_align_ptr(p, a)                                                                                     \
    (u_char *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))

from twisted.internet import protocol
from twisted.protocols import baisc

class Answer(LineReceiver):
    def lineReceived(self, line):
        #行数据接收处理方式
        pass
    def dataReceived(self, data):
        #原始数据接收处理方式
        pass

class AnswerServerFactory(protocol.ServerFactory):
    protocol=Answer#表明每次成功建立连接时要实例的协议类型
    def startFactory(self):
        #在开始监听一个端口或连接器时被调用
        pass
    def stopFactory(self):
        #在停止监听所有端口或连接器时被调用
        pass
    def  buildProtocol(self, addr):
        #实例化Protocol的子类
        protocol.ServerFactory.buildProtocol(self, add)
        pass

from twisted.internet import reactor
reactor.listenTCP(8000,AnswerServerFactory())
reactor.run()

#!/bin/bash
 
declare -i count=`pacmd list-sinks | grep -c index:[[:space:]][[:digit:]]`
declare -i active=`pacmd list-sinks | sed -n -e 's/\*[[:space:]]index:[[:space:]]\([[:digit:]]\)/\1/p'`
declare -i major=$count-1
declare -i next=0
 
if [ $active -ne $major ] ; then
next=active+1
fi
 
pacmd "set-default-sink ${next}"
 
for app in $(pacmd list-sink-inputs | sed -n -e 's/index:[[:space:]]\([[:digit:]]\)/\1/p');
do
pacmd "move-sink-input $app $next"
done
 
declare -i ndx=0
pacmd list-sinks | sed -n -e 's/device.description[[:space:]]=[[:space:]]"\(.*\)"/\1/p' | while read line;
do
if [ $next -eq $ndx ] ; then
notify-send -i notification-audio-volume-high "声音输出切换到" "$line"
exit
fi
ndx+=1
done;

#!/bin/sh
while true;
do
    if test -n "`file /tmp/Flash*|grep \"Macromedia Flash Video\\|MPEG v4\"`";then
        gnome-screensaver-command -p
    fi
    sleep 30
done

#!/bin/sh
while true;
do
	pid=`ps aux | grep /opt/google/chrome/libgcflashplayer.so | grep -v grep | awk '{print $2}'`
	if [ "$pid" != "" ]; then
		data=`lsof -p $pid | grep /tmp/Flash`
		if [ "$data" != "" ]; then
			echo "gnome-screensaver-command"
			gnome-screensaver-command -p
		fi
	fi
	sleep 30
done