meisw's blog

php调用so库和a库方法

举例分析Linux动态库和静态库

如何查看静态库内容 Unix/Linux

Linux动态库、静态库加载基础

Linux编译链接问题----静态库和动态库

linux中编译静态库(.a)和动态库(.so)的基本方法

Linux rsync目录同步功能实现

设置 XEN 的多网卡(3网卡4网卡..)桥接

php调用so库和a库方法

举例分析Linux动态库和静态库

如何查看静态库内容 Unix/Linux

Linux动态库、静态库加载基础

Linux编译链接问题----静态库和动态库

linux中编译静态库(.a)和动态库(.so)的基本方法

Linux rsync目录同步功能实现

设置 XEN 的多网卡(3网卡4网卡..)桥接

日志分类

日志归档

搜索文章

最新评论

博客信息

友情链接

浏览模式: 标准 | 列表全部文章

Submitted by admin on 2011, August 6, 11:44 AM

（一）调用so方法

(引自：http://tech.idv2.com/2007/07/06/use-local-so-in-php/)

某个功能被编译到so文件中，那么如何通过php来调用它？一个方法是写一个php模块(php extension)，在php中调用该模块内的函数，再通过该模块来调用so中的函数。下面做一个简单的例子，使用的操作系统是Fedora Core 6。

首先做一个简单的so文件：

/**
 * hello.c
 * To compile, use following commands:
 *   gcc -O -c -fPIC -o hello.o hello.c 
 *   gcc -shared -o libhello.so hello.o
 */

int hello_add(int a, int b)
{
    return a + b;
}

然后将它编译成.so文件并放到系统中：

$ gcc -O -c -fPIC -o hello.o hello.c
$ gcc -shared -o libhello.so hello.o
$ su
# echo /usr/local/lib > /etc/ld.so.conf.d/local.conf
# cp libhello.so /usr/local/lib
# /sbin/ldconfig

写段小程序来验证其正确性：

/**
 * hellotest.c
 * To compile, use following commands:
 *   gcc -o hellotest -lhello hellotest.c
 */
#include <stdio.h>
int main()
{
    int a = 3, b = 4;
    printf("%d + %d = %d\n", a, b, hello_add(a,b));
    return 0;
}

编译并执行：

$ gcc -o hellotest -lhello hellotest.c
$ ./hellotest
3 + 4 = 7

OK，下面我们来制作PHP模块。首先确保你安装了 php-devel 包，没有的话请自行从安装光盘上找。然后下载php源代码。我使用的是php-5.2.3.tar.gz，解压缩。

$ tar xzvf php-5.2.3.tar.gz
$ cd php-5.2.3/ext

然后通过下面的命令建立一个名为 hello 的模块。

$ ./ext_skel --extname=hello

执行该命令之后它会提示你应当用什么命令来编译模块，可惜那是将模块集成到php内部的编译方法。如果要编译成可动态加载的 php_hello.so，方法要更为简单。

$ cd hello

首先编辑 config.m4 文件，去掉第16行和第18行的注释（注释符号为 dnl 。）

16:  PHP_ARG_ENABLE(hello, whether to enable hello support,
17:  dnl Make sure that the comment is aligned:
18:  [  --enable-hello           Enable hello support])

然后执行 phpize 程序，生成configure脚本：

$ phpize

然后打开 php_hello.h，在 PHP_FUNCTION(confirm_hello_compiled); 之下加入函数声明：

PHP_FUNCTION(confirm_hello_compiled);   /* For testing, remove later. */
PHP_FUNCTION(hello_add);

打开 hello.c，在 PHP_FE(confirm_hello_compiled, NULL) 下方加入以下内容。

zend_function_entry hello_functions[] = {
    PHP_FE(confirm_hello_compiled,  NULL)       /* For testing, remove later. */
    PHP_FE(hello_add,   NULL)       /* For testing, remove later. */
    {NULL, NULL, NULL}  /* Must be the last line in hello_functions[] */
};

然后在 hello.c 的最末尾书写hello_add函数的内容：

PHP_FUNCTION(hello_add)
{
    long int a, b;
    long int result;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &a, &b) == FAILURE) {
        return;
    }

    result = hello_add(a, b);

    RETURN_LONG(result);
}

保存退出，编译并安装：

$ ./configure
$ make LDFLAGS=-lhello
$ su
# cp modules/hello.so /usr/lib/php/modules

然后在 /var/www/html 下建立一个 hello.php 文件，内容如下：

<?php
    dl("hello.so");
    echo hello_add(3, 4);
?>

然后在浏览器中打开hello.php文件，如果显示7，则说明函数调用成功了。

参考URL

调用a库方法:

