分类 开发技术 下的文章

LFS 6.7中配置telnet服务并使用PuTTY链接

  安装完了LFS,有个问题比较烦人,那就是中文乱码。
  1.jpg

  没办法,毕竟字符界面下中文编码无法做到原生支持,要在Linux字符界面中支持中文显示,需要安装中文环境,上网找了些资料,感觉都不太好,zhcon虽然经典,但是很久没有更新了,最后放弃了,还是曲线救国吧。
  
  其实字符界面中的中文字符编码都是正确的,只是显示出了问题,那就换个前端显示,以远程连接的方式连接到LFS,所以就想到了telnet和ssh,先试试telnet吧,只要telnet客户端能够支持中文显示就可以了,这样的客户端很多呀,像PuTTY、SecureCRT等等,既然定了方案,那就开工吧。。。
  
  首先,在LFS中安装telnet服务telnetd,由于inetutils附带了一份,只是被LFS屏蔽了,配置编译时使用了--disable-servers禁止了telnetd的构建,只要去掉改该编译选项就可以了:
  ./configure --prefix=/usr --libexecdir=/usr/sbin \
  --localstatedir=/var --disable-ifconfig \
  --disable-logger --disable-syslogd --disable-whois \
  [--disable-servers,去掉该编译选项]
  
  重新编译安装inetutils就可以了
  
  然后,配置telnetd服务
  在/etc目录中创建inetd.conf,添加如下参数行:
  telnet stream tcp nowait root /usr/sbin/telnetd telnetd
  
  最后,启动inetd服务
  
  直接执行命令inetd即可
  
  如果要让inetd开机自启动,方案很多,这里给出一种:
  在/etc/rc.d/rc3.d目录下创建脚本S30inetd:
  输入内容:
  #! /bin/sh
  inetd
  
  即可,如果运行级不是3,在对应的rc*.d目录下创建即可
  
  好了telnet服务已经开启,远程连接到LFS虚拟机即可。
  
  又有新的问题了,使用PuTTY连接的时候,登陆很慢,因为telnet服务需要反向验证客户端,需要在hosts文件中对客户端IP添加一条DNS记录来解决该问题
  
  好了,最后在PuTTY中将字符编码设置为UTF8,这样PuTTY就能正确解码UTF8编码的中文字符了。
2.jpg

  OK,终于看到正确的中文显示了
3.png
  

基于Ubuntu 10.10 构建LFS 6.7总结

  首先扫个盲,呵呵。
  LFS,即Linux From Scratch,LFS不像Ubuntu,Fedora,SUSE等Linux发行版以最终产品的形式发布,而是以文档的形式发布一套构建流程,指导使用者,从源代码自行构建一个LFS系统,也就是说你拿到的LFS实际上只是一个指导手册,其中指明了以下几点::

  1. 什么是LFS
  2. 如何准备构建LFS
  3. 如何获取构建LFS所需的源码包
  4. 如何编译LFS
  5. 如何配置LFS

  从LFS的构建过程中,能够学习到一个常规Linux系统的结构,以及如何去配置Linux系统,毕竟Linus给你的只是Linux内核,而一个真正可用的Linux系统是由很多部件一起工作的。
  当然不能期望通过一个LFS就让你知晓Linux的一切,毕竟这不太现实,而且LFS的目标很明确,就是指导用户构建一个可用的Linux系统,所以LFS不会对其中的操作用动辄几百字去解释透彻,但是对于一个具备Linux基本使用能力的人来说,LFS的解释已经很详细了,能够让使用者知其然,还能知其所以然。

  这里我想把自己的LFS构建经验总结一下,主要是过程中遇到的问题,列出来,欢迎大家围观,呵呵

LFS的主要构建流程:

  1. 准备。包括为LFS分配空间,设置分区,在宿主系统安装相关组件等
  2. 编译一个临时的纯净系统。考虑到现行的发行版中都会或多或少做一些优化调整,这会导致直接编译出来的系统不具备通用性,所以需要基于宿主系统构建一个临时的纯净系统,新的LFS系统所需的相关组件都会在这个纯净的环境中编译
  3. 在上面的纯净系统中编译LFS系统
  4. 配置LFS系统,以使系统能够正常工作
      上面的流程在LFS Book中都以指令的形式列了出来,我们要做的就是按照LFS Book中的说明,一点一点敲字母就可以了,这需要具备一些Linux的基本使用知识来理解操作的含义。

  具体细节这里就不多说了,大家看LFS Book就可以了,这里顺便共享几个文件,方便大家使用。

  我这里主要想把自己编译LFS时遇到的问题总结一下,共享出来:

  我这次编译的LFS是最新(2011.2.12)的6.7版本,用的宿主系统是Ubuntu 10.10,基于VMware WOrkstation 7.1虚拟机。虚拟机使用的是双硬盘,其中一个/dev/sda安装了Ubuntu 10.10,LFS则编译在了另一个硬盘/dev/sdb,这也是为了在制作完LFS后,能够方便的在独立的虚拟机中运行。

