linux源代码分析怎么使用，手上有一本linux内核2.4版源代码分析大全

linux socket编程代码解析

#include<stdio.h> #include<stdlib.h> #include<sys/types.h> #include<sys/socket.h> #include&/in.h> #include<arpa/.h> #include&db.h> char *host_name="127.0.0.1"; int port=7778; struct student { char name[20]; char num[20]; float score; }t={"xiejian","200701415",89.9}; int main ( ) { char buf[502]; int socket_descriptor; struct sockaddr_in pin; bzero(&pin,sizeof(pin)); pin.sin_family=AF_INET; _pton(AF_INET,host_name,&pin.sin_addr); pin.sin_port=htons(port); if((socket_descriptor=socket(AF_INET,SOCK_STREAM,0))==-1) { perror("Error openung socket! "); exit(1); } if(connect(socket_descriptor,(void *)&pin,sizeof (pin))==-1) { perror("can not connecting to server! "); exit (1); } printf("Send message to server ... "); //memset(buf,0,502); //memcpy(buf,(void *)&t,sizeof(t)); //sprintf(buf,"%s %d",t.name,t.num); //printf("the first string : %s ",buf); if(send(socket_descriptor,(void *) &t,sizeof(t),0)==-1) { perror("can not send message! "); exit (1); } printf("waiting for response from server! "); memset(buf,0,502); if(recv(socket_descriptor,buf,sizeof(buf),0)==-1) { perror("can not receive response ! "); exit (1); } printf(" Response from server : "); memcpy((struct student *)&t,buf,sizeof(buf)); //printf("the string : %s ",rebuf); printf("--%s--%s--%5.1f-- ",t.name,t.num,t.score); close (socket_descriptor); } /* 注意在send 结构体时应该把结构体强制类型转换为void * 型 ** 接受之后又要强制转换回结构体型！否则则穿过来的是结构体的 ** 一部分！ */ 下面是服务端 #include<stdio.h> #include<stdlib.h> #include&/in.h> #include<sys/socket.h> #include<arpa/.h> #include&db.h> int port=7778; struct student { char name[20]; char num[20]; float score; }t; main() { struct sockaddr_in sin; struct sockaddr_in pin; int sock_descriptor; int temp_sock_descriptor; int size_of_addr; //struct cfg a; char buf[502]; int i,lenth; sock_descriptor=socket(AF_INET,SOCK_STREAM,0); if(sock_descriptor==-1) { perror("socket! "); exit(1); } bzero(&sin,sizeof(sin)); sin.sin_addr.s_addr=INADDR_ANY; sin.sin_port=htons(port); if(bind(sock_descriptor,(struct sockaddr *)&sin,sizeof (sin))==-1) { perror("bind! "); exit(1); } if(listen (sock_descriptor,20)==-1) { perror("listen! "); exit(1); } printf("Waiting for epting connection from client! "); while(1) { printf("the process is waiting here! "); temp_sock_descriptor=ept(sock_descriptor, (struct sockaddr *)&pin,&size_of_addr); if(temp_sock_descriptor==-1) { perror("call to ept! "); exit (1); } memset(buf,0,502); if(recv(temp_sock_descriptor,buf,sizeof(buf),0)==-1) { perror("recv! "); exit (1); } printf("received : "); //printf("the recv buf is :%s ",buf); memcpy((struct student *) &t,buf,sizeof(buf)); printf("--%s--%s--%5.1f-- ",t.name,t.num,t.score); if(send (temp_sock_descriptor,(void *) &t,sizeof(t),0)==-1) { perror("send! "); exit(1); } close (temp_sock_descriptor); } }

求一段嵌入式linux代码解读？

/q?sc=web&pid=ask.rel&w=%C7%F3%D2%BB%B6%CE%C7%B6%C8%EB%CA%BDlinux%B4%FA%C2%EB%BD%E2%B6%C1%A3%BF

谁能给我一个Linux系统中du命令的详细分析？（包括源代码的分析）

Linux du命令也是查看使用空间的，但是与df命令不同的是Linux du命令是对文件和目录磁盘使用的空间的查看，还是和df命令有一些区别的，这里介绍Linux du命令。

