linux 内核可以忽略,Linux内核源码特殊用法

ゝ一世哀愁。 2023-01-20 05:53 111阅读 0赞

Linux内核源码特殊用法1前言

Linux内核源码主要以C语言为主，有一小部分涉及汇编语言，编译器使用的是Gcc。初次看内核源码，会遇到一些难以理解、晦涩的代码；而恰恰是这些晦涩的代码，在内核源码中经常出现。把一些晦涩、常见的代码看懂后，大家会发现看内核代码越来越顺利。

本文以x86\_64架构中的Linux 2.6.32-71.el6(RHEL 6)源码为例，选择一些经常出现且晦涩的源码进行解释，选择的源码虽以2.6.32-71.el6为例，但很多内容同样使用其他版本的源码。主要内容包括Gcc中C语言的扩展用法、及其他一些杂项。

中C语言的扩展用法

在我们看文件系统(File Sytems)或页面缓存(Page Cache)管理内容时，会经常遇到struct address\_space数据结构，其定义在include/linux/fs.h中。

00624:structaddress\_space\{

00625:structinode\*host;/\*owner:inode,block\_device\*/

00626:structradix\_tree\_rootpage\_tree;/\*radixtreeofallpages\*/

00627:spinlock\_ttree\_lock;/\*andlockprotectingit\*/

00628:unsignedinti\_mmap\_writable;/\*countVM\_SHAREDmappings \*/

00629:structprio\_tree\_rooti\_mmap;

00629:/\*treeofprivateandsharedmappings \*/

00630:structlist\_headi\_mmap\_nonlinear;/\*listVM\_NONLINEARmappings \*/

00631:spinlock\_ti\_mmap\_lock;/\*protecttree,count,list\*/

00632:unsignedinttruncate\_count;/\*Coverraceconditionwithtruncate\*/

00633:unsignedlongnrpages;/\*numberoftotalpages\*/

00634:pgoff\_twriteback\_index;/\*writebackstartshere\*/

00635:conststructaddress\_space\_operations\*a\_ops;/\*methods\*/

00636:unsignedlongflags;/\*errorbits/gfpmask\*/

00637:structbacking\_dev\_info\*backing\_dev\_info;/\*devicereadahead,etc\*/

00638:spinlock\_tprivate\_lock;/\*forusebytheaddress\_space\*/

![fedac5aae6319aa673695b74ccd9c09c.gif][]00639:structlist\_headprivate\_list;/\*ditto\*/

00640:structaddress\_space\*assoc\_mapping;/\*ditto\*/

00641:\}\_\_attribute\_\_((aligned(sizeof(long))));

大家注意到，在结构体定义结束出\_\_attribute\_\_((aligned(sizeof(long))))。

这句的作用是什么？对结构体的定义有什么影响？

对于关键字\_\_attribute\_\_，在标准的C语言中是没有的。它是Gcc中对C语言的一个扩展用法。关键字\_\_attribute\_\_可以用来设置一个函数或数据结构定义的属性。对一个函数设置属性的主要目的是使编译器对函数进行可能的优化。对函数设置属性，是在函数原型定义中设置，如下面一个例子：

void fatal\_error() \_\_attribute\_\_ ((noreturn));

. . .

void fatal\_error(char \*message)

fprintf(stderr,"FATAL ERROR: %s\\n",message);

exit(1);

在这个例子中，noreturn属性告诉编译器，这个函数不返回给调用者，所以编译器就可以忽略所有与执行该函数返回值有关的代码。

可以在同一个定义中，设置多个属性，各个属性用逗号分开即可。如下面的定义就是告诉编译器，它不改变全局变量和该函数不能扩展为内联函数。

int getlim() \_\_attribute\_\_ ((pure,noinline));

属性(attributes)也可以用来设置变量和结构体的成员。如，为了保证结构体中的一个成员变量与结构体有特殊方式的对齐(alignment)，可以用以下形式定义：