Ubuntu的安装就不说了,下面直接说说编译LFS时出现的问题:

  1. 编译Binutls出错
    一开始的时候就出错了,比较打击人。。。
    这里需要安装build-essential和texinfo两个包,因为Ubuntu中没有

  2. 编译gcc出错
    原因很简单,查找问题很恼火。。。
    因为在输出指令的时候,输入languages时少输了末尾的s

  3. 编译glibc出错

因为Ubuntu中安装的是mawk,不是gawk
这里需要安装gawk

  1. 编译过程中要注意指令的大小写,否则很容易出现问题
      这是个细节问题,因为Linux中是区分大小写的,所以要格外注意。因为我是一边在VMWare中操作,一边看LFS Book,LFS Book不是最大化的显示,所以输入指令的时候不容易区分大小写,像C和c,S和s,容易出错,结果编译不过去,仔细一些就可以了

  2. 安装完成LFS后,启动出现问题
      重新启动以引导LFS的时候卡在了这里:kernel_thread_helper 0x6/0x10,原因是根文件系统无法加载,这个问题被称作kernel panic,似乎遇到的朋友还比较多。
      我之前没有编译过Linux内核,并不懂内核配置,但是LFS Book对这里没有任何说明,所以在这里郁闷了很久。最后,找到原因是Linux内核的默认编译选项对sata硬件的支持不完整,有些sata硬件的驱动没有编译进去,比如我使用的VMware 7.1中的sata驱动:
    LSI Logic / Symbios Logic 53c1030 PCI-X Fusion-MPT Dual Ultra320 SCSI
      这里需要修改编译选项,以支持该sata驱动。我想其他的驱动支持,道理也差不多,注意添加对应的驱动支持就可以了。可以通过lspci命令了解到系统中的pci设备都有哪些,便于在编译内核时选择正确的驱动。这里的lspci是pciutils包中的工具,没有的话需要安装。

我这里说说我选择的编译选项,这里参考了网上的一些资料,对于同样使用VMWare体验LFS的朋友或许会有帮助:

Linux Kernel Configuration
    -> Device Drivers
        -> SCSI device support
            - > SCSI disk support   选中

Linux Kernel Configuration
   -> Device Drivers
       -> Fusion MPT device support   选中
            -> 选中子项(不确定的话就全部选中好了)

Linux Kernel Configuration
    -> Device Drivers
        -> SCSI device support
            - > SCSI low-level drivers  选中
                -> 选中和Fusion-MPT相关的底层驱动以及VMWare PVSCSI driver support
  1. 调整/etc/ftab和/boot/grub/grub.cfg以正确引导独立的LFS并加载分区

  因为我的目的是在独立的硬盘中编译LFS,这样将LFS的虚拟硬盘文件拷贝到新的虚拟机中就可以加载运行了,所以目标系统中是只有一个硬盘的,需要调整上面的两个文件,将原来的sdb对应的改成sda即可,因为LFS所在硬盘是以第二硬盘的形式挂到虚拟机中的。

  grub.cfg是在加载Linux时使用的,这里需要调整;fstab是在Linux启动时,加载分区中的文件系统的,这里也需要修改。

  好了一切正常,截几张图过来看看,呵呵:
1.png

2.png

用PuTTY Telnet过去的效果,算是临时解决了中文无法显示的问题
3.jpg

