标签 开源 下的文章

APR源代码分析-信号篇

U know 信号Unix的重要系统机制。信号机制使用起来很简单,但是理解起来有并不是那么Easy。APR Signal的封装也并不繁琐,代码量很少,所以分析APR Signal的过程其实就是学习Signal机制的过程。

一、信号介绍
1、Signal“历史久远”,在最初的Unix系统上就能看到它“伟岸”的身影。它的引入用来进行User Mode进程间的交互,系统内核也可以利用它通知User Mode进程发生了哪些系统事件。从最开始引入到现在,信号只是做了很小的一些改动(不可靠信号模型到可靠信号模型)。

2、信号服务于两个目的:
 1) 通知某进程某特定事件发生了;
 2) 强制其通知进程执行相应的信号处理程序。

二、基础概念
1、信号的一个特性就是可以在任何时候发给某一进程,而无需知道该进程的状态。如果该进程当前并未处于执行态,则该信号被内核Save起来,直到该进程恢复执行才传递给它;如果一个信号被进程设置为阻塞,则该信号的传递被延迟,直到其阻塞被取消它才被传递给进程。

2、系统内核严格区分信号传送的两个阶段:
 1) Signal Generation : 系统内核更新目标进程描述结构来表示一个信号已经被发送出去。
 2) Signal Delivery : 内核强制目标进程对信号做出反应,或执行相关信号处理函数,或改变进程执行状态。
信号的诞生和传输我们可以这样理解:把信号作为“消费品”,其Generation状态就是“消费品诞生”,其Delivery状态就是理解为“被消费了”。这样势必存在这样的一个情况:“消费品诞生了,但是还没有被消费掉”,在信号模型中,这样的状态被称为“pending”(悬而未决)。

任何时候一个进程只能有一个这样的某类型的pending信号,同一进程的其他同类型的pending信号将不排队,将被简单的discard(丢弃)掉。

3、如何消费一个signal
 1) 忽略该信号;[注1]
 2) 响应该信号,执行一特定的信号处理函数;
 3) 响应该信号,执行系统默认的处理函数。包括:Terminate、Dump、Ignore、Stop、Continue等。
这里有特殊:SIGKILL和SIGSTOP两个信号不能忽略、不能捕捉、不能阻塞,而只是执行系统默认处理函数。

三、APR Signal封装
APR Signal源代码的位置在$(APR_HOME)/\threadproc目录下,本篇blog着重分析unix子目录下的signals.c文件内容,其相应头文件为$(APR_HOME)/include/apr_signal.h。

1、apr_signal函数
Unix信号机制提供的最简单最常见的接口是signal函数,用来设置某特定信号的处理函数。但是由于早期版本和后期版本处理信号方式的不同,导致现在直接使用signal函数在不同的平台上可能得到不同的结果。
早期版本处理方式:进程每次处理信号后,随即将信号的处理动作重置为默认值。
后期版本处理方式:进程每次处理信号后,信号的处理动作不被重置为默认值。

我们举例测试一下:分别在Solaris 9 、Cygwin和RedHat Linux 9上。
例子:
E.G 1:
void siguser1_handler(int sig);

int main(void)
{
        if (signal(SIGUSR1, siguser1_handler) == SIG_ERR) {
                perror("siguser1_handler error");
                exit(1);
        }
        while (1) {
                pause();
        }
}

void siguser1_handler(int sig)
{
        printf("in siguser1_handler, %d\n", sig);
}

input:
kill -USR1 9122
kill -USR1 9122

output:(Solaris 9)
in siguser1_handler, 16
用户信号1 (程序终止)

output:(Cygwin and RH9)
in siguser1_handler, 30
in siguser1_handler, 30

..