struct mong \{

char id;

int code \_\_attribute\_\_ ((align(4)));

\};

address\_space结构体中，显然\_\_attribute\_\_是用来设置结构体struct address\_space的，就是给该结构体设置一个属性。设置什么样的属性呢？该结构体的属性是aligned(sizeof(long))，就是设置struct address\_space结构体按sizeof(long)个字节对齐。

这里的属性aligned的含义是：设置与内存地址对齐(alignment)的方式。如

int alivalue \_\_attribute\_\_ ((aligned(32)));

变量alivalue的地址就是32字节对齐。对于我们内核源码的例子，当然属性有很多中，不仅仅是aligned，比如还有deprecated、packed、unused等。并且设置变量或结构体的属性，与设置函数的属性有所不同。

GCC对C语言的扩展，更多内容请参考链接。http://gcc.gnu.org/onlinedocs/gcc/C-Extensions.html\#C-Extensions

我们再来看一个实例代码摘自linux/include/module.h

00083:\#ifdefMODULE

00084:\#defineMODULE\_GENERIC\_TABLE(gtype,name)\\

00085:externconststructgtype\#\#\_id mod\_\#\#gtype\#\#\_table\\

00086:\_\_attribute\_\_((unused,alias(\_\_stringify(name))))

00087:

00088:externstructmodule\_\_this\_module;

00089:\#defineTHIS\_MODULE(&this\_module)

00090:\#else/\*!MODULE\*/

00091:\#defineMODULE\_GENERIC\_TABLE(gtype,name)

00092:\#defineTHIS\_MODULE((structmodule\*)0)

00093:\#endif

注意到86行的\_\_attribute\_\_((unused,alias(\_\_stringify(name))))。前面已经提到，可以为一个变量或函数设置多个属性(attribute)，各个属性之间用逗号隔开。86行的宏有两个属性：unused和alias。unused使该类型的数据项显示为未被使用的，这样编译时就不会产生任何告警信息；alias使该定义是其他符号的别名。如

void \_\_f () \{ /\* Do something. \*/; \}

void f () \_\_attribute\_\_ ((weak, alias ("\_\_f")));

定义“f”是“\_\_f”的一个弱别名。

先看一段源码，摘自include/linux/compiler-gcc.h。

00010:/\*Optimizationbarrier\*/

00011:/\*The"volatile"isduetogccbugs\*/

00012:\#definebarrier()\_\_asm\_\_volatile\_\_("":::"memory")

在文件arch/x86/include/asm/msr.h另外一段代码。

00076:staticinlineunsignedlonglongnative\_read\_msr\_safe(unsignedintmsr,

00077:int\*err)

00078:\{

00079:DECLARE\_ARGS(val,low,high);

00080:

00081:asmvolatile("2:rdmsr;xor%\[err\],%\[err\]\\n"

00082:"1:\\n\\t"

00083:".section.fixup,\\"ax\\"\\n\\t"

00084:"3: mov%\[fault\],%\[err\];jmp1b\\n\\t"

00085:".previous\\n\\t"

00086:\_ASM\_EXTABLE(2b,3b)

00087::\[err\]"=r"(\*err),EAX\_EDX\_RET(val,low,high)

00088::"c"(msr),\[fault\]"i"(-EIO));

00089:returnEAX\_EDX\_VAL(val,low,high);

00090:\}

00091:

给出的两段代码都使用了嵌入式汇编。但不同的是关键字的形式不一样。一个使用的是\_\_asm\_\_，另外一个是asm。事实上，两者的含义都一样。也就是\_\_asm\_\_等同于asm，区别在于编译时，若使用了选项-std和-ansi，则关闭了关键字asm，而其替代关键字\_\_asm\_\_仍然可以使用。

类似的关键字还有\_\_typeof\_\_和\_\_inline\_\_，其等同于typeof和inline。