(转)经常用Linux 但是你知道它和Unix区别吗

  有很多初学Linux的人比较关心Linux和windows的区别,这里还有一点就是Linux Unix的区别,弄清楚一些区别有助于我们对操作系统的了解.这里叙述Linux Unix的区别.

  Linux和UNIX的最大的区别是,前者是开发源代码的自由软件,而后者是对源代码实行知识产权保护的传统商业软件.

  这应该是他们最大的不同,这种不同体现在用户对前者有很高的自主权,而对后者却只能去被动的适应;这种不同还表现在前者的开发是处在一个完全开放的环境之中,而后者的开发完全是处在一个黑箱之中,只有相关的开发人员才能够接触的产品的原型.

  Linux 的源头要追溯到最古老的UNIX.1969年,Bell实验室的Ken Thompson开始利用一台闲置的 PDP-7计算机开发了一种多用户,多任务操作系统.很快,Dennis Richie加入了这个项目,在他们共同努力下诞生了最早的UNIX.Richie受一个更早的项目--MULTICS的启发,将此操作系统命名为 Unix.早期UNIX是用汇编语言编写的,但其第三个版本用一种崭新的编程语言C重新设计了.C是Richie设计出来并用于编写操作系统的程序语言.通过这次重新编写,Unix得以移植到更为强大的 DEC PDP-11/45与11/70计算机上运行.后来发生的一切,正如他们所说,已经成为历史.Unix从实验室走出来并成为了操作系统的主流,现在几乎每个主要的计算机厂商都有其自有版本的Unix.

  Linux起源于一个学生的简单需求.Linus Torvalds,Linux的作者与主要维护者,在其上大学时所买得起的唯一软件是Minix. Minix是一个类似Unix,被广泛用来辅助教学的简单操作系统.Linus 对Minix不是很满意,于是决定自己编写软件.他以学生时代熟悉的Unix作为原型, 在一台Intel 386 PC上开始了他的工作.他的进展很快,受工作成绩的鼓舞,他将这项成果通过互连网与其他同学共享,主要用于学术领域.有人看到了这个软件并开始分发.每当出现新问题时,有人会立刻找到解决办法并加入其中,很快的, Linux成为了一个操作系统.值得注意的是Linux并没有包括Unix源码.它是按照公开的POSIX标准重新编写的.Linux大量使用了由麻省剑桥免费软件基金的GNU软件,同时Linux自身也是用它们构造而成.

  另外两大区别:

  1) UNIX系统大多是与硬件配套的,而Linux则可运行在多种硬件平台上.

  2) UNIX是商业软件,而Linux是自由软件,免费、公开源代码的.

  UNIX(5万美圆)而Linux免费

  历史

  Unix的历史久于linux. Linux的思想源于Unix

  产品

  unix和linux都是操作系统的名称.但unix这四个字母除了是操作系统名称外,还作为商标归SCO所有.

  Linux商业化的有RedHat Linux 、SuSe Linux、slakeware Linux、国内的红旗等,还有Turbo Linux.

  Unix主要有Sun 的Solaris、IBM的AIX, HP的HP-UX,以及x86平台的的SCO Unix/Unixware

  其他区别

  linux的核心是免费的,自由使用的,核心源代码是开放的.

  而unix的核心并不公开

  在对硬件的要求上,linux比unix要低,没有unix那么苛刻.在安装上linux比unix容易掌握.

  在使用上,linux相对没有unix那么复杂.

  Unix多数是硬件厂商针对自己的硬件平台的操作系统,主要与CPU等有关,如Sun 的Solaris作为商用,定位在其使用SPARC/SPARCII的CPU的工作站及服务器上,当然Solaris也有x86的版本,而Linux也有其于RISC的版本.

  但确切的讲,拿RISC上的Unix与x86上的Linux进行比较不太合适.

  至于价格,个人使用的Linux基本上算是免费的,不同的Linux发行厂商针对企业级应用在基本的系统上有些优化,如RedHat的Enterprise产品,这些产品包括支持服务是比较贵的.

  像IBM/HP/SUN的Unix,因为主要是针对其硬件平台,所以操作系统通常在设备价格中.(没有人单独去买一个Unix操作系统的)

  在性能上,linux没有unix那么全面,但基本上对个人

  用户和小型应用来说是绰绰有余.

  通常情况下,如果你有机会使用到Unix环境,比如银行、电信部门,那一般都是固定机型的Unix.比如电信里SUN的居多,民航里HP的居多,银行里IBM的居多.学习中,不同的Unix命令集有些不同,要注意.

  至于学习,我看还是linux比较好学一点,而且现在喜欢和

  鼓捣linux的人也越来越多,各种有关linux的资料

  也很多.如果是自己想学习,那Linux或是BSD系统是不错的选择.一台x86的机器就可以.

  应用上,除非是大型网站,一般企业或个人,使用Linux即可.

  UNIX是一个功能强大、性能全面的多用户、多任务操作系统,可以应用从巨型计算机到普通PC机等多种不同的平台上,是应用面最广、影响力最大的操作系统.

  Linux是一种外观和性能与UNIX相同或更好的操作系统,但,Linux不源于任何版本的UNIX的源代码,并不是UNIX,而是一个类似于UNIX的产品.Linux产品成功的模仿了UNIX系统和功能,具体讲Linux是一套兼容于System V以及BSD UNIX的操作系统,对于System V来说,目前把软件程序源代码拿到Linux底下重新编译之后就可以运行,而对于BSD UNIX来说它的可执行文件可以直接在Linux环境下运行.

  一般来说,Linux是一套遵从POSIX(可移植操作系统环境)规范的一个操作系统,它能够在普通PC计算机上实现全部的UNIX特性,具有多任务、多用户的能力.Linux受到广大计算机爱好者的喜爱的另一个主要原因是,它具有UNIX的全部功能,任何使用UNIX操作系统或想要学习 UNIX操作系统的人都可以从Linux中获益.

  在网络管理能力和安全方面,使用过Linux的人都承认Linux UNIX很相似.UNIX系统一直被用做高端应用或服务器系统,因此拥有一套完善的网络管理机制和规则, Linux沿用了这些出色的规则,使网络的可配置能力很强,为系统管理提供了极大的灵活性.

