Tony Bai - Part 340

六月 27, 2011

部门虽然不是做Web开发的，但是部门内部很多服务器也是使用Apache作为Web Server的。不过一直一来我这边都是用一个Apache Server对应一套Web应用。不过今天有了新的要求：在一个已经部署了一套应用的Apache2上再部署另外一套应用。这也让我不得不深入了解一下Apache的配置。不过还好，过程还是顺利的，这里记下此文意在备忘，如果同时也能给大家带来一些有价值的参考那就再好不过了。

Ubuntu下安装好Apache2后(sudo apt-get install apache)，在任何配置都未做修改的初始情况下，我们看到的与虚拟站点有关的Apache2的初始配置如下：

Apache2主配置文件: /etc/apache2/apache2.conf。其最后两行为：
# Include the virtual host configurations:
Include /etc/apache2/sites-enabled/

显然/etc/apache2/sites-enabled下存放着有关虚拟站点（VirtualHost）的配置。经查看，初始情况下，该目录下包含一个符号连接：000-default -> ../sites-available/default

这里又引出另外一个配置目录：/etcc/apache2/sites-available。这个目录下放置了所有可用站点的真正配置文件，对于Enabled的站点，Apache2在sites-enabled目录建立一个到sites-available目录下文件的符号链接。

/etc/apache2/sites-available下有两个文件：default和default-ssl。000-default链接的文件为default，我们就以default为例，看看一个VirtualHost的配置是啥样的：

ServerAdmin webmaster@localhost

    DocumentRoot /var/www

        Options FollowSymLinks
        AllowOverride None


        Options Indexes FollowSymLinks MultiViews
        AllowOverride None
        Order allow,deny
        allow from all

    … …

DocumentRoot是这个站点的根目录，这样Apache2启动时会扫描/etc/apache2/sites-enabled中可用的website配置并加载。当用户访问localhost:80时，Apache2就将default站点根目录/var/www下的index.html作为请求的回应返回给浏览器，你就会欣赏到的就是/var/www/index.html这个文件中的内容了。

Apache2的默认站点我们不要去动它。我们新增站点配置来满足我们的要求。到这里我猜测一下你可能有两类需求：
一是如何配置根据访问的域名区分配置不通的站点？
二是在相同域名地址的情况下，如何通过访问不同的端口获得不同的站点？

我们先来看看第一种需求。第一种需求讲的是我要在一个Apache2服务器上配置两个站点：site1.com和site2.com。好，我们可以按照下面步骤来做：

* 建立配置文件
在sites-available中建立两个站点的配置文件site1_com和site2_com：
sudo cp default site1_com
sudo cp default site2_com

编辑这两个配置文件，以site1_com为例：

        ServerAdmin webmaster@localhost
        ServerName site1.com

        DocumentRoot /var/www/site1_com

            Options FollowSymLinks
            AllowOverride None


            Options Indexes FollowSymLinks MultiViews
            AllowOverride None
            Order allow,deny
            allow from all

        … …

注意上面配置中：ServerName、DocumentRoot和Directory是我们重点关注的配置点。site1的ServerName为site1.com，根目录为/var/www/site1_com，Directory同DocumentRoot。site2_com也做同样的改动。

* 在sites-enabled目录下建立符号链接：
sudo ln -s /etc/apache2/sites-available/site1_com /etc/apache2/sites-enabled/site1_com
sudo ln -s /etc/apache2/sites-available/site2_com /etc/apache2/sites-enabled/site2_com

* 在/var/www下建立site1_com和site2_com两个目录，然后修改目录所有者：
sudo chown -R www-data site1_com site2_com/

* 在site1_com和site2_com中各自创建一个index.html文件，用于测试使用。
以site1_com下index.html为例，其内容为：Welcome To Site1。

* 重启Apache2(sudo /init.d/apache2 restart)使配置生效。
* 修改/etc/hosts文件，便于测试。
添加如下两行：
127.0.0.1 site1.com
127.0.0.1 site2.com

* 打开浏览器，输入http://site1.com，之后不出意外你就会看到”Welcome to Site1“字样。

第二类需求是希望通过端口号来区分虚拟站点。这个也不难，一些配置方法与上面内容雷同，这里就不详说了。

比如以site2为例：我通过80端口访问site2，可看到"Welcome to Site2”，从8080端口访问site2，则会看到"Welcome to Site2 through 8080"。我们如何配置呢？