E.G 1结果表示在Solaris 9上,信号的处理仍然按照早期版本的方式,而Cygwin和RH9则都按照后期版本的方式。
那么有什么替代signal函数的办法么?在最新的X/Open和UNIX specifications中都推荐使用一个新的信号接口sigaction,该接口采用后期版本的信号处理方式。在《Unix高级环境编程》中就有使用sigaction实现signal的方法,而APR恰恰也是使用了该方法实现了apr_signal。其代码如下:
APR_DECLARE(apr_sigfunc_t *) apr_signal(int signo, apr_sigfunc_t * func)
{
    struct sigaction act, oact;

    act.sa_handler = func;
    sigemptyset(&act.sa_mask); ——————(1)
    act.sa_flags = 0;
#ifdef SA_INTERRUPT             /* SunOS */
    act.sa_flags |= SA_INTERRUPT;
#endif
    … …

    if (sigaction(signo, &act, &oact) < 0)
        return SIG_ERR;
    return oact.sa_handler;
}

(1) 这里有一个Signal Set(信号集)的概念,通过相关函数操作信号集以改变内核传递信号给进程时的行为。Unix用sigset_t结构来表示信号集。信号集总是和sigprocmask或sigaction一起使用。关于信号集和sigprocmask函数将在下面详述。

2、apr_signal_block和apr_signal_unblock
这两个函数分别负责阻塞和取消阻塞内核传递某信号给目标进程。其主要利用的就是sigprocmask函数来实现的。每个进程都有其对应的信号屏蔽字,它让目标进程能够通知内核“哪些传给我的信号该阻塞,哪些畅通无阻”。在《Unix高级环境编程》中作者有这么一段说明“如果在调用sigprocmask后有任何未决的、不再阻塞的信号,则在sigprocmask返回前,至少将其中之一递送给该进程。”能理解这句我想信号屏蔽字这块儿也就没什么问题了。在Unix高级环境编程》中作者举了一个很不错的例子,讲解的也很详细。这里想举例说明的是:如果多次调用SET_BLOCK的sigprocmask设置屏蔽字,结果是什么呢?

E.G 3
int main(void)
{
        sigset_t newmask, oldmask, pendmask;

        /* 设置进程信号屏蔽字, 阻塞SIGQUIT */
        sigemptyset(&newmask);
        sigaddset(&newmask, SIGQUIT);

        if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0) {
                perror("SIG_BLOCK error");
        }

        printf("1st to wait 30 seconds\n");
        sleep(30);

        /* 第一次察看当前的处于pend状态的信号 */
        if (sigpending(&pendmask) < 0) {
                perror("sigpending error");
        }

        if (sigismember(&pendmask, SIGQUIT)) {
                printf("SIGQUIT pending\n");
        } else {
                printf("SIGQUIT unpending\n");
        }

        if (sigismember(&pendmask, SIGUSR1)) {

        if (sigismember(&pendmask, SIGUSR1)) {
                printf("SIGUSR1 pending\n");
        } else {
                printf("SIGUSR1 unpending\n");
        }

        /* 重新设置屏蔽字, 阻塞SIGUSR1 */
        sigemptyset(&newmask);
        sigaddset(&newmask, SIGUSR1);

        if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0) {
                perror("SIG_BLOCK error");
        }

        printf("2nd to wait 30 seconds\n");
        sleep(30);

        /* 再次察看当前的处于pend状态的信号 */
        if (sigpending(&pendmask) < 0) {
                perror("sigpending error");
        }

        if (sigismember(&pendmask, SIGQUIT)) {
                printf("SIGQUIT pending\n");
        } else {
                printf("SIGQUIT unpending\n");
        }

        if (sigismember(&pendmask, SIGUSR1)) {
                printf("SIGUSR1 pending\n");
        } else {
                printf("SIGUSR1 unpending\n");
        }
        exit(0);
}

//output:
1st to wait 30 seconds
^\
SIGQUIT pending
SIGUSR1 unpending
2nd to wait 30 seconds — 这之后发送kill -USR1 28821
SIGQUIT pending
SIGUSR1 pending