Ubuntu中启用root账户

现在很多Linux发行版都默认禁用了root账户,有些时候确实不太方便

还是启用root吧。。。

给root设置一个密码,就可以登录使用了:

命令:

sudo passwd root

设置密码即可

然后就可以登陆使用root账户了

(转)GCC中__attribute__属性的使用

  在学习linux内核代码及一些开源软件的源码(如:DirectFB),经常可以看到有关__attribute__的相关使用。
  本文结合自己的学习经历,较为详细的介绍了__attribute__相关语法及其使用。

  GNU C的一大特色(却不被初学者所知)就是__attribute__机制。
  __attribute__可以设置函数属性(Function Attribute)、变量属性(Variable Attribute)和类型属性(Type Attribute)。

__attribute__书写特征是:

  • __attribute__前后都有两个下划线,并切后面会紧跟一对原括弧,括弧里面是相应的
  • __attribute__参数。
  • __attribute__语法格式为:
  • __attribute__ ((attribute-list))

其位置约束为:
放于声明的尾部“;”之前。

函数属性(Function Attribute)

  函数属性可以帮助开发者把一些特性添加到函数声明中,从而可以使编译器在错误检查方面的功能更强大。__attribute__机制也很容易同非GNU应用程序做到兼容之功效。
  GNU CC需要使用 –Wall编译器来激活该功能,这是控制警告信息的一个很好的方式。

下面介绍几个常见的属性参数。

__attribute__ format

  该__attribute__属性可以给被声明的函数加上类似printf或者scanf的特征,它可以使编译器检查函数声明和函数实际调用参数之间的格式化字符串是否匹配。该功能十分有用,尤其是处理一些很难发现的bug。

format的语法格式为:
format (archetype, string-index, first-to-check)

  format属性告诉编译器,按照printf, scanf, strftime或strfmon的参数表格式规则对该函数的参数进行检查。“archetype”指定是哪种风格;“string-index”指定传入函数的第几个参数是格式化字符串;“first-to-check”指定从函数的第几个参数开始按上述规则进行检查。

具体使用格式如下:
__attribute__((format(printf,m,n)))
__attribute__((format(scanf,m,n)))

其中参数m与n的含义为:

  • m:第几个参数为格式化字符串(format string);
  • n:参数集合中的第一个,即参数“…”里的第一个参数在函数参数总数排在第几,注意,有时函数参数里还有“隐身”的呢,后面会提到;

  在使用上,__attribute__((format(printf,m,n)))是常用的,而另一种却很少见到。下面举例说明,其中myprint为自己定义的一个带有可变参数的函数,其功能类似于printf:

//m=1;n=2
extern void myprint(const char *format,...) __attribute__((format(printf,1,2)));
//m=2;n=3
extern void myprint(int l,const char *format,...) __attribute__((format(printf,2,3)));

需要特别注意的是,如果myprint是一个函数的成员函数,那么m和n的值可有点“悬乎”了,例如:
//m=3;n=4
extern void myprint(int l,const char *format,...) __attribute__((format(printf,3,4)));