在内核双链表include/linux/kernel.h中，有以下一段代码。该宏的具体含义，这里不多作解释，后面的章节会介绍。这里我们关注一个关键字typeof。

00669:/\*\*

00670:\*container\_of-castamemberofastructureouttothecontainingstructure

00671:\*thepointertothemember.

00672:\*typeofthecontainerstructthisisembeddedin.

00673:\*thenameofthememberwithinthestruct.

00674:\*

00675:\*/

00676:\#definecontainer\_of(ptr,type,member)(\{\\

00677:consttypeof(((type\*)0)->member)\*\_\_mptr=(ptr);\\

00678:(type\*)((char\*)\_\_mptr-offsetof(type,member));\})

00679:

从字面意思上理解，typeof就是获取其类型，其含义也正是如此。关键字typeof返回的是表达式的类型，使用上类似于关键字sizeof，但它的返回值是类型，而不是一个大小。下面是一些例子：

char \*chptr; // A char pointer

typeof (\*chptr) ch; // A char

typeof (ch) \*chptr2; // A char pointer

typeof (chptr) chparray\[10\]; // Ten char pointers

typeof (\*chptr) charray\[10\]; // Ten chars

typeof (ch) charray2\[10\]; // Ten chars

asmlinkage在内核源码中出现的频率非常高，它是告诉编译器在本地堆栈中传递参数，与之对应的是fastcall；fastcall是告诉编译器在通用寄存器中传递参数。运行时，直接从通用寄存器中取函数参数，要比在本地堆栈(内存)中取，速度快很多。

00492:/\*

00493:\*sys\_execve()executesanewprogram.

00494:\*/

00495:asmlinkage

00496:longsys\_execve(char\_\_user\*name,char\_\_user\*\_\_user\*argv,

00497:char\_\_user\*\_\_user\*envp,structpt\_regs \*regs)

00498:\{

00499:longerror;

00500:char\*filename;

00501:

00502:filename=getname(name);

00503:error=PTR\_ERR(filename);

00504:if(IS\_ERR(filename))

00505:returnerror;

00506:error=do\_execve(filename,argv,envp,regs);

00507:putname(filename);

00508:returnerror;

00509:\}

fastcall的使用是和平台相关的，asmlinkage和fastcall的定义都在文件arch/x86/include/asm/linkage.h中。

00009:\#ifdefCONFIG\_X86\_32

00010:\#defineasmlinkageCPP\_ASMLINKAGE\_\_attribute\_\_((regparm(0)))

00011:/\*

00012:\*For32-bitUML-markfunctionsimplementedinassemblythatuse

00013:\*regparminputparameters:

00014:\*/

00015:\#defineasmregparm\_\_attribute\_\_((regparm(3)))

UL通常用在一个常数的后面，标记为“unsigned long”。使用UL的必要性在于告诉编译器，把这个常数作为长型数据对待。这可以避免在部分平台上，造成数据溢出。例如，在16位的整数可以表示的范围为-32,768 ~ +32,767；一个无符号整型表示的范围可以达到65,535。使用UL可以帮助当你使用大数或长的位掩码时，写出的代码与平台无关。下面一段代码摘自include/linux/hash.h。

00017:\#includetypes.h>

00018:

00019:/\*2^31+2^29-2^25+2^22-2^19-2^16+1\*/

00020:\#defineGOLDEN\_RATIO\_PRIME\_320x9e370001UL

00021:/\*2^63+2^61-2^57+2^54-2^51-2^18+1\*/

00022:\#defineGOLDEN\_RATIO\_PRIME\_640x9e37fffffffc0001UL

00023:

和volatile

关键字const的含义不能理解为常量，而是理解为“只读”。如int const\*x是一个指针，指向一个const整数。这样，指针可以改变，但整数值却不能改变。然而int \*const x是一个const指针，指向整数，整数的值可以改变，但指针不能改变。下面代码摘自fs/ext4/inode.c。