第一次输出SIGUSR1 unpending是因为并未发送USR1信号,所以自然为unpending状态;我想说的是第二次重新sigprocmask时我们仅加入了SIGUSR1,并未显示加入SIGQUIT,之后察看pending信号中SIGQUIT仍然为pending状态,这说明两次SET_BLOCK的sigprocmask调用是"或"的关系,第二次SET_BLOCK的sigprocmask调用不会将第一次SET_BLOCK的sigprocmask调用设置的阻塞信号变为非阻塞的。

四、总结
信号简单而强大,如果想深入了解signal的实现,参考资料中的第二本书会给你满意的答案。

五、参考资料:
1、《Unix高级环境编程
2、《深入理解Linux内核

[注1]
忽略信号和阻塞信号
前者相当于一个消费行为,该信号的状态为“已消费”,而后者只是将信号做缓存,等待阻塞打开,再交给进程消费,其状态为“未消费”,也相当于处于pending状态。

APR源代码分析-内存篇

内存管理一直是让C程序员头痛的问题,作为一个通用接口集,APR当然也提供其自己的内存管理接口–APR Pool。APR Pool作为整个APR的一个基础功能接口,直接影响着APR的设计风格。在这篇Blog中,我们就要和APR Pool来一次“亲密接触”。(还是以Unix平台实现为例)

APR Pool源代码的位置在$(APR_HOME)/memory目录下,本篇blog着重分析unix子目录下的apr_pools.c文件内容,其相应头文件为$(APR_HOME)/include/apr_pools.h;在apr_pools.c中还实现了负责APR内部内存分配的APR allocator的相关操作接口(APR allocator相关头文件为$(APR_HOME)/include/apr_allocator.h)。

一、APR Pool概述
我们平时常用的内存管理方式都是基于“request-style”的,即分配所请求大小的内存,使用之,销毁之。而APR Pool的设计初衷是为Complex Application提供良好的内存管理接口,其使用方式与“request-style”有所不同。在$(APR_HOME)/docs/pool-design.htm文档中,设计者道出了“使用好”APR Pool的几个Rules,同时也从侧面反映出APR Pool的设计。
1、任何Object都不应该有自己的Pool,它应该在其构造函数的调用者的Pool中分配。因为一般调用者知道该Object的生命周期,并通过Pool管理之。也就是说Object无须自己调用"Close" or "Free",这些操作在Object所在Pool被摧毁时会被隐式调用的。
2、函数无须为了他们的行为而去Create/Destroy Pool,它们应该使用它们调用者传给它们的Pool。
3、为了防止内存无限制的增长,APR Pool建议当遇到unbounded iteration时使用sub_pool,标准格式如下:
subpool = apr_poll_create(pool, NULL);
for (i = 0; i < n; ++i) {
  apr_pool_clear(subpool);
  … …
  do_operation(…, subpool);
}
apr_pool_destroy(subpool);

二、深入APR Pool
到目前为止我们已经知道了该如何“很好的”使用APR Pool,接下来我们来深入APR Pool的内部,看究竟有什么“奥秘”。
1、分析apr_pool_initialize
任何使用APR的应用程序一般都会调用apr_app_initalize来初始化APR的内部使用的数据结构,察看一下app_app_initialize的代码,你会发现apr_pool_initialize在被apr_app_initialize调用的apr_initialize中被调用,该函数用来初始化使用Pool所需的内部结构(用户无须直接调用apr_pool_initialize,在apr_app_initialize时它被自动调用,而apr_app_initialize又是APR program调用的第一个function,其在apr_general.h中声明,在misc/unix/start.c中实现)。

apr_pool_initialize的伪码如下(这里先不考虑多线程的情况):
static apr_byte_t apr_pools_initialized = 0;
static apr_pool_t *global_pool = NULL;
static apr_allocator_t *global_allocator = NULL;