其原因是,类成员函数的第一个参数实际上一个“隐身”的“this”指针。(有点C++基础的都知道点this指针,不知道你在这里还知道吗?)

这里给出测试用例:attribute.c,代码如下:

extern void myprint(const char *format,...) __attribute__((format(printf,1,2)));

void test()
{
    myprint("i=%d\n",6);
    myprint("i=%s\n",6);
    myprint("i=%s\n","abc");
    myprint("%s,%d,%d\n",1,2);
}

运行$gcc –Wall –c attribute.c attribute后,输出结果为:

attribute.c: In function `test':
attribute.c:7: warning: format argument is not a pointer (arg 2)
attribute.c:9: warning: format argument is not a pointer (arg 2)
attribute.c:9: warning: too few arguments for format

  如果在attribute.c中的函数声明去掉__attribute__((format(printf,1,2))),再重新编译,既运行$gcc –Wall –c attribute.c attribute后,则并不会输出任何警告信息。
  注意,默认情况下,编译器是能识别类似printf的“标准”库函数。

__attribute__ noreturn

  该属性通知编译器函数从不返回值,当遇到类似函数需要返回值而却不可能运行到返回值处就已经退出来的情况,该属性可以避免出现错误信息。C库函数中的abort()和exit()的声明格式就采用了这种格式,如下所示:

extern void exit(int) __attribute__((noreturn));
extern void abort(void) __attribute__((noreturn));

  为了方便理解,大家可以参考如下的例子:

//name: noreturn.c  ;测试__attribute__((noreturn))
extern void myexit();

int test(int n)
{
       if ( n > 0 )
       {
              myexit();
              /* 程序不可能到达这里*/
       }
       else
              return 0;
}

编译显示的输出信息为:

$gcc –Wall –c noreturn.c
noreturn.c: In function `test':
noreturn.c:12: warning: control reaches end of non-void function

  警告信息也很好理解,因为你定义了一个有返回值的函数test却有可能没有返回值,程序当然不知道怎么办了!
  加上__attribute__((noreturn))则可以很好的处理类似这种问题。把
extern void myexit();
  修改为:
extern void myexit() __attribute__((noreturn));
之后,编译不会再出现警告信息。

__attribute__ const

  该属性只能用于带有数值类型参数的函数上。当重复调用带有数值参数的函数时,由于返回值是相同的,所以此时编译器可以进行优化处理,除第一次需要运算外,其它只需要返回第一次的结果就可以了,进而可以提高效率。该属性主要适用于没有静态状态(static state)和副作用的一些函数,并且返回值仅仅依赖输入的参数。
  为了说明问题,下面举个非常“糟糕”的例子,该例子将重复调用一个带有相同参数值的函数,具体如下:

extern int square(int n) `__attribute__`((const));
...
    for (i = 0; i < 100; i++ )
    {
        total += square(5) + i;
    }

  通过添加__attribute__((const))声明,编译器只调用了函数一次,以后只是直接得到了相同的一个返回值。
  事实上,const参数不能用在带有指针类型参数的函数中,因为该属性不但影响函数的参数值,同样也影响到了参数指向的数据,它可能会对代码本身产生严重甚至是不可恢复的严重后果。
  并且,带有该属性的函数不能有任何副作用或者是静态的状态,所以,类似getchar()或time()的函数是不适合使用该属性的。

-finstrument-functions

  该参数可以使程序在编译时,在函数的入口和出口处生成instrumentation调用。恰好在函数入口之后并恰好在函数出口之前,将使用当前函数的地址和调用地址来调用下面的 profiling 函数。(在一些平台上,__builtin_return_address不能在超过当前函数范围之外正常工作,所以调用地址信息可能对profiling函数是无效的。)

void __cyg_profile_func_enter(void *this_fn, void *call_site);
void __cyg_profile_func_exit(void *this_fn, void *call_site);

  其中,第一个参数this_fn是当前函数的起始地址,可在符号表中找到;第二个参数call_site是指调用处地址。
  instrumentation 也可用于在其它函数中展开的内联函数。从概念上来说,profiling调用将指出在哪里进入和退出内联函数。这就意味着这种函数必须具有可寻址形式。如果函数包含内联,而所有使用到该函数的程序都要把该内联展开,这会额外地增加代码长度。如果要在C 代码中使用extern inline声明,必须提供这种函数的可寻址形式。
  可对函数指定no_instrument_function属性,在这种情况下不会进行instrumentation操作。例如,可以在以下情况下使用no_instrument_function属性:上面列出的profiling函数、高优先级的中断例程以及任何不能保证profiling正常调用的函数。