00347:staticintext4\_block\_to\_path(structinode\*inode,

00348:ext4\_lblk\_ti\_block,

00349:ext4\_lblk\_toffsets\[4\],int\*boundary)

00350:\{

00351:intptrs=EXT4\_ADDR\_PER\_BLOCK(inode->i\_sb);

00352:intptrs\_bits=EXT4\_ADDR\_PER\_BLOCK\_BITS(inode->i\_sb);

00353:constlongdirect\_blocks=EXT4\_NDIR\_BLOCKS,

00354:indirect\_blocks=ptrs,

00355:double\_blocks=(1<

关键字volatile标记变量可以改变，而没有告警信息。volatile告诉编译器每次访问时，该变量必须重新加载，而不是从拷贝或缓存中读取。需要使用volatile的场合有，当我们处理中断寄存器时，或者并发进程之间共享的变量。

task\_struct结构体如下，包含volatile和const两个特殊关键字。

01231:structtask\_struct\{

01232:volatilelongstate;/\*-1unrunnable,0runnable,>0stopped\*/

01233:void\*stack;

01234:atomic\_tusage;

01235:unsignedintflags;/\*perprocessflags,definedbelow\*/

01236:unsignedintptrace;

01237:

01238:intlock\_depth;/\*BKLlockdepth\*/

01239:

01240:\#ifdefCONFIG\_SMP

01241:\#ifdef\_\_ARCH\_WANT\_UNLOCKED\_CTXSW

01242:intoncpu;

01243:\#endif

01244:\#endif

01245:

01246:intprio,static\_prio,normal\_prio;

01247:unsignedintrt\_priority;

01248:conststructsched\_class\*sched\_class;

在嵌入式汇编代码中，经常看到\_\_volatile\_\_修饰符，我们提到\_\_volatile\_\_和volatile实际上是等同的，这里不多作强调。\_\_volatile\_\_修饰符对汇编代码非常重要。它告诉编译器不要优化内联的汇编代码。通常，编译器认为一些代码是冗余和浪费的，于是就试图尽可能优化这些汇编代码。

和unlikely()

unlikely()和likely()这两个语句也很常见。先看mm/page\_alloc.c中的函数\_\_alloc\_pages()，这个函数是内存管理中分配物理页面的核心函数。

02100:/\*

02101:\*Thisisthe'heart'ofthezonedbuddyallocator.

02102:\*/

02103:structpage \*

02104:\_\_alloc\_pages\_nodemask(gfp\_tgfp\_mask,unsignedintorder,

02105:structzonelist\*zonelist,nodemask\_t\*nodemask)

02106:\{

02107:enumzone\_typehigh\_zoneidx=gfp\_zone(gfp\_mask);

02108:structzone\*preferred\_zone;

02109:structpage \*page;

02110:intmigratetype=allocflags\_to\_migratetype(gfp\_mask);

02111:

02112:gfp\_mask&=gfp\_allowed\_mask;

02113:

02114:lockdep\_trace\_alloc(gfp\_mask);

02115:

02116:might\_sleep\_if(gfp\_mask&\_\_GFP\_WAIT);

02117:

02118:if(should\_fail\_alloc\_page(gfp\_mask,order))

02119:returnNULL;

02120:

02121:/\*

02122:\*Checkthezonessuitableforthegfp\_maskcontainatleastone

02123:\*validzone.It'spossibletohaveanemptyzonelistasaresult

02124:\*ofGFP\_THISNODEandamemorylessnode

02125:\*/

02126:if(unlikely(!zonelist->\_zonerefs->zone))

02127:returnNULL;

02128:

注意到2126行的unlikely()语句。那么unlikely()和likely()的含义是什么？

在linux内核源码中，unlikely()和likely()是两个宏，它告诉编译器一个暗示。现代的CPU都有提前预测语句执行分支(branch-prediction heuristics)的功能，预测将要执行的指令，以优化执行速度。unlikely()和likely()通过编译器告诉CPU，某段代码是likely，应被预测；某段代码是unlikely，不应被预测。likely()和unlikely()定义在include/linux/compiler.h。

00106:\#ifndeflikely

00107:\# definelikely(x)(\_\_builtin\_constant\_p(x)?!!(x):\_\_branch\_check\_\_(x,1))

00108:\#endif

00109:\#ifndefunlikely

00110:\# defineunlikely(x)(\_\_builtin\_constant\_p(x)?!!(x):\_\_branch\_check\_\_(x,0))

00111:\#endif

和PTR\_ERR

许多内部的内核函数返回一个指针值给调用者，而这些函数中很多可能会失败。在大部分情况下，失败是通过返回一个NULL指针值来表示的。这种技巧有作用，但是它不能传递问题的确切性质。某些接口确实需要返回一个实际的错误编码，以使调用者可以根据实际出错的情况做出正确的决策。

许多内核接口通过把错误值编码到一个指针值中来返回错误信息。这种函数必须小心使用，因为他们的返回值不能简单地和NULL比较。为了帮助创建和使用这种类型的接口，中提供了一小组函数。

void \*ERR\_PTR(long error);

这里error是通常的负的错误编码。调用者可以使用IS\_ERR来检查所返回的指针是否是一个错误编码：

long IS\_ERR(const void\* ptr);

如果需要实际的错误编码，可以通过以下函数把它提取出来：

long PTR\_ERR(const void\* ptr);

应该只有在IS\_ERR对某值返回真值时才对该值使用PTR\_ERR，因为任何其他值都是有效的指针。

先看linux内核启动时的一段代码，摘自init/main.c。

00541:asmlinkagevoid\_\_initstart\_kernel(void)

00542:\{

00543:char\*command\_line;

00544:externstructkernel\_param\_\_startparam\[\],

\_\_stopparam\[\];

00545:

00546:smp\_setup\_processor\_id();

00547:

00548:/\*

00549:\*Needtorunasearlyaspossible,toinitializethe

00550:\*lockdephash:

00551:\*/

00552:lockdep\_init();

00553:debug\_objects\_early\_init();

00554:

00555:/\*

00556:\*SetupthetheinitialcanaryASAP:

00557:\*/

00558:boot\_init\_stack\_canary();

00559:

00560:cgroup\_init\_early();

00561:

00562:local\_irq\_disable();

00563:early\_boot\_irqs\_off();

00564:early\_init\_irq\_lock\_class();

00565:

00566:/\*

00567:\*Interruptsarestilldisabled.Donecessarysetups,then

00568:\*enablethem

00569:\*/

函数start\_kernel()有个修饰符\_\_init。\_\_init实际上是一个宏，只有在linux内核初始化是执行的函数或变量前才使用\_\_init。编译器将标记为\_\_init的代码段存放在一个特别的内存区域里，这个区域在系统初始化后，就会释放。

同理，\_\_initdata用来标记只在内核初始化使用的数据，\_\_exit和\_\_exitdata用来标记结束或关机的例程。这些通常在设备驱动卸载时使用。

看进程管理内容时，do\_fork()的源码是必读的。我们注意到do\_fork()最后两个参数前，都有\_\_user修饰符。那么这么修饰符的含义和用处是怎样的？摘自kernel/fork.c。

01397:longdo\_fork(unsignedlongclone\_flags,

01398:unsignedlongstack\_start,

01399:structpt\_regs \*regs,

01400:unsignedlongstack\_size,

01401:int\_\_user\*parent\_tidptr,

01402:int\_\_user\*child\_tidptr)

01403:\{

01404:structtask\_struct\*p;

01405:inttrace=0;

01406:longnr;

01407:

01408:/\*

01409:\*Dosomepreliminaryargumentandpermissionscheckingbeforewe

01410:\*actuallystartallocatingstuff

01411:\*/

01412:if(clone\_flags&CLONE\_NEWUSER)\{

01413:if(clone\_flags&CLONE\_THREAD)

01414:return-EINVAL;

01415:/\*hopefullythischeckwillgoawaywhenusernssupportis

01416:\*complete

01417:\*/

01418:if(!capable(CAP\_SYS\_ADMIN)|| !capable(CAP\_SETUID)||

01419:!capable(CAP\_SETGID))

01420:return-EPERM;

01421:\}

先来看\_\_user的在include/linux/compiler.h中的定义：

00006:\#ifdefCHECKER

00007:\#define\_\_user\_\_attribute\_\_((noderef,address\_space(1)))

00008:\#define\_\_kernel/\*defaultaddressspace\*/

00009:\#define\_\_safe\_\_attribute\_\_((safe))

00010:\#define\_\_force\_\_attribute\_\_((force))

00011:\#define\_\_nocast\_\_attribute\_\_((nocast))

00012:\#define\_\_iomem\_\_attribute\_\_((noderef,address\_space(2)))

00013:\#define\_\_acquires(x)\_\_attribute\_\_((context(x,0,1)))

00014:\#define\_\_releases(x)\_\_attribute\_\_((context(x,1,0)))

00015:\#define\_\_acquire(x)\_\_context\_\_(x,1)

00016:\#define\_\_release(x)\_\_context\_\_(x,-1)

00017:\#define\_\_cond\_lock(x,c)((c)?(\{\_\_acquire(x);1;\}):0)

00018:externvoid\_\_chk\_user\_ptr(constvolatilevoid\_\_user\*);

00019:externvoid\_\_chk\_io\_ptr(constvolatilevoid\_\_iomem\*);

00020:\#else

00021:\#define\_\_user

00022:\#define\_\_kernel

00023:\#define\_\_safe

00024:\#define\_\_force

00025:\#define\_\_nocast

00026:\#define\_\_iomem

00027:\#define\_\_chk\_user\_ptr(x)(void)0

00028:\#define\_\_chk\_io\_ptr(x)(void)0

00029:\#define\_\_builtin\_warning(x,y...)(1)

00030:\#define\_\_acquires(x)

00031:\#define\_\_releases(x)

00032:\#define\_\_acquire(x)(void)0

00033:\#define\_\_release(x)(void)0

00034:\#define\_\_cond\_lock(x,c)(c)

00035:\#endif

通过其定义，似乎Gcc中现在还没有支持这个用法。通过字面意思理解，\_\_user很显然是告诉它是一个用户数据。虽然Gcc还不支持这种用法，但借助适当的工具，就可以在内核编译时就可以发现内核源码中的一些错误；如前面的\_\_user，若编译时发现传递进来的不是用户数据，那么就产生告警。

在\_\_user定义中，我们发现还有\_\_kernel、\_\_safe、\_\_force、\_\_iomem，这些都是用来做内核源码语法检查的；其中\_\_iomem在驱动代码中很常见。

目前内核社区使用SPARSE工具来做内核源码的检查。SPARSE是语法分析器，能在编译器前端发现源码的语法。它能检查ANSI C以及很多Gcc的扩展。SPASE提供一系列标记来传递语法信息，如地址空间的类型、函数所需获取或释放的锁等。

[fedac5aae6319aa673695b74ccd9c09c.gif]: /images/20221021/34ef2dd07e8e48c7814a7f72a4fe5d38.png

linux 内核可以忽略,Linux内核源码特殊用法

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 linux 内核源码学习

相关 linux内核源码ping,Linux内核源码特殊用法

相关 linux 内核可以忽略,Linux内核源码特殊用法

相关编译linux内核源码

相关 Linux内核源码分析方法

相关 Linux内核源码分析方法

相关 linux内核源码结构

相关 Linux epoll内核源码剖析

相关 Linux poll内核源码剖析

相关 Linux select内核源码剖析