　　du：查询档案或目录的磁盘使用空间 　　a：显示全部目录和其次目录下的每个档案所占的磁盘空间 　　b：大小用bytes来表示 (默认值为k bytes) 　　c：最后再加上总计 (默认值) 　　s：只显示各档案大小的总合 　　x：只计算同属同一个档案系统的档案 　　L：计算所有的档案大小 　　常用命令：du –a 　　操作详解 　　引用 　　指令 du 能以指定的目录下的子目录为单位，显示每个目录内所有档案所占用的磁盘空间大小。

例如： 　　# du -h /etc 　　104K /etc/defaults 　　6.0K /etc/X11 　　8.0K /etc/bluetooth 　　4.0K /etc/gnats 　　52K /etc/isdn 　　388K /etc/mail 　　68K /etc/mtree 　　2.0K /etc/ntp 　　38K /etc/pam.d 　　44K /etc/periodic/daily 　　6.0K /etc/periodic/monthly 　　42K /etc/periodic/security 　　16K /etc/periodic/weekly 　　110K /etc/periodic 　　6.0K /etc/ppp 　　318K /etc/rc.d 　　2.0K /etc/skel 　　130K /etc/ssh 　　10K /etc/ssl 　　1.7M /etc 　　我们目样使用 -h 参数来显示 human-readable 的格式。

在应用时，我们可以使用 du 这个指令来查看哪个目录占用最多的空间。

不过，du 的输出结果通常很长，我们可以加上 -s 参数来省略指定目录下的子目录，而只显示该目录的总合即可： 　　# du -sh /etc 　　1.7M /etc 　　在查看目录的使用情形时，我们可以将输出结果导到 sort 指令进行排序，以了解哪个档案用了最多的空间： 　　# du /etc | sort -nr | more 　　1746 /etc 　　388 /etc/mail 　　318 /etc/rc.d 　　130 /etc/ssh 　　110 /etc/periodic 　　104 /etc/defaults 　　68 /etc/mtree 　　52 /etc/isdn 　　44 /etc/periodic/daily 　　42 /etc/periodic/security 　　38 /etc/pam.d 　　16 /etc/periodic/weekly 　　10 /etc/ssl 　　8 /etc/bluetooth 　　6 /etc/ppp 　　6 /etc/periodic/monthly 　　6 /etc/X11 　　4 /etc/gnats 　　2 /etc/skel 　　2 /etc/ntp 　　sort 的参数 -nr 表示要以数字排序法进行反向排序，因为我们要对目录大小做排序，所以不可以使用 human-readable 的大小输出，不然目录大小中会有 K、M 等字样，会造成排序不正确。

　　现在明了了Linux du命令和Linux df命令的不同之处了吗

请教一下对Linux操作系统内核分析方法?高手请进

Linux的最大的好处之一就是它的源码公开。

同时，公开的核心源码也吸引着无数的电脑爱好者和程序员；他们把解读和分析Linux的核心源码作为自己的最大兴趣，把修改Linux源码和改造Linux系统作为自己对计算机技术追求的最大目标。

Linux内核源码是很具吸引力的，特别是当你弄懂了一个分析了好久都没搞懂的问题；或者是被你修改过了的内核，顺利通过编译，一切运行正常的时候。

那种成就感真是油然而生！而且，对内核的分析，除了出自对技术的狂热追求之外，这种令人生畏的劳动所带来的回报也是非常令人着迷的，这也正是它拥有众多追随者的主要原因： 首先，你可以从中学到很多的计算机的底层知识，如后面将讲到的系统的引导和硬件提供的中断机制等；其它，象虚拟存储的实现机制，多任务机制，系统保护机制等等，这些都是非都源码不能体会的。

同时，你还将从操作系统的整体结构中，体会整体设计在软件设计中的份量和作用，以及一些宏观设计的方法和技巧：Linux的内核为上层应用提供一个与具体硬件不相关的平台；同时在内核内部，它又把代码分为与体系结构和硬件相关的部分，和可移植的部分；再例如，Linux虽然不是微内核的，但他把大部分的设备驱动处理成相对独立的内核模块，这样减小了内核运行的开销，增强了内核代码的模块独立性。