apr_pool_initialize
{
 如果(!apr_pools_initialized)
 {
  创建global_allocator; ——(1)
 }
 
 创建global_pool; ——-(2)
 给global_pool起名为"apr_global_pool";
}

(1) Pool和Allocator
每个Pool都有一个allocator相伴,这个allocator可能是Pool自己的,也可能是其Parent Pool的。allocator的结构如下:
/* in apr_pools.c */
struct apr_allocator_t {
    apr_uint32_t        max_index;
    apr_uint32_t        max_free_index;
    apr_uint32_t        current_free_index;
    … …[注1]
    apr_pool_t         *owner;
    apr_memnode_t      *free[MAX_INDEX];
};
在(1)调用后,global_allocator的所有xx_index字段都为0,owner–>NULL,free指针数组中的指针也都–>NULL。这里的index是大小的级别,这里最大级别为20(即MAX_INDEX = 20),free指针数组中free[0]所指的node大小为MIN_ALLOC大小,即8192,即2的13次幂。按此类推free[19]所指的node大小应为2的32次幂,即4G byte。allocator_alloc中是通过index = (size >> BOUNDARY_INDEX) – 1来得到这一index的。allocator维护了一个index不同的memnode池,每一index级别上又有一个memnode list,以后用户调用apr_palloc分配size大小内存时,allocaotr_alloc函数就会在free memnode池中选和要寻找的size的index级别相同的memnode,而不是重新malloc一个size大小的memnode。另外要说明一点的是APR Pool中所有ADT中的xx_index字段都是大小级别的概念。

(2) 创建global_pool
在APR Pool初始化的时候,唯一创建一个Pool — global_pool。apr_pool_t的非Debug版本如下:
/* in apr_pools.c */
struct apr_pool_t {
    apr_pool_t           *parent;
    apr_pool_t           *child;
    apr_pool_t           *sibling;
    apr_pool_t           **ref;
    cleanup_t            *cleanups;
    cleanup_t            *free_cleanups;
    apr_allocator_t      *allocator;
    struct process_chain *subprocesses;
    apr_abortfunc_t       abort_fn;
    apr_hash_t           *user_data;
    const char           *tag;
    apr_memnode_t        *active;
    apr_memnode_t        *self; /* The node containing the pool itself */
    char                 *self_first_avail;
    … …
}
而apr_memnode_t的结构如下:
/* in apr_allocator.h */
struct apr_memnode_t {
    apr_memnode_t *next;            /**< next memnode */
    apr_memnode_t **ref;            /**< reference to self */
    apr_uint32_t   index;           /**< size */
    apr_uint32_t   free_index;      /**< how much free */
    char          *first_avail;     /**< pointer to first free memory */
    char          *endp;            /**< pointer to end of free memory */
};

apr_pool_create_ex首先通过allocator寻找合适的node用于创建Pool,但由于global_allocator尚未分配过任何node,所以global_allocator创建一个新的node,该node大小为MIN_ALLOC(即8192),该node的当前状态如下:
node –>|—————|0
              |                      |
              |                      |
              |                      |
              |—————|APR_MEMNODE_T_SIZE first_avail
              |                      |
              |                      |
              |                      | 
              —————– size(一般为8192) endp
其他属性值如下:
node->next = NULL;
node->index = (APR_UINT32_TRUNC_CAST)index; /* 这里为1 */

创建完node后,我们将在该node上的avail space划分出我们的global_pool来。划分后状态如下(pool与node关系):
node –>|—————|0 self = pool_active
             |                       |
             |                       |
             |—————|APR_MEMNODE_T_SIZE <——– global_pool
            |                        |
            |                       |  
            |—————|APR_MEMNODE_T_SIZE+SIZEOF_POOL_T first_avail = pool->self_first_avail
           |                        |
           |                        |
           —————– size(一般为8192) endp

pool其他一些属性值(pool与pool之间关系)如下:
pool->allocator = global_allocator;
pool->child = NULL;
pool->sibling = NULL;
pool->ref = NULL;