* 首先我们得让apache2监听端口8080
修改/etc/apache2/ports.conf，增加两行：
NameVirtualHost *:8080
Listen 8080

* 在/etc/apache2/sites-available/下增加site2_com_8080，并在sites-enabled下建立符号连接。
site2_com_8080的主要配置如下：

ServerAdmin webmaster@localhost
ServerName site2.com

        DocumentRoot /var/www/site2_com_8080

            Options FollowSymLinks
            AllowOverride None


            Options Indexes FollowSymLinks MultiViews
            AllowOverride None
            Order allow,deny
            allow from all

        … …

在/var/www下建立site2_com_8080目录，方法同上。

重启Apache2，访问http://site2.com:8080，我们将看到“Welcome to Site2 through 8080”。

也谈C语言的内联函数

六月 22, 2011

1 条评论

有这样一段代码：

/* foo.c */
#include "stdio.h"

inline void foo() {
printf("inline foo in %s\n", __FILE__);
}

int main() {
foo();
return 0;
}

我采用C99标准，并在不加任何优化选项的情况下编译之：

$ gcc -std=c99 foo.c -o foo
foo.c: In function ‘foo’:
/tmp/ccLGkuIK.o: In function `main':
foo.c:(.text+0×7): undefined reference to `foo'
collect2: ld returned 1 exit status

这样的结果出乎我的意料。我原以为用inline修饰的函数定义，如上面的foo函数，在编译器未开启内联优化时依旧可以作为外部函数定义被编译器使用。但通过上面gcc输出的错误信息来看，inline函数的定义并没有被看待为外部函数定义，这样链接器才无法找到foo这个符号。C99标准新增的inline似乎与我对inline语义的理解有所不同。

C语言原本是不支持inline的，但C++中原生对inline的支持让很多C编译器也为C语言实现了一些支持inline语义的扩展。C99将inline正式放入到标准C语言中，并提供了inline关键字。和C++中的inline一样，C99的inline也是对编译器的一个提示，提示编译器尽量使用函数的内联定义，去除函数调用带来的开销。inline只有在开启编译器优化选项时才会生效。正如上面的例子，当我们打开优化选项并重新编译时，我们会看到：

$ gcc -std=c99 foo.c -O2 -o foo
$./foo
$ inline foo in foo.c

在-O2的优化选项下，编译器进行了内联优化，并采用了foo的inline定义。通过汇编代码我们也可以看出：foo.s中并没有显式地使用call进行函数调用，函数调用被优化掉了：

/* foo.s : gcc -std=c99 foo.c -O2 -S */
    .file   "foo.c"
    .section    .rodata.str1.1,"aMS",@progbits,1
.LC0:
    .string "foo.c"
.LC1:
    .string "inline foo in %s\n"
    .text
    .p2align 4,,15
.globl main
    .type   main, @function
main:
    pushl   %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    subl    $16, %esp
    movl    $.LC0, 8(%esp)
    movl    $.LC1, 4(%esp)
    movl    $1, (%esp)
    call    __printf_chk
    xorl    %eax, %eax
    leave
    ret
    .size   main, .-main
    .ident "GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"
    .section    .note.GNU-stack,"",@progbits

我们在另外一个文件bar.c中提供一个foo的外部函数定义：

/* bar.c */
#include

void foo() {
printf("global foo in %s\n", __FILE__);
}

我们将foo.c和bar.c放在一起编译（未开启优化选项）：
$ gcc -std=c99 foo.c bar.c -o foo
$ ./foo
$ global foo in bar.c

链接器为foo.c中的符号foo选择了bar.c中的foo函数定义。这样看来我们甚至可以有两个同名（名字都是foo）的函数定义，只不过一个是inline定义，一个是外部定义，它们并不冲突。

再开启优化选项，我们得到：
$ gcc -std=c99 foo.c bar.c -o foo
$ ./foo
$ inline foo in foo.c

这一次编译器选择了foo的inline定义。

究其原因：foo.c和bar.c分处于两个不同的编译单元，在未开启内联优化的情况下，foo.c对应的目标文件foo.o中foo只是一个未定义的符号，而bar.o中的foo却是一个global符号，并对应一块独立的实现代码。链接器自然采用了bar.c中的foo函数定义。而在开启了内联优化的情况下，编译器在进行foo.o这个编译单元的编译期间就直接对foo进行了优化，并采用了foo的inline定义，直接放到了main函数的汇编代码中，没有显式地call foo，并且foo.o中并未为foo单独生成Global函数代码，这样在最后的链接阶段，bar.o就变成"打酱油"的了^_^。