而且你还能从对内核源码的分析中，体会到它在解决某个具体细节问题时，方法的巧妙：如后面将分析到了的Linux通过Botoom_half机制来加快系统对中断的处理。

最重要的是：在源码的分析过程中，你将会被一点一点地、潜移默化地专业化。

一个专业的程序员，总是把代码的清晰性，兼容性，可移植性放在很重要的位置。

他们总是通过定义大量的宏，来增强代码的清晰度和可读性，而又不增加编译后的代码长度和代码的运行效率；他们总是在编码的同时，就考虑到了以后的代码维护和升级。

甚至，只要分析百分之一的代码后，你就会深刻地体会到，什么样的代码才是一个专业的程序员写的，什么样的代码是一个业余爱好者写的。

而这一点是任何没有真正分析过标准代码的人都无法体会到的。

然而，由于内核代码的冗长，和内核体系结构的庞杂，所以分析内核也是一个很艰难，很需要毅力的事；在缺乏指导和交流的情况下，尤其如此。

只有方法正确，才能事半功倍。

正是基于这种考虑，作者希望通过此文能给大家一些借鉴和启迪。

由于本人所进行的分析都是基于2.2.5版本的内核；所以，如果没有特别说明，以下分析都是基于i386单处理器的2.2.5版本的Linux内核。

所有源文件均是相对于目录/usr/src/linux的。

方法之一：从何入手 要分析Linux内核源码，首先必须找到各个模块的位置，也即要弄懂源码的文件组织形式。

虽然对于有经验的高手而言，这个不是很难；但对于很多初级的Linux爱好者，和那些对源码分析很有兴趣但接触不多的人来说，这还是很有必要的。

1、Linux核心源程序通常都安装在/usr/src/linux下，而且它有一个非常简单的编号约定：任何偶数的核心（的二个数为偶数，例如2.0.30）都是一个稳定地发行的核心，而任何奇数的核心（例如2.1.42）都是一个开发中的核心。

2、核心源程序的文件按树形结构进行组织，在源程序树的最上层，即目录/usr/src/linux下有这样一些目录和文件： ◆ COPYING: GPL版权申明。

对具有GPL版权的源代码改动而形成的程序，或使用GPL工具产生的程序，具有使用GPL发表的义务，如公开源代码； ◆ CREDITS: 光荣榜。

对Linux做出过很大贡献的一些人的信息； ◆ MAINTAINERS: 维护人员列表，对当前版本的内核各部分都有谁负责； ◆ Makefile: 第一个Makefile文件。

用来组织内核的各模块，记录了个模块间的相互这间的联系和依托关系，编译时使用；仔细阅读各子目录下的Makefile文件对弄清各个文件这间的联系和依托关系很有帮助； ◆ ReadMe: 核心及其编译配置方法简单介绍； ◆ Rules.make: 各种Makefilemake所使用的一些共同规则； ◆ REPORTING-BUGS:有关报告Bug 的一些内容； ● Arch/ ：arch子目录包括了所有和体系结构相关的核心代码。

它的每一个子目录都代表一种支持的体系结构，例如i386就是关于intel cpu及与之相兼容体系结构的子目录。

PC机一般都基于此目录； ● Include/: include子目录包括编译核心所需要的大部分头文件。

与平台无关的头文件在 include/linux子目录下，与 intel cpu相关的头文件在include/asm-i386子目录下,而include/scsi目录则是有关scsi设备的头文件目录； ● Init/： 这个目录包含核心的初始化代码(注：不是系统的引导代码)，包含两个文件main.c和Version.c，这是研究核心如何工作的好的起点之一。