no_instrument_function

  如果使用了-finstrument-functions ,将在绝大多数用户编译的函数的入口和出口点调用profiling函数。使用该属性,将不进行instrument操作。

constructor/destructor

  若函数被设定为constructor属性,则该函数会在main()函数执行之前被自动的执行。类似的,若函数被设定为destructor属性,则该函数会在main()函数执行之后或者exit()被调用后被自动的执行。拥有此类属性的函数经常隐式的用在程序的初始化数据方面。
  这两个属性还没有在面向对象C中实现。

同时使用多个属性

  可以在同一个函数声明里使用多个__attribute__,并且实际应用中这种情况是十分常见的。使用方式上,你可以选择两个单独的__attribute__,或者把它们写在一起,可以参考下面的例子:

/* 把类似printf的消息传递给stderr 并退出 */
extern void die(const char *format, ...)
__attribute__((noreturn))
__attribute__((format(printf, 1, 2)));
或者写成

extern void die(const char *format, ...)
__attribute__((noreturn, format(printf, 1, 2)));

  如果带有该属性的自定义函数追加到库的头文件里,那么所以调用该函数的程序都要做相应的检查。

和非GNU编译器的兼容性

  庆幸的是,__attribute__设计的非常巧妙,很容易作到和其它编译器保持兼容,也就是说,如果工作在其它的非GNU编译器上,可以很容易的忽略该属性。即使__attribute__使用了多个参数,也可以很容易的使用一对圆括弧进行处理,例如:

/* 如果使用的是非GNU C, 那么就忽略__attribute__ */
#ifndef __GNUC__
#  define  __attribute__(x)  /*NOTHING*/
#endif

  需要说明的是,__attribute__适用于函数的声明而不是函数的定义。所以,当需要使用该属性的函数时,必须在同一个文件里进行声明,例如:

/* 函数声明 */
void die(const char *format, ...) `__attribute__`((noreturn))
                                  `__attribute__`((format(printf,1,2)));
void die(const char *format, ...)
{
               /* 函数定义 */
}

更多的属性含义参考:
http://gcc.gnu.org/onlinedocs/gcc-4.0.0/gcc/Function-Attributes.html

变量属性(Variable Attributes)

  关键字__attribute__也可以对变量(variable)或结构体成员(structure field)进行属性设置。这里给出几个常用的参数的解释,更多的参数可参考本文给出的连接。
  在使用__attribute__参数时,你也可以在参数的前后都加上“”(两个下划线),例如,使用__aligned而不是aligned,这样,你就可以在相应的头文件里使用它而不用关心头文件里是否有重名的宏定义。

aligned (alignment)

  该属性规定变量或结构体成员的最小的对齐格式,以字节为单位。例如:

int x __attribute__ ((aligned (16))) = 0;

  编译器将以16字节(注意是字节byte不是位bit)对齐的方式分配一个变量。也可以对结构体成员变量设置该属性,例如,创建一个双字对齐的int对,可以这么写:

struct foo { int x[2] __attribute__ ((aligned (8))); };

  如上所述,你可以手动指定对齐的格式,同样,你也可以使用默认的对齐方式。如果aligned后面不紧跟一个指定的数字值,那么编译器将依据你的目标机器情况使用最大最有益的对齐方式。例如:

short array[3] __attribute__ ((aligned));

  选择针对目标机器最大的对齐方式,可以提高拷贝操作的效率。
  aligned属性使被设置的对象占用更多的空间,相反的,使用packed可以减小对象占用的空间。
需要注意的是,attribute属性的效力与你的连接器也有关,如果你的连接器最大只支持16字节对齐,那么你此时定义32字节对齐也是无济于事的。

packed

  使用该属性可以使得变量或者结构体成员使用最小的对齐方式,即对变量是一字节对齐,对域(field)是位对齐。