以上只是为了说明C99内inline语义而做的试验。在现实开发中，我们绝不应该这么去做。我们要确保函数的inline定义和非inline定义的语义一致性。那能否做到让一份函数定义既可以作为inline定义，也可以作为外部函数定义呢？这意味着我们在开启内联优化时，既要在inline函数定义的编译单元里执行内联优化，也要为inline函数生成一份独立的global的函数定义（汇编码）。

我们增加一个头文件foo.h：
/* foo.h */
extern void foo();

/* foo.c */
#include
#include "foo.h"

inline void foo() {
printf("foo in %s\n", __FILE__);
}

int main() {
foo();
return 0;
}

我们在开启优化和未开启优化两种情况下分别编译执行：
$ gcc -std=c99 foo.c -o foo
$ ./foo
$ foo in foo.c

$ gcc -std=c99 foo.c -o foo -O2
$ ./foo
$ foo in foo.c

我们看到：无论哪种情况，我们都可以顺利通过编译，并且得到正确的执行结果。我们来看看汇编码有何变化：

在未开启优化的情况下，我们得到如下汇编码：

.globl foo
    .type   foo, @function
foo:
    pushl   %ebp
    … …
    call    printf
    leave
    ret
    .size   foo, .-foo

    … …
main:
    pushl   %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    call    foo
    … …
    ret

内联优化并未生效，main代码中进行了foo的函数调用。但与本文开始时的那个例子不同的是，编译器为foo生成了一份独立的global的函数定义汇编码块，这块代码可以直接被外部引用，也就是说在未开启优化的情况下，foo定义被看成了外部函数定义。

但开启优化选项的情况下，我们得到如下汇编码：
.globl foo
    .type   foo, @function
foo:
    pushl   %ebp
    … …
    call    __printf_chk
    leave
    ret
    … …
main:
    pushl   %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    subl    $16, %esp
    movl    $.LC0, 8(%esp)
    movl    $.LC1, 4(%esp)
    movl    $1, (%esp)
    call    __printf_chk
    xorl    %eax, %eax
    leave
    ret

内联优化生效了，main代码中并未显式地进行foo的函数调用。并且编译器依旧为foo生成了一份独立的global的函数定义汇编码块，这块代码可以直接被外部引用，也就是说在开启优化的情况下，foo定义在本编译单元被看作内联定义，同时对其他编译单元而言，也是外部函数定义。

我们通过在头文件中增加一个外部函数声明实现了我们的目标！不过上面方法虽然实现了一份定义既可以当作inline定义，也可以作为外部定义，但inline定义仅局限于定义它的那个编译单元，其他编译单元即使在开启内联优化时，依旧无法实施内联优化。如果我们希望多个编译单元共享一份inline定义并且这份定义也可以同时作为外部函数定义，我们该如何做呢？ – 那我们只能把inline定义放到头文件中了！见下面代码：

/* foo.h */
inline void foo() {
printf ("foo in %s\n", __FILE__);
}

/* foo.c */
#include
#include "foo.h"

int main() {
foo();
return 0;
}

/* bar.c */
#include
#include "foo.h"

void bar() {
foo();
}

$ gcc -std=c99 foo.c -S -O2
我们看看开启优化情况下的bar.c和foo.c对应的汇编代码，以foo.s为例：

/* foo.s */
… …
main:
    pushl   %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    subl    $16, %esp
    movl    $.LC0, 8(%esp)
    movl    $.LC1, 4(%esp)
    movl    $1, (%esp)
    call    __printf_chk
    xorl    %eax, %eax
    leave
    ret
… …

内联优化生效，bar.s也是一样，不过编译器没有为我们生成foo的独立外部定义代码，这样的foo定义只能作为inline定义，而不能被作为外部函数定义。如果此时不开启优化选项编译，我们还会得到如下错误：
/tmp/ccpp1E7i.o: In function `main':
foo.c:(.text+0×7): undefined reference to `foo'
/tmp/ccQk872R.o: In function `bar':
bar.c:(.text+0×7): undefined reference to `foo'
collect2: ld returned 1 exit status

我们稍作改动，在foo.c和bar.c的文件开始处，我们加上这样一行代码："extern inline void foo();"，加上后，我们重新编译，这回foo在被内联优化的同时，也被生成了一份独立的外部函数定义。我们的目标又达到了!

总之，C99中inline相对比较怪异，使用时务必小心慎重。