● Mm/：这个目录包括所有独立于 cpu 体系结构的内存管理代码，如页式存储管理内存的分配和释放等；而和体系结构相关的内存管理代码则位于arch/*/mm/，例如arch/i386/mm/Fault.c； ● Kernel/：主要的核心代码，此目录下的文件实现了大多数linux系统的内核函数，其中最重要的文件当属sched.c；同样，和体系结构相关的代码在arch/*/kernel中； ● Drivers/： 放置系统所有的设备驱动程序；每种驱动程序又各占用一个子目录：如，/block 下为块设备驱动程序，比如ide（ide.c）。

如果你希望查看所有可能包含文件系统的设备是如何初始化的，你可以看drivers/block/genhd.c中的device_setup()。

它不仅初始化硬盘，也初始化网络，因为安装nfs文件系统的时候需要网络； ● Documentation/: 文档目录,没有内核代码，只是一套有用的文档，可惜都是English的，看看应该有用的哦； ● Fs/: 所有的文件系统代码和各种类型的文件操作代码，它的每一个子目录支持一个文件系统, 例如fat和ext2； ● Ipc/: 这个目录包含核心的进程间通讯的代码； ● Lib/: 放置核心的库代码； ● Net/: 核心与网络相关的代码； ● Modules/: 模块文件目录，是个空目录，用于存放编译时产生的模块目标文件； ● Scripts/: 描述文件，脚本，用于对核心的配置； 一般，在每个子目录下，都有一个 Makefile 和一个Readme 文件，仔细阅读这两个文件，对内核源码的理解很有用。

对Linux内核源码的分析，有几个很好的入口点：一个就是系统的引导和初始化，即从机器加电到系统核心的运行；另外一个就是系统调用，系统调用是用户程序或操作调用核心所提供的功能的接口。

对于那些对硬件比较熟悉的爱好者，从系统的引导入手进行分析，可能来的容易一些；而从系统调用下口，则可能更合适于那些在dos或Uinx、Linux下有过C编程经验的高手。

如何查看 linux 内核源代码

Linux的内核源代码可以从很多途径得到。

一般来讲，在安装的linux系统下，/usr/src/linux目录下的东西就是内核源代码。

对于源代码的阅读，要想比较顺利，事先最好对源代码的知识背景有一定的了解。

对于linux内核源代码来讲，我认为，基本要求是:1、操作系统的基本知识;2、对C语言比较熟悉，最好要有汇编语言的知识和GNU C对标准C的扩展的知识的了解。

另外在阅读之前，还应该知道Linux内核源代码的整体分布情况。

我们知道现代的操作系统一般由进程管理、内存管理、文件系统、驱动程序、网络等组成。

看一下Linux内核源代码就可看出，各个目录大致对应了这些方面。

Linux内核源代码的组成如下(假设相对于linux目录): arch 这个子目录包含了此核心源代码所支持的硬件体系结构相关的核心代码。

如对于X86平台就是i386。

include 这个目录包括了核心的大多数include文件。

另外对于每种支持的体系结构分别有一个子目录。

init 此目录包含核心启动代码。

mm 此目录包含了所有的内存管理代码。

与具体硬件体系结构相关的内存管理代码位于arch/*/mm目录下，如对应于X86的就是arch/i386/mm/fault.c 。

drivers 系统中所有的设备驱动都位于此目录中。

它又进一步划分成几类设备驱动，每一种也有对应的子目录，如声卡的驱动对应于drivers/sound。

ipc 此目录包含了核心的进程间通讯代码。

modules 此目录包含已建好可动态加载的模块。

fs Linux支持的文件系统代码。

不同的文件系统有不同的子目录对应，如ext2文件系统对应的就是ext2子目录。

kernel 主要核心代码。

同时与处理器结构相关代码都放在arch/*/kernel目录下。

核心的网络部分代码。

里面的每个子目录对应于网络的一个方面。

lib 此目录包含了核心的库代码。