(引自:http://group.qqread.com/thread-22305-1-1.html)

把静态库加入PHP：
   把要编译的静态库链接存入环境变量。假设静态库的文件名叫libnpc.a，放在/home目录下。在PHP的安装目录下输入如下命令：export LDFLAGS=”–L/home –lnpc”
   这个环境变量的作用就是让PHP在编译时知道要把这个库也一起编译进去。

编译PHP：
   和普通编译PHP没什么大区别，就是要在./configure的时候加上你的扩展，具体见编写PHP扩展部分。
   当编译好之后可以通过unset LDFLAGS来删除之前的环境变量。

总结：

动态库和静态库相同的地方就是上面橘色的地方，不同的地方so库是紫色的方法，而a库

s#export LDFLAGS=”–L/home –lnpc”

s#./configure

s#make

s#unset LDFLAGS

php | 评论:0 | Trackbacks:0 | 阅读:1385

Submitted by admin on 2011, August 6, 11:43 AM

函数库分为静态库和动态库两种。创建Linux静态库和Linux动态库和使用它们在这里将以举例的形式详述一下。静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库。动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在。

第1步：编辑得到举例的程序--hello.h、hello.c和main.c;

hello.h(见程序1)为该函数库的头文件。
hello.c(见程序2)是函数库的源程序，其中包含公用函数hello，该函数将在屏幕上输出"Hello XXX!"。
main.c(见程序3)为测试库文件的主程序，在主程序中调用了公用函数hello。

--------------------------------------------------------------------------------  
 程序1: hello.h  
#ifndef HELLO_H  
#define HELLO_H  
void hello(const char *name);  
#endif //HELLO_H  
--------------------------------------------------------------------------------  
 程序2: hello.c  
 
#include <stdio.h> 
void hello(const char *name)  
{  
    printf("Hello %s!\n", name);  
}  
--------------------------------------------------------------------------------  
 程序3: main.c  
#include "hello.h"  
int main()  
{  
    hello("everyone");  
    return 0;  
}  
--------------------------------------------------------------------------------

第2步：将hello.c编译成.o文件

无论静态库，还是动态库，都是由.o文件创建的。因此，我们必须将源程序hello.c通过gcc先编译成.o文件。在系统提示符下键入以下命令得到hello.o文件。

# gcc -c hello.c

第3步：由.o文件创建静态库

静态库文件名的命名规范是以lib为前缀，紧接着跟静态库名，扩展名为.a。例如：我们将创建的静态库名为myhello，则静态库文件名就是libmyhello.a。在创建和使用静态库时，需要注意这点。创建静态库用ar命令。在系统提示符下键入以下命令将创建静态库文件libmyhello.a。

# ar cr libmyhello.a hello.o

第4步：在程序中使用静态库

静态库制作完了，如何使用它内部的函数呢？只需要在使用到这些公用函数的源程序中包含这些公用函数的原型声明，然后在用gcc命令生成目标文件时指明静态库名，gcc将会从静态库中将公用函数连接到目标文件中。注意，gcc会在静态库名前加上前缀lib，然后追加扩展名.a得到的静态库文件名来查找静态库文件。在程序3:main.c中，我们包含了静态库的头文件hello.h，然后在主程序main中直接调用公用函数hello。下面先生成目标程序hello，然后运行hello程序看看结果如何。
# gcc -o hello main.c -L. -lmyhello
# ./hello
Hello everyone!
#
我们删除静态库文件试试公用函数hello是否真的连接到目标文件 hello中了。
# rm libmyhello.a
rm: remove regular file `libmyhello.a'? y
# ./hello
Hello everyone!
#
程序照常运行，静态库中的公用函数已经连接到目标文件中了。我们继续看看如何在Linux中创建动态库。我们还是从.o文件开始。

第5步：由.o文件创建动态库文件

动态库文件名命名规范和静态库文件名命名规范类似，也是在动态库名增加前缀lib，但其文件扩展名为.so。例如：我们将创建的动态库名为myhello，则动态库文件名就是libmyhello.so。用gcc来创建动态库。在系统提示符下键入以下命令得到动态库文件libmyhello.so。

# gcc -shared -fPCI -o libmyhello.so hello.o

第6步：在程序中使用动态库

在程序中使用动态库和使用静态库完全一样，也是在使用到这些公用函数的源程序中包含这些公用函数的原型声明，然后在用gcc命令生成目标文件时指明动态库名进行编译。我们先运行gcc命令生成目标文件，再运行它看看结果。
# gcc -o hello main.c -L. -lmyhello
# ./hello
./hello: error while loading shared libraries: libmyhello.so: cannot open shared object file: No such file or directory
#
哦！出错了。快看看错误提示，原来是找不到动态库文件libmyhello.so。程序在运行时，会在/usr/lib和/lib等目录中查找需要的动态库文件。若找到，则载入动态库，否则将提示类似上述错误而终止程序运行。我们将文件libmyhello.so复制到目录/usr/lib中，再试试。
# mv libmyhello.so /usr/lib
# ./hello
Hello everyone!
#
成功了。这也进一步说明了动态库在程序运行时是需要的。
我们回过头看看，发现使用静态库和使用动态库编译成目标程序使用的gcc命令完全一样，那当静态库和动态库同名时，gcc命令会使用哪个库文件呢？抱着对问题必究到底的心情，来试试看。先删除除.c和.h外的所有文件，恢复成我们刚刚编辑完举例程序状态。
# rm -f hello hello.o /usr/lib/libmyhello.so
# ls
hello.c hello.h main.c
#
在来创建静态库文件libmyhello.a和动态库文件libmyhello.so。
# gcc -c hello.c
# ar cr libmyhello.a hello.o
# gcc -shared -fPCI -o libmyhello.so hello.o
# ls
hello.c hello.h hello.o libmyhello.a libmyhello.so main.c
#
通过上述最后一条ls命令，可以发现静态库文件libmyhello.a和动态库文件libmyhello.so都已经生成，并都在当前目录中。然后，我们运行gcc命令来使用函数库myhello生成目标文件hello，并运行程序 hello。
# gcc -o hello main.c -L. -lmyhello
# ./hello
./hello: error while loading shared libraries: libmyhello.so: cannot open shared object file: No such file or directory
#
从程序hello运行的结果中很容易知道，当Linux静态库和Linux动态库同名时， gcc命令将优先使用动态库。

编译 | 评论:0 | Trackbacks:0 | 阅读:1203

Submitted by admin on 2011, August 6, 11:43 AM

如何查看静态库内容 Unix/Linux

以下从最好情况->最坏情况：

1. 最好知道静态库的原文件(.c)，要是知道声明文件(.h)也比较好。

2. ar -t YourFile 看其结构，找其中的原文件。

3. 可以将库文件下到本地用UE打开，然后你就找吧。

另外，看动态库用 nm -D lib*.so

附：

1.ar基本用法
2.nm基本用法命令

　当我们的程序中有经常使用的模块，而且这种模块在其他程序中也会用到，这时按照软件重用的思想，我们应该将它们生成库，使得以后编程可以减少开发代码量。这里介绍两个命令ar和nm，用来对库操作。

1.ar基本用法

　　ar命令可以用来创建、修改库，也可以从库中提出单个模块。库是一单独的文件，里面包含了按照特定的结构组织起来的其它的一些文件（称做此库文件的member）。原始文件的内容、模式、时间戳、属主、组等属性都保留在库文件中。

　　下面是ar命令的格式：

　　ar [-]{dmpqrtx}[abcfilNoPsSuvV] [membername] [count] archive files...

　　例如我们可以用ar rv libtest.a hello.o hello1.o来生成一个库，库名字是test，链接时可以用-ltest链接。该库中存放了两个模块hello.o和hello1.o。选项前可以有‘-‘字符，也可以没有。下面我们来看看命令的操作选项和任选项。现在我们把{dmpqrtx}部分称为操作选项，而[abcfilNoPsSuvV]部分称为任选项。

　　{dmpqrtx}中的操作选项在命令中只能并且必须使用其中一个，它们的含义如下：

d：从库中删除模块。按模块原来的文件名指定要删除的模块。如果使用了任选项v则列出被删除的每个模块。
m：该操作是在一个库中移动成员。当库中如果有若干模块有相同的符号定义(如函数定义)，则成员的位置顺序很重要。如果没有指定任选项，任何指定的成员将移到库的最后。也可以使用'a'，'b'，或'I'任选项移动到指定的位置。
p：显示库中指定的成员到标准输出。如果指定任选项v，则在输出成员的内容前，将显示成员的名字。如果没有指定成员的名字，所有库中的文件将显示出来。
q：快速追加。增加新模块到库的结尾处。并不检查是否需要替换。'a'，'b'，或'I'任选项对此操作没有影响，模块总是追加的库的结尾处。如果使用了任选项v则列出每个模块。这时，库的符号表没有更新，可以用'ar s'或ranlib来更新库的符号表索引。
r：在库中插入模块(替换)。当插入的模块名已经在库中存在，则替换同名的模块。如果若干模块中有一个模块在库中不存在，ar显示一个错误消息，并不替换其他同名模块。默认的情况下，新的成员增加在库的结尾处，可以使用其他任选项来改变增加的位置。
t：显示库的模块表清单。一般只显示模块名。
x：从库中提取一个成员。如果不指定要提取的模块，则提取库中所有的模块。
　　下面在看看可与操作选项结合使用的任选项：

a：在库的一个已经存在的成员后面增加一个新的文件。如果使用任选项a，则应该为命令行中membername参数指定一个已经存在的成员名。
b：在库的一个已经存在的成员前面增加一个新的文件。如果使用任选项b，则应该为命令行中membername参数指定一个已经存在的成员名。
c：创建一个库。不管库是否存在，都将创建。
f：在库中截短指定的名字。缺省情况下，文件名的长度是不受限制的，可以使用此参数将文件名截短，以保证与其它系统的兼容。
i：在库的一个已经存在的成员前面增加一个新的文件。如果使用任选项i，则应该为命令行中membername参数指定一个已经存在的成员名(类似任选项b)。
l：暂未使用
N：与count参数一起使用，在库中有多个相同的文件名时指定提取或输出的个数。
o：当提取成员时，保留成员的原始数据。如果不指定该任选项，则提取出的模块的时间将标为提取出的时间。
P：进行文件名匹配时使用全路径名。ar在创建库时不能使用全路径名（这样的库文件不符合POSIX标准），但是有些工具可以。
s：写入一个目标文件索引到库中，或者更新一个存在的目标文件索引。甚至对于没有任何变化的库也作该动作。对一个库做ar s等同于对该库做ranlib。
S：不创建目标文件索引，这在创建较大的库时能加快时间。
u：一般说来，命令ar r...插入所有列出的文件到库中，如果你只想插入列出文件中那些比库中同名文件新的文件，就可以使用该任选项。该任选项只用于r操作选项。
v：该选项用来显示执行操作选项的附加信息。
V：显示ar的版本。
2.nm基本用法命令

　　nm用来列出目标文件的符号清单。下面是nm命令的格式：

　　如果没有为nm命令指出目标文件，则nm假定目标文件是a.out。下面列出该命令的任选项，大部分支持"-"开头的短格式和"—"开头的长格式。

-A、-o或--print-file-name：在找到的各个符号的名字前加上文件名，而不是在此文件的所有符号前只出现文件名一次。
例如nm libtest.a的输出如下：

CPThread.o:
00000068 T Main__8CPThreadPv
00000038 T Start__8CPThread
00000014 T _._8CPThread
00000000 T __8CPThread
00000000 ? __FRAME_BEGIN__
.......................................

则nm -A 的输出如下：

libtest.a:CPThread.o:00000068 T Main__8CPThreadPv
libtest.a:CPThread.o:00000038 T Start__8CPThread
libtest.a:CPThread.o:00000014 T _._8CPThread
libtest.a:CPThread.o:00000000 T __8CPThread
libtest.a:CPThread.o:00000000 ? __FRAME_BEGIN__
..................................................................

-a或--debug-syms：显示调试符号。
-B：等同于--format=bsd，用来兼容MIPS的nm。
-C或--demangle：将低级符号名解码(demangle)成用户级名字。这样可以使得C++函数名具有可读性。
-D或--dynamic：显示动态符号。该任选项仅对于动态目标(例如特定类型的共享库)有意义。
-f format：使用format格式输出。format可以选取bsd、sysv或posix，该选项在GNU的nm中有用。默认为bsd。
-g或--extern-only：仅显示外部符号。
-n、-v或--numeric-sort：按符号对应地址的顺序排序，而非按符号名的字符顺序。
-p或--no-sort：按目标文件中遇到的符号顺序显示，不排序。
-P或--portability：使用POSIX.2标准输出格式代替默认的输出格式。等同于使用任选项-f posix。
-s或--print-armap：当列出库中成员的符号时，包含索引。索引的内容包含：哪些模块包含哪些名字的映射。
-r或--reverse-sort：反转排序的顺序(例如，升序变为降序)。
--size-sort：按大小排列符号顺序。该大小是按照一个符号的值与它下一个符号的值进行计算的。
-t radix或--radix=radix：使用radix进制显示符号值。radix只能为"d"表示十进制、"o"表示八进制或"x"表示十六进制。
--target=bfdname：指定一个目标代码的格式，而非使用系统的默认格式。
-u或--undefined-only：仅显示没有定义的符号(那些外部符号)。
-l或--line-numbers：对每个符号，使用调试信息来试图找到文件名和行号。对于已定义的符号，查找符号地址的行号。对于未定义符号，查找指向符号重定位入口的行号。如果可以找到行号信息，显示在符号信息之后。
-V或--version：显示nm的版本号。
--help：显示nm的任选项。

编译 | 评论:0 | Trackbacks:0 | 阅读:1249

Submitted by admin on 2011, August 6, 11:42 AM

Linux动态库、静态库加载基础
静态库
   在linux环境中, 使用ar命令创建静态库文件.如下是命令的选项:
      d -----从指定的静态库文件中删除文件
      m -----把文件移动到指定的静态库文件中
      p -----把静态库文件中指定的文件输出到标准输出
      q -----快速地把文件追加到静态库文件中
      r -----把文件插入到静态库文件中
      t -----显示静态库文件中文件的列表
      x -----从静态库文件中提取文件
      还有多个修饰符修改以上基本选项,详细请man ar 以下列出三个:
      a -----把新的目标文件(*.o)添加到静态库文件中现有文件之后
      b -----***************************************之前
      v -----使用详细模式    ar 命令的命令行格式如下:    ar [-]{dmpqrtx}[abcfilNoPsSuvV] [membername] [count] archive files...    eg:       ar -crs hello.a hello.c
动态库
1.创建共享库
   gcc -c error.c
   gcc -c errorlog.c
   gcc -shared -o libapue.so error.o errorlog.o
这样就创建了共享库!
2.编译共享库
假设共享库位于当前目录(即跟程序文件相同的目录中)
gcc -o test -L. -lapue test.c
这样就编译出了不包含函数代码可执行文件了,但是但你运行时会发现linux动态加载器打不到libapue.so文件.
可以用ldd 命令查看可执行文件依赖什么共享库:
ldd test
如何才能让动态加载器发现库文件呢?有两种方法可以解决:
   LD_LIBRARY_PATH 环境变量
   /etc/ld.so.conf文件
1.环境变量
   export LD_LIBRARY_PATH="dir$LD_LIBRARY_PATH"
2.修改/etc/ld.so.conf文件.位于/etc/ld.so.conf
一般应用程序的库文件不与系统库文件放在同一个目录下,一般把应用程序的共享库文件放在/usr/local/lib下,新建一个属于自己的目录apue,然后把刚才libapue.so复制过去就行了
同时在/etc/ld.so.conf中新增一行:
/usr/local/lib/apue
实例分析：
test.c
      #include
      #include "print.h"

      int main(void){
         printf("Function : main/n");
         print();
         printf("out main/n");

         return 0;
      }

   print.c
      #include
      #include
      int print(void){

         printf("Function : print/n");
         printf("Hello world/n");
         printf("out print/n");
         return 0;
      }
   1 : 创建动态库：
      gcc -o libprint.so -fPIC -rdynamic -shared print.c
   2 : 创建可执行文件
      gcc -o test -I$(INC_PATH) -L$(LIB_PATH) -lprint test.c
　　３：如果出现下列错误
   　　　　./test: error while loading shared libraries: libprint.so: cannot open 　　shared object file: No such file or directory
　　　　　　解决方法：
　　　　　　　１：　export LD_LIBRARY_PATH=DIR:$LD_LIBRARY_PATH
　　　　　　　２：　修改文件/etc/ld.so.config文件，在末行加上你的库文件目录，最后,ldconfig刷新ld.so.cache文件即可。可以用strings命令查看ld.so.cache是否刷新：strings /etc/ld.so.cache | grep print

４： ldd命令查看动态连接库

         linux-gate.so.1 =>  (0xb7f0e000)
         libprint.so => not found
         libc.so.6 => /lib/tls/i686/cmov/libc.so.6 (0xb7d82000)
         /lib/ld-linux.so.2 (0xb7ef4000)
５：　nm查看程序中有那些符号
　　　　　　
049f18 d _DYNAMIC
08049ff4 d _GLOBAL_OFFSET_TABLE_
080485cc R _IO_stdin_used
      w _Jv_RegisterClasses
08049f08 d __CTOR_END__
08049f04 d __CTOR_LIST__
08049f10 D __DTOR_END__
08049f0c d __DTOR_LIST__
080485ec r __FRAME_END__
08049f14 d __JCR_END__
08049f14 d __JCR_LIST__
0804a018 A __bss_start
0804a010 D __data_start
08048580 t __do_global_ctors_aux
08048450 t __do_global_dtors_aux
0804a014 D __dso_handle
      w __gmon_start__
0804857a T __i686.get_pc_thunk.bx
08049f04 d __init_array_end
08049f04 d __init_array_start
08048510 T __libc_csu_fini
08048520 T __libc_csu_init
      U __libc_start_main@@GLIBC_2.0
0804a018 A _edata
0804a020 A _end
080485ac T _fini
080485c8 R _fp_hw
0804839c T _init
08048420 T _start
0804a018 b completed.6625
0804a010 W data_start
0804a01c b dtor_idx.6627
080484b0 t frame_dummy
080484d4 T main
      U print
      U puts@@GLIBC_2.0
６：　strip取出程序中符号
７：　strings查看可执行文件中的文本信息
　　
参考：http://www.kuqin.com/linux/20081103/25444.html
   http://hi.baidu.com/li_zhongnan/blog/item/1d9bf3c2e13a9f32e4dd3b4f.html

编译 | 评论:0 | Trackbacks:0 | 阅读:1330

Submitted by admin on 2011, August 6, 11:41 AM

1. Linux静态库和动态库的命名规则：

静态函数库：静态库的名字一般是libxxx.a，利用静态库编译生成的文件比较大，因为整个静态库所有的数据都会被整合进目标代码中。

a) 优点：编译后，可执行文件不需要外部支持；

b) 缺点：生成的可执行程序大；静态库改变了，就需要重新编译可执行程序。

动态函数库：动态库的名字一般是libxxx.so，相对于静态库，动态函数库在编译的时候并没有被编译进目标代码中，你的程序执行到相关函数时才调用函数库里面相应的函数，因此使用动态函数库生成的可执行文件比较小。由于函数库没有编译进可执行程序，而是程序运行时动态的申请调用，所以程序的运行环境中必须提供相应的库。动态函数库的改变也不会影响可执行程序，针对可执行程序的动态函数库升级也比较容易。

a) 优点：实现进程的资源共享，当程序在运行的时候需要调用某个动态链接库函数时候，OS会先查看所有正在运行的程序，看内存里面是否已经有此函数的拷贝了，有责共享那个拷贝，没有才会链接载入，这样会大大节省OS的内存资源；

b) 优点：升级容易，升级动态链接库即可，不需要重新编译可执行程序；

2. Gcc/g++的编译链接：

通常，对函数的链接是在编译期的时候完成的，所有相关的对象文件与相关联的library被链接成一个可执行文件，这就是使用静态库的编译过程，

而动态库技术：对一些库函数的链接载入推迟到程序运行的时候。

但是，不管是使用静态库还是使用动态库，这些库文件都是由*.o文件生成的，在给编译器gcc传不同的参数，就会生成相应的静态库或者是动态库了。

3. 静态库和动态库的创建过程：

a) 创建静态库：

在linux环境下，创建静态库是使用ar命令，具体的选项可以man查看下，例子：

ar -rt libtest.a error.o show.o test.o

这样就创建了libtest.a静态库文件。

b) 创建动态库：

使用gcc编译.c文件的使用，使用-fPIC标签，然后在使用*.o文件生成动态库文件的时候，传递-shared标签给gcc，例子：

Gcc –fPIC –c file1.c

Gcc -fPIC -c file2.c

Gcc –shared libtest.so file1.o file2.o

这样就创建了libtest.so动态库文件。

4. 使用静态库和动态库的方法：

动态库文件和静态库文件的使用方法基本上差不多，在gcc的command里面使用-Lpath和-lxxx标签：

Gcc file1.o file2.o –Lpath –lxxx –o yourprogrammer

编译器会先到path下面寻找libxxx.so文件，如果没有找到，继续寻找libxxx.a文件。

那么动态库函数文件，是在程序运行的过程中决定是否载入的，那么我们需要告诉编译器，去哪里能找到动态库函数文件，在linux或者类unix操作系统里面是使用LD_LIBRARY_PATH环境变量来实现的。

编译 | 评论:0 | Trackbacks:0 | 阅读:1260

Submitted by admin on 2011, August 4, 8:25 PM

静态库
   在linux环境中, 使用ar命令创建静态库文件.如下是命令的选项:
      d -----从指定的静态库文件中删除文件
      m -----把文件移动到指定的静态库文件中
      p -----把静态库文件中指定的文件输出到标准输出
      q -----快速地把文件追加到静态库文件中
      r -----把文件插入到静态库文件中
      t -----显示静态库文件中文件的列表
      x -----从静态库文件中提取文件
   还有多个修饰符修改以上基本选项,详细请man ar 以下列出三个:
      a -----把新的目标文件(*.o)添加到静态库文件中现有文件之后
      b -----***************************************之前
      v -----使用详细模式
ar 命令的命令行格式如下:
   ar [-]{dmpqrtx}[abcfilNoPsSuvV] [membername] [count] archive files...
参数archive定义库的名称, files是库文件中包含的目标文件的清单, 用空格分隔每个文件.
比如创建一个静态库文件的命令如下:
   ar r libapue.a error.o errorlog.o lockreg.o
这样就了libapue.a静态库文件, 可以用 t 选项显示包含在库中的文件
   创建库文件之后,可以创建这个静态库文件的索引来帮助提高和库连接的其他程序的编译速度.使用ranlib程序创建库的索引,索引存放在库文件内部.
   ranlib libapue.a
用nm程序显示存档文件的索引,它可以显示目标文件的符号
nm libapue.a | more
如果是显示目标文件的符号:
nm error.o | more
如何使用呢?如下所示:
gcc -o test test.c libapue.a
这样就可以在test.c中调用在libapue.a中的函数了.
动态库
1.创建共享库
   gcc -shared -o libapue.so error.o errorlog.o
这样就创建了共享库!
2.编译共享库
假设共享库位于当前目录(即跟程序文件相同的目录中)
gcc -o test -L. -lapue test.c
这样就编译出了不包含函数代码可执行文件了,但是但你运行时会发现linux动态加载器打不到libapue.so文件.
可以用ldd 命令查看可执行文件依赖什么共享库:
ldd test
如何才能让动态加载器发现库文件呢?有两种方法可以解决:
   LD_LIBRARY_PATH 环境变量
   /etc/ld.so.conf文件
1.环境变量
   export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:."
2.修改/etc/ld.so.conf文件.位于/etc/ld.so.conf
一般应用程序的库文件不与系统库文件放在同一个目录下,一般把应用程序的共享库文件放在/usr/local/lib下,新建一个属于自己的目录apue,然后把刚才libapue.so复制过去就行了
同时在/etc/ld.so.conf中新增一行:
/usr/local/lib/apue
以后在编译程序时加上编译选项:
-L/usr/local/lib/apue -lapue
这样就可以使用这个libapue.so共享库了!!

linux | 评论:0 | Trackbacks:0 | 阅读:1184

Submitted by admin on 2011, August 3, 5:25 PM

实现目标:

A 服务器上 /opt/web 目录,与B服务器上 /opt/web目录实现同步。即：B主动与A进行同步。

OS: Reaht AS4

A Server 192.168.1.2 /opt/web

B Server 192.168.1.3 /opt/web

一. A Server config

1.rsync 系统自带, 需要使用 --deamon 方式进行启动,服务端口是 TCP 873

2. vi /etc/xinetd.d/rsync 修改 disable =yes 为 disable =no ,修改后的文件如下

# default: off

# description: The rsync server is a good addition to an ftp server, as it \

# allows crc checksumming etc.

service rsync

{

disable = no

socket_type = stream

wait = no

user = root

server = /usr/bin/rsync

server_args = --daemon

log_on_failure += USERID

}

3. service xinetd restart,重启 xinted 服务

4. 编辑主要配置文件 /etc/rsyncd.conf

vi /etc/rsyncd.conf

uid = nobody

gid = nobody

use chroot = no

max connections = 4

pid file = /var/run/rsyncd.pid

lock file = /var/run/rsyncd.lock

log file = /var/log/rsyncd.log

[web]

path = /opt/web

ignore errors

read only = true

list = false

hosts allow = 192.168.0.0 # 允许的IP地址

hosts deny = 0.0.0.0/32 # 禁止的IP 地址

auth users = backup # 认证用户名,此例是 backup

secrets file = /etc/backup.pass #认证用户的密码文件

5 编辑服务器的密码文件 /etc/backup.pass

vi /etc/backup.pass

backup:123456

6. chmod 400 /etc/backup.pass

二. B Server config

1. 编辑rsync连接时的密码文件 /etc/rsync_client.pass

vi /etc/rsync_client.pass

123456 # 只需要配置连接时使用的密码即可，必须与A服务器上定义的密码相同.

2. chmod 600 /etc/rsync_client.pass

3. 使用 rsync 命令连接服务器,实现文件同步

rsync -vzrtopg --progress --delete --password-file=/etc/rsync_client.pass backup@192.168.1.2::web /opt/web

4. 使用 --execlude= 排除不需要同步的文件后缀名

rsync -vzrtopg --progress --delete --password-file=/etc/rsync_client.pass --exclude="*.tmp" backup@192.168.1.2::web /opt/web

5. 使用 --execlude-from= 排除不需要同步的目录

[root@ASB opt]# rsync -vzrtopg --progress --delete --password-file=/etc/rsync_client.pass --exclude-from=/opt/pcdir backup@192.168.1.2::web /opt/web

/opt/pcdir 文件的内容如下

cat /opt/pcdir

temp/

参数说明

-vzrtopg里的

v是verbose，

z是压缩，

r是recursive，

topg都是保持文件原有属性如属主、时间的参数

----progress

是指显示出详细的进度情况

--delete

是指如果服务器端删除了这一文件，那么客户端也相应把文件删除，保持真正的一致

--exclude="*.tmp"

不包含某些文件

--execlude-from= 排除不需要同步的目录

--password-file

指定CLIENT端密码文件存放路径

/opt/web/

指定CLIENT端存放镜象目的路径

选项说明

-v, --verbose 详细模式输出

-q, --quiet 精简输出模式

-c, --checksum 打开校验开关，强制对文件传输进行校验

-a, --archive 归档模式，表示以递归方式传输文件，并保持所有文件属性，等于-rlptgoD

-r, --recursive 对子目录以递归模式处理

-R, --relative 使用相对路径信息

rsync foo/bar/foo.c remote:/tmp/

则在/tmp目录下创建foo.c文件，而如果使用-R参数：

rsync -R foo/bar/foo.c remote:/tmp/

则会创建文件/tmp/foo/bar/foo.c，也就是会保持完全路径信息。

-b, --backup 创建备份，也就是对于目的已经存在有同样的文件名时，将老的文件重新命名为~filename。可以使用--suffix选项来指定不同的备份文件前缀。

--backup-dir 将备份文件(如~filename)存放在在目录下。

-suffix=SUFFIX 定义备份文件前缀

-u, --update 仅仅进行更新，也就是跳过所有已经存在于DST，并且文件时间晚于要备份的文件。(不覆盖更新的文件)

-l, --links 保留软链结

-L, --copy-links 想对待常规文件一样处理软链结

--copy-unsafe-links 仅仅拷贝指向SRC路径目录树以外的链结

--safe-links 忽略指向SRC路径目录树以外的链结

-H, --hard-links 保留硬链结

-p, --perms 保持文件权限

-o, --owner 保持文件属主信息

-g, --group 保持文件属组信息

-D, --devices 保持设备文件信息

-t, --times 保持文件时间信息

-S, --sparse 对稀疏文件进行特殊处理以节省DST的空间

-n, --dry-run现实哪些文件将被传输

-W, --whole-file 拷贝文件，不进行增量检测

-x, --one-file-system 不要跨越文件系统边界

-B, --block-size=SIZE 检验算法使用的块尺寸，默认是700字节

-e, --rsh=COMMAND 指定替代rsh的shell程序

--rsync-path=PATH 指定远程服务器上的rsync命令所在路径信息

-C, --cvs-exclude 使用和CVS一样的方法自动忽略文件，用来排除那些不希望传输的文件

--existing 仅仅更新那些已经存在于DST的文件，而不备份那些新创建的文件

--delete 删除那些DST中SRC没有的文件

--delete-excluded 同样删除接收端那些被该选项指定排除的文件

--delete-after 传输结束以后再删除

--ignore-errors 及时出现IO错误也进行删除

--max-delete=NUM 最多删除NUM个文件

--partial 保留那些因故没有完全传输的文件，以是加快随后的再次传输

--force 强制删除目录，即使不为空

--numeric-ids 不将数字的用户和组ID匹配为用户名和组名

--timeout=TIME IP超时时间，单位为秒

-I, --ignore-times 不跳过那些有同样的时间和长度的文件

--size-only 当决定是否要备份文件时，仅仅察看文件大小而不考虑文件时间

--modify-window=NUM 决定文件是否时间相同时使用的时间戳窗口，默认为0

-T --temp-dir=DIR 在DIR中创建临时文件

--compare-dest=DIR 同样比较DIR中的文件来决定是否需要备份

-P 等同于 --partial

--progress 显示备份过程

-z, --compress 对备份的文件在传输时进行压缩处理

--exclude=PATTERN 指定排除不需要传输的文件模式

--include=PATTERN 指定不排除而需要传输的文件模式

--exclude-from=FILE 排除FILE中指定模式的文件

--include-from=FILE 不排除FILE指定模式匹配的文件

--version 打印版本信息

--address 绑定到特定的地址

--config=FILE 指定其他的配置文件，不使用默认的rsyncd.conf文件

--port=PORT 指定其他的rsync服务端口

--blocking-io 对远程shell使用阻塞IO

-stats 给出某些文件的传输状态

--progress 在传输时现实传输过程

--log-format=formAT 指定日志文件格式

--password-file=FILE 从FILE中得到密码

--bwlimit=KBPS 限制I/O带宽，KBytes per second

-h, --help 显示帮助信息

linux | 评论:0 | Trackbacks:0 | 阅读:1147

Submitted by admin on 2011, August 3, 10:08 AM

我有种机器，有 4 个网卡，想在上面整 4 个虚拟机。所以让不同的虚拟机，使用不同的网卡。这样来做桥接设备。方便使用。记录一下方法，如下。

1.安装 xen 虚拟化

最开始当然得使用软件源来安装虚拟化。用 163 的吧，速度不错。

perl -i -pe 's/mirror.centos.org/mirrors.163.com/g;s/^#baseurl/baseurl/g;s/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-Base.repo
yum -y groupinstall Virtualization

我们计划的设置如下
eth0 – xenbr0 – Dom0, DomN
eth1 – xenbr1 – DomX+1
eth2 – xenbr2 – DomX+2
eth3 – xenbr3 – DomX+3

4个网卡，分别桥接，然后让三个虚拟机分别接到三个机器上

2. 修改 xend 的配置文件，让它支持多个网卡，不使用默认的脚本

在 /etc/xen/xend-config.sxp 文件中的 (network-script network-bridge) 修改成 (network-script php-oa-network-multi-bridge).这样启用我们自己的脚本来生成桥接的设备

perl -i -pe 's/\(network-script network-bridge\)/#\(network-script network-bridge\)\n\(network-script php-oa-network-multi-bridge\)/g' /etc/xen/xend-config.sxp

3. 写自己自定的脚本，来生成自己所需要的网卡数量和绑定的位置，如上面的计划中

perl -le 'for $num (0 .. 3){print "/etc/xen/scripts/network-bridge \"\$@\" vifnum=$num netdev=eth$num bridge=xenbr$num" }' > /etc/xen/scripts/php-oa-network-multi-bridge
chmod u+x /etc/xen/scripts/php-oa-network-multi-bridge

这样会生成一个 /etc/xen/scripts/php-oa-network-multi-bridge 内包含如下的内容。$@ 是用来接收 shell 命令中的 start,stop,status 的命令的。记的要加执行的权限，可一定不能忘记.

/etc/xen/scripts/network-bridge "$@" vifnum=0 netdev=eth0 bridge=xenbr0
/etc/xen/scripts/network-bridge "$@" vifnum=1 netdev=eth1 bridge=xenbr1
/etc/xen/scripts/network-bridge "$@" vifnum=2 netdev=eth2 bridge=xenbr2
/etc/xen/scripts/network-bridge "$@" vifnum=3 netdev=eth3 bridge=xenbr3

4.配置物理网卡，让开机就能启动

好了，在使用上面的脚本成前面，我们需要保证这几个网卡配置是能正常启动的。
所以我们要修改二个地方，ONBOOT=yes 和 BOOTPROTO=static 这二个，网卡才能正常的启动.

perl -i -pe "s/ONBOOT=no/ONBOOT=yes/g;s/BOOTPROTO=dhcp/BOOTPROTO=static/g" /etc/sysconfig/network-scripts/ifcfg-eth{1,2,3}

5. 测试桥接

下面的命令就不用解释了，还可以用 ifconfig 检查

/etc/xen/scripts/ChinaCache-network-multi-bridge start
/etc/xen/scripts/ChinaCache-network-multi-bridge status
/etc/xen/scripts/ChinaCache-network-multi-bridge stop

6. 安装第一个虚拟机

下面的命令是用来安装第一个虚拟机的,其它的虚拟机直接 copy 出来就行。然后只要修改其它机器的配置文件就行了。

/usr/sbin/virt-install -p --paravirt --name=node1 -s 5 --ram=8192 --vcpus=2 --file=/xen/node1 --location=nfs:123.125.162.7:/mnt --extra-args="ip=123.125.162.45 netmask=255.255.255.192 gateway=123.125.162.1 dns=202.106.0.20" --network bridge=xenbr0 noipv6

以上参数中
–extra-args 这个是传送给启动时的内核用的。
–network 是设置网络的连接方法，还有桥接到那个设备
-s 生成的文件大小 G 为单位
–ram 内存设置
–file 系统文件存放的位置

7. 设置自动启动

当主系统启动时，虚拟机启动,自己有几个虚拟机设置几个

virsh autostart node1

8. 其它虚拟机的安装

其它的虚拟机安装比较容易，直接 copy 上面的 /xen/node1 这个操作系统的文件叫别的名字，另外新建几个其它机器的配置文件

cp /etc/xen/node1 /etc/xen/node{1,2,3}

并修改其中几个参数

name = "node1"
disk = [ "tap:aio:/xen/node1,xvda,w" ]
vif = [ "mac=00:16:36:7b:c9:e3,bridge=xenbr0,script=vif-bridge" ]

如上几个参数，disk 指向其它的参数。vif 是指本机的 MAC 地址，xenbr0 – xenbr3 是可以桥接的设备
如果要新加硬盘，可以使用下面的语法，来加入物理硬盘

disk = [ "tap:aio:/xen/node1,xvda,w",
"phy:/dev/sdb,ioemu:sdb,w",
"phy:/dev/sdc,ioemu:sdc,w",
]

以下经验参考： http://www.cnblogs.com/yangyh/archive/2010/07/16/1778516.html

xenbr0 是会连接vif0.0,vifN.0 (N 表示 xm list 中的 id 号，表示第几个 id 的虚拟主机）
peth0 可以将peth0看作etho的别名
vif0.0表示dom0接口,vif1.0表示dom ID=1的接口(重启或新建几个domain,ID更改后你会发现vif1.0变成vif2.0..3.0了)

如果在xenbr0中删除vif0.0,则在domain中无法ping通本机,但能ping通通过eth0连接的机器,比如本机连接的路由器
如果在xenbr0中删除vif1.0,则在domain中就没有网卡了(相应的vif1.1表示ID为1的DOMAIN的第二块网卡)
如果在xenbr0中删除peth0,则能ping能本机,而无法ping通路由器或局域网其它机器

转

虚拟化 | 评论:0 | Trackbacks:0 | 阅读:1524

Records:1075«‹57 58 59 60 616263 64 65 66 ›»

« 2026年03月 »