下面的例子中,x成员变量使用了该属性,则其值将紧放置在a的后面:
```cpp
struct test
{
char a;
int x[2] __attribute__ ((packed));
};


其它可选的属性值还可以是:cleanup,common,nocommon,deprecated,mode,section,shared,tls_model,transparent_union,unused,vector_size,weak,dllimport,dlexport等, 详细信息可参考: http://gcc.gnu.org/onlinedocs/gcc-4.0.0/gcc/Variable-Attributes.html#Variable-Attributes ##类型属性(Type Attribute)   关键字`__attribute__`也可以对结构体(struct)或共用体(union)进行属性设置。大致有六个参数值可以被设定,即:aligned, packed, transparent_union, unused, deprecated 和 may_alias。   在使用`__attribute__`参数时,你也可以在参数的前后都加上“__”(两个下划线),例如,使用__aligned__而不是aligned,这样,你就可以在相应的头文件里使用它而不用关心头文件里是否有重名的宏定义。 ###aligned (alignment) 该属性设定一个指定大小的对齐格式(以字节为单位),例如: struct S { short f[3]; } `__attribute__` ((aligned (8))); typedef int more_aligned_int `__attribute__` ((aligned (8)));   该声明将强制编译器确保(尽它所能)变量类型为struct S或者more-aligned-int的变量在分配空间时采用8字节对齐方式。   如上所述,你可以手动指定对齐的格式,同样,你也可以使用默认的对齐方式。如果aligned后面不紧跟一个指定的数字值,那么编译器将依据你的目标机器情况使用最大最有益的对齐方式。例如: struct S { short f[3]; } `__attribute__` ((aligned));   这里,如果sizeof(short)的大小为2(byte),那么,S的大小就为6。取一个2的次方值,使得该值大于等于6,则该值为8,所以编译器将设置S类型的对齐方式为8字节。   aligned属性使被设置的对象占用更多的空间,相反的,使用packed可以减小对象占用的空间。   需要注意的是,attribute属性的效力与你的连接器也有关,如果你的连接器最大只支持16字节对齐,那么你此时定义32字节对齐也是无济于事的。 ###packed 使用该属性对struct或者union类型进行定义,设定其类型的每一个变量的内存约束。当用在enum类型定义时,暗示了应该使用最小完整的类型(it indicates that the smallest integral type should be used)。 下面的例子中,my-packed-struct类型的变量数组中的值将会紧紧的靠在一起,但内部的成员变量s不会被“pack”,如果希望内部的成员变量也被packed的话,my-unpacked-struct也需要使用packed进行相应的约束。 struct my_unpacked_struct { char c; int i; }; struct my_packed_struct { char c; int i; struct my_unpacked_struct s; }`__attribute__` ((__packed__)); 其它属性的含义见: http://gcc.gnu.org/onlinedocs/gcc-4.0.0/gcc/Type-Attributes.html#Type-Attributes ###变量属性与类型属性举例   下面的例子中使用`__attribute__`属性定义了一些结构体及其变量,并给出了输出结果和对结果的分析。 程序代码为: ```cpp struct p { int a; char b; char c; }`__attribute__`((aligned(4))) pp; struct q { int a; char b; struct n qn; char c; }`__attribute__`((aligned(8))) qq; int main() { printf("sizeof(int)=%d,sizeof(short)=%d.sizeof(char)=%d\n",sizeof(int),sizeof(short),sizeof(char)); printf("pp=%d,qq=%d \n", sizeof(pp),sizeof(qq)); return 0; }

输出结果:

sizeof(int)=4,sizeof(short)=2.sizeof(char)=1
pp=8,qq=24

分析:
sizeof(pp):
sizeof(a)+ sizeof(b)+ sizeof(c)=4+1+1=6<23=8= sizeof(pp)
sizeof(qq):
sizeof(a)+ sizeof(b)=4+1=5
sizeof(qn)=8;即qn是采用8字节对齐的,所以要在a,b后面添3个空余字节,然后才能存储qn,
4+1+(3)+8+1=17
  因为qq采用的对齐是8字节对齐,所以qq的大小必定是8的整数倍,即qq的大小是一个比17大又是8的倍数的一个最小值,由此得到
17<24+8=24= sizeof(qq)

更详细的介绍见:
http://gcc.gnu.org

  下面是一些便捷的连接:GCC 4.0 Function Attributes;GCC 4.0 Variable Attributes ;GCC 4.0 Type Attributes ;GCC 3.2 Function Attributes ;GCC 3.2 Variable Attributes ;GCC 3.2 Type Attributes ;GCC 3.1 Function Attributes ;GCC 3.1 Variable Attributes

Reference:
1.有关__attribute__的相对简单的介绍:http://www.unixwiz.net/techtips/gnu-c-attributes.html
2.__attribute__详细介绍:http://gcc.gnu.org