与处理器结构相关库代码被放在arch/*/lib/目录下。

scripts此目录包含用于配置核心的脚本文件。

Documentation 此目录是一些文档，起参考作用。

俗话说:“工欲善其事，必先利其器”。

阅读象Linux核心代码这样的复杂程序令人望而生畏。

它象一个越滚越大的雪球，阅读核心某个部分经常要用到好几个其他的相关文件，不久你将会忘记你原来在干什么。

所以没有一个好的工具是不行的。

由于大部分爱好者对于Window平台比较熟悉，并且还是常用Window系列平台，所以在此我介绍一个Window下的一个工具软件:Source Insight。

这是一个有30天免费期的软件，可以从下载。

安装非常简单，和别的安装一样，双击安装文件名，然后按提示进行就可以了。

安装完成后，就可启动该程序。

这个软件使用起来非常简单，是一个阅读源代码的好工具。

它的使用简单介绍如下:先选择Project菜单下的new，新建一个工程，输入工程名，接着要求你把欲读的源代码加入(可以整个目录加)后，该软件就分析你所加的源代码。

分析完后，就可以进行阅读了。

对于打开的阅读文件，如果想看某一变量的定义，先把光标定位于该变量，然后点击工具条上的相应选项，该变量的定义就显示出来。

对于函数的定义与实现也可以同样操作。

别的功能在这里就不说了，有兴趣的朋友可以装一个Source Insight，那样你阅读源代码的效率会有很大提高的。

怎么样，试试吧!

怎么使用，手上有一本linux内核2.4版源代码分析大全

一般在Linux系统中的/usr/src/linux*.*.*（*.*.*代表的是内核版本，如2.4.23）目录下就是内核源代码（如果没有类似目录，是因为还没安装内核代码）。

另外还可从互连网上下载。

注意，不要总到去下载，最好使用它的镜像站点下载。

请在mirrors/里找一个合适的下载点，再到pub/linux/kernel/v2.6/目录下去下载2.4.23内核。

代码目录结构 在阅读源码之前，还应知道Linux内核源码的整体分布情况。

现代的操作系统一般由进程管理、内存管理、文件系统、驱动程序和网络等组成。

Linux内核源码的各个目录大致与此相对应，其组成如下（假设相对于Linux-2.4.23目录）： 1.arch目录包括了所有和体系结构相关的核心代码。

它下面的每一个子目录都代表一种Linux支持的体系结构，例如i386就是Intel CPU及与之相兼容体系结构的子目录。

PC机一般都基于此目录。

2.include目录包括编译核心所需要的大部分头文件，例如与平台无关的头文件在include/linux子目录下。

3.init目录包含核心的初始化代码（不是系统的引导代码），有main.c和Version.c两个文件。

这是研究核心如何工作的好起点。

4.mm目录包含了所有的内存管理代码。

与具体硬件体系结构相关的内存管理代码位于arch/*/mm目录下。

5.drivers目录中是系统中所有的设备驱动程序。

它又进一步划分成几类设备驱动，每一种有对应的子目录，如声卡的驱动对应于drivers/sound。

6.ipc目录包含了核心进程间的通信代码。

7.modules目录存放了已建好的、可动态加载的模块。

8.fs目录存放Linux支持的文件系统代码。

不同的文件系统有不同的子目录对应，如ext3文件系统对应的就是ext3子目录。

Kernel内核管理的核心代码放在这里。

同时与处理器结构相关代码都放在arch/*/kernel目录下。

目录里是核心的网络部分代码，其每个子目录对应于网络的一个方面。

10.lib目录包含了核心的库代码，不过与处理器结构相关的库代码被放在arch/*/lib/目录下。

11.scripts目录包含用于配置核心的脚本文件。

12.documentation目录下是一些文档，是对每个目录作用的具体说明。

一般在每个目录下都有一个.depend文件和一个Makefile文件。

这两个文件都是编译时使用的辅助文件。

仔细阅读这两个文件对弄清各个文件之间的联系和依托关系很有帮助。

另外有的目录下还有Readme文件，它是对该目录下文件的一些说明，同样有利于对内核源码的理解。

在阅读方法或顺序上，有纵向与横向之分。

所谓纵向就是顺着程序的执行顺序逐步进行；所谓横向，就是按模块进行。

它们经常结合在一起进行。

对于Linux启动的代码可顺着Linux的启动顺序一步步来阅读；对于像内存管理部分，可以单独拿出来进行阅读分析。

实际上这是一个反复的过程，不可能读一遍就理解。