也许现在你仍然不能看清楚APR Pool的结构,无需着急,我们继续往下分析。

2、APR Sub_Pool创建(pool与pool之间关系)
上面我们已经初始化了global_pool,但是global_pool是不能直接拿来就用的,我们需要创建其sub_pool,也就是用户自己的pool。一般创建user的sub_pool我们都使用apr_pool_create宏,它只需要2个参数,并默认sub_pool继承parent_pool的allocator和abort_fn。在apr_pool_create内部调用的还是apr_pool_create_ex函数。我们来看一下创建sub_pool后pool之间的关系:
例:
static apr_pool_t *sub_pool = NULL;
apr_pool_create(&sub_pool, NULL);

这里sub_pool的创建过程与global_pool相似,也是先创建其承载体node,然后设置相关属性,使其成为global_pool的child_pool。创建完后global_pool和该sub_pool的关系如下图:
global_pool    sub_pool
———–              \ /          ————
sibling —>NULL    /——-   parent
———–             /             ————
child ————  /                 sibling —–>NULL
———–                            ————
                                             child  ——>NULL
                                            ————
APR Pool是按照二叉树结构组织的,并采用“child-sibling”的链式存储方式,global_pool作为整个树的Root Node。如果APR Pool中存在多个Pool,其节点结构关系如下:
               /-child–>
              / ——–Pool_level1-a
             / / parent   /|\    |
            /|/_              |     | sibling
global_pool             |     |
            \                  |    \|/
             \-child-> Pool_level1-b
            /|\                  | 
             -parent——

3、从pool中分配内存
上面我们已经拥有了一个sub_pool,我们现在就可以从sub_pool中分配内存了。APR提供了函数apr_palloc来做这件事情。
例如:apr_alloc(sub_pool, wanted_mem_size);
apr_palloc在真正分配内存前会把wanted_mem_size做一下处理。它使用APR_ALIGN_DEFAULT宏处理wanted_mem_size得到一个圆整到8的new_size,然后再在pool中分配new_size大小的内存,也就是说pool中存在的用户内存块的大小都是8的倍数。举个例子来说,如果wanted_mem_size = 30,apr_alloc实际会在pool中划分出32个字节的空间。

apr_palloc的工作流程简单描述是这样的:
a) 如果在pool->active node的avail space足够满足要申请的内存大小size时,则直接返回active->first_avail,并调整active->first_avail = active->first_avail + size;
b) 如果a)不满足,则察看active->next这个node满足与否;如果满足则将返回所要内存,并将该node设为active node,将以前的active node放在新active node的next位置上;
c) 如果b)也不满足,则新创建一个memnode,这个node可能为新创建的,也可能是从allocator的free memnode池中取出的,取决于当时整个Pool的状态。

从上面我们也可以看出node分为2类,一种是作为pool的承载体,但pool结构的空间不足以完全占满一个node,所以也可以用来分配用户内存;另一种就是完全用于分配用户内存的了。每个pool有一个node list,当然这个list中包括它自己所在的node了。

4、apr_pool_clear和apr_pool_destroy
创建和分配结束后,我们需要clear或者destroy掉Pool。
clear和destroy的区别在于clear并不真正free内存,只是清理便于以后alloc时重用,而destroy则是真正的free掉内存了。

三、总结
本文并未说明APR Pool有哪些优点或缺点(除了概述中的一些Rules),仅是把其来龙去脉弄清。

[注1]
在本文中出现的"… …"的符号表示与多线程相关的字段和代码的省略。

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言精进之路1 Go语言精进之路2 Go语言编程指南
商务合作请联系bigwhite.cn AT aliyun.com

欢迎使用邮件订阅我的博客

输入邮箱订阅本站,只要有新文章发布,就会第一时间发送邮件通知你哦!

这里是 Tony Bai的个人Blog,欢迎访问、订阅和留言! 订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠 ,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats