学习linux内核，这个可不像学一门语言，c或者java一个月或者3月你就能精通掌握。学习linux内核是需要一步一步循序渐进，掌握正确的linux内核学习路线对学习至关重要，本篇文章就来分享学习linux内核的一些建议吧。
 
1. 了解操作系统基本概念。如果不会，可以学习《操作系统：设计与实现》Andrew S.Tanenbaum 写的那本。以MINIX为例子讲解操作系统的概念。非常推荐。
 
2. 有了操作系统的基本概念以后，可以了解Linux的机制了。推荐《Linux内核设计与实现》Robert Love 写的。这本书从概念上讲解了Linux有什么，他们是怎么运行的。这本书要反复认真看透。
 
3. 有了Linux内核的了解，还需要具体研究Linux内核源码。经典的就是《深入理解Linux内核》Daniel P. Bovet 写的。学习这本书的时候，要对着内核代码看着学。这本书学起来相当费力了，那么多多代码要研究。不过这本书如果学明白了，恭喜你，Linux内核你已经很熟悉了。
 
4. 如果要开发设备驱动，可以学习《linux设备驱动程序》O'Reilly出版社的。这本作为驱动的入门是很好的资料。另外还有一本《精通Linux 驱动程序开发》也是不错的教材，可以参考着看。学习驱动，免不了要学习一些硬件的协议和资料，研究哪个就找到相应的硬件文档，把硬件的工作原理搞明白。这些就不细说了。
 
5. 网络部分，学些Linux网络部分就学习《深入理解LINUX网络技术内幕》。这本书把Linux的网络部分讲的非常清晰透彻。但是通常不做这方面的工作研究，也不用研究这么深，毕竟现在相关职位较少。
 
6. 现在Linux相关的工作，多集中在一些嵌入式开发领域，arm，mips等，要学习以下这些体系架构的的资料，了解CPU的设计和工作方式。ARM就看对应的芯片手册，讲的很细致。MIPS就看 《see mips run》，有一二两版，两版内容有些差异，推荐都看。
 
7. 补充一点经验。不要认为Linux很庞大，很复杂，就觉的很难学。任何东西认真学下来都是能学会的，看你都恒心和毅力了。另外，不要走弯路，不要看市面上讲什么Linux0.11的那些书，直接学你要学的东西。就像学C语言看什么谭浩强一样，弯路走了，力气没少花，还严重影响学习效果。
 
关于linux内核学习路线，再多说几句应用编程，有时候经常会需要的：
 
1. 学习Linux应用编程，建议看《unix环境高级编程》，把里面的例子都做一遍，会对整个Linux编程有系统都认识。
 
2. 针对Linux，有本 《Linux系统编程》，学完上一本，这本很快看一遍就懂了。主要是针对Linux具体懂一些内容，讲的挺全了，很实用。
 
3. Linux网络编程，系统的学习一下《unix网络编程.卷1,套接字联网api》，基本上网络应用相关的程序就都没问题了。
 
这些内容，分几年时间，分步计划学习，就会成为Linux高手了

linux 内核学习3-自己编译一个ARM Linux内核
 
1. 目的
 
编译一个ARM版本的内核镜像，谁让我是做Android的呢！并且在QEMU上运行。
 
2. 准备工作
 
2.1 开发环境
 
ubuntu 18.4虚拟机
linux内核版本 4.19.67 linux内核地址
busybox 工具包
 
3.编译过程
 
3. busybox编译
 
$ cd busybox
$ export ARCH=arm
$ export CROSS_COMPILE=arm-linux-gnueabi-
$ make menuconfig
 
进入menuconfig之后，配置成静态编译
 
Busybox Settings  ---->
	Build Options     ---->
			[*] Build BusyBox as a static binary  (no shared libs)
 
# make && make install
 
3.2创建必须的文件
 
这个时候在busybox根目录下回有一个_install目录,该目录存放了编译好的文件系统需要的一些命令合计
 将_install 目录复制到linux-4.0 目录下。进入_install 目录，先创建etc、dev等目录。
 
# mkdir etc
# mkdir dev
# mkdir mnt
# mkdir -p etc/init.d/
 
在_install /etc/init.d/目录下新建一个rcS文件，并写入如下内容
 
mkdir -p /sys
mkdir -p /tmp
mkdir -p /proc
mkdir -p /mnt
/bin/mount -a
mkdir -p /dev/pts
mount -t devpts devpts /dev/pts
echo /sbin/mdev > /proc/sys/kernel/hotplug
mdev -s
 
修改_install/etc/init.d/rcS 文件需要可执行权限，可以使用chmod命令来实现，比如chmod +x_install/etc/init.d/rcS。
 在_install /etc 目录中新建一个fstab文件，并写入如下内容。
 
proc /proc proc defaults 0 0
tmpfs /tmp tmpfs defaults 0 0
sysfs /sys sysfs defaults 0 0
tmpfs /dev tmpfs defaults 0 0
debugfs /sys/kernel/debug debugfs defaults 0 0
 
 
在_install /etc 目录中新建一个inittab文件，并写入如下内容
 
::sysinit:/etc/init.d/rcS
::respawn:-/bin/sh
::askfirst:-/bin/sh
::ctrlaltdel:/bin/umount -a -r
 
在_install/dev 目录中创建如下设备结点，这时需要root权限。
 
cd _install/dev/
sudo mknod console c 5 1
sudo mknod null c 1 3
 
 
3.3. 编译内核配置
 
$ cd linux-4.0
$ export ARCH=arm
$ export CROSS_COMPILE=arm-linux-gnueabi-
$ make vexpress_defconfig
$ make menuconfig
 
配置 initramfs,在 initramfs source file 中填入_install ，并把Default kernel command string清空
 
接着
 
 General setup  --->  
		  [*] Initial RAM filesystem and RAM disk (initramfs/initrd) support 
        		 (_install) Initramfs source file(s)  

Boot options --->
	()Default kernel command string

Kernel Features --->
	Memory split(3G/1G user/kernel split)--->
	[*] High Memory Support
 
注意，(_install) Initramfs source file(s)这个要通过enter键进入，输入_install
 
3.4 开始编译内核
 
$ make bzImage -j4 ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-
$ make dtbs
 
3.5 运行QEMU虚拟机
 
 qemu-system-arm -M vexpress-a9 -smp 4 -m 200M -kernel arch/arm/boot/zImage -append "rdinit=/linuxrc console=ttyAMA0 loglevel=8" -dtb arch/arm/boot/dts/vexpress-v2p-ca9.dtb -nographic

 
4.其他
 
这里的操作流程参考的是奔跑吧linux内核入门篇。大家想学习linux内核，可以去买奔跑吧linux内核 入门篇和奔跑吧linux内核。
 这里给到作者笨叔叔的学习资料 github地址 这里有笨叔叔调教好的linux内核。这来有他的视频教程 视频地址 内核地址

linux内核获取 官网： https://www.kernel.org/
 
 
 Linux操作系统的核心是模块化，可以使用lsmod命令查看内核模块，下面展示已载入系统的模块：
 
 
[root@172.16.0.55: vendor/composer → test]$ lsmod
Module                  Size  Used by
nfnetlink_queue         8111  0 
nfnetlink_log           8718  0 
nfnetlink               4200  2 nfnetlink_queue,nfnetlink_log
bluetooth              99271  0 
rfkill                 19255  1 bluetooth
bridge                 83177  0 
stp                     2218  1 bridge
llc                     5546  2 bridge,stp
iptable_filter          2793  0 
ip_tables              17831  1 iptable_filter
ipv6                  317340  134 
 
内核模块化设计的好处
 
（1）内核功能可裁剪、增加灵活性。
 
（2）可扩展性（动态安装卸载、新硬件支持）。
 
（3）利于协作。
 
宏内核与微内核　　
 
　　宏内核 ( Macrokernel)：也叫单内核。
 
　　微内核（Micro kernel）
 
　　现在的系统都在开始走向微内核（提供操作系统核心功能的内核的精简版本）。目前linux内核是宏内核。
 
 
 
　　　　　　　　　　　　　　　　　　图片源于网上
 
Linux系统组成
 
　　Linux系统一般有4个主要部分，分别是应用程序，shell、内核，文件系统。shell，内核文件系统构成了基本操作系统结构，在它之上使得用户可以运行程序、管理文件并使用系统。如下图所示。
 
　　 
 
Linux内核架构图如下
 
 
linux内核学习的三个步骤
 
 　　1.Linux内核编译环境。
 
　　 2.Linux内核模块编写。
 
　　 3.Linux内核模块编译及调试。
 
如何查看Linux源码。
 
　　Linux核心源程序通常都安装在/usr/src/linux下。
 
学习中........
 
 以上就是良许教程网为各位朋友分享的Linux相关知识。

 
 
《linux内核设计艺术》写的很好，对于理解操作系统的工作原理有很大帮助，以下是我在读这本书时所整理的一些框架，希望可以对读者理解linux操作系统的内核起到一定的作用，由于本人水平有限，不足之处，欢迎广大读者留言指正。
 
1.linux启动     
 
计算机在启动时,内存中是没有程序的,所以需要将硬盘中的操作系统加载到内存中,在内存(RAM)中什么程序也没有的时候,是由BIOS来完成加载硬盘中操作系统的任务的.
 
那么是由谁来执行BIOS程序呢?
 
当然不可能由软件来执行!
 
Intel采用了硬件的解决方案,将所有80x86的CPU的硬件都设计为加电进入16位实模式运行,同时,将CPU的硬件逻辑设计为加电瞬间强行将CS的置为0xffff,IP的值置为0x0000,这样CS:IP指向了0xffff0这个位置.
 
BIO的第一条指令便在0xffff00地址上.
 
那么BIOS程序不被放在内存中,又被放在哪里呢,但是BIOS的起始地址是通过寻址找到的,那么寻址便是寻内存中的地址,这两者自相矛盾又作何解释呢?
 
BIOS程序被固化在计算机主板上的一块很小ROM芯片上.
 
随着BIOS程序的执行,BIOS会检测显卡,内存......,期间,由一项对启动操作系统至关重要的工作,便是在内存中建立中断向量表和中断服务程序.
 
中断向量表有256个中断向量,每个中断向量占4个字节,其中两个字节是CS的值,两个字节是IP的值,每个中断向量都指向一个具体的中断服务程序.
 
 
 
 
 
2.从main到怠速
 
怠速的意思就是操作系统已经完成了所有的准备工作,随时可以响应用户激励.
 
系统达到怠速状态前所做的一切准备工作的核心目的是让用户程序能够以”进程”的方式正常运行,即能够在主机上进行运算,能够与外设进行交互,能够让用户以他为媒介进行人机交互.
 
创建进程0:
 
每一个进程都是由已经存在的进程创建的,新建的进程具备创建他的进程应该具备的一切能力.因此需要创建一个最原始的进程,进程0,该进程能在主机中进行运算.
 
创建进程1:
 
进程1在进程0的基础上能以文件的形式与外设进行数据交互.
 
创建进程2:
 
进程2将构建一套人机交互界面,以支持用户与计算机的交互,最终进入怠速状态,进程2将成为创建地一个用户进程的母本.
 
 
 
 
 
3.用户进程与内存管理
 
在shell输入指令./str1,shell程序将调用fork函数创建进程.然后产生软中断,然后调用system_call函数,并通过call_system_cal_table映射到sys_fork函数.
 
调用find_empty_process函数,为进程申请进程号和在进程槽中为该进程申请一个空闲位置. 
 
进程的退出
 
进程通过exit函数退出,最终会映射到sys_exit函数执行.
 
第一步:释放str1进程代码与数据所占用的物理内存并解除其与str1这个可执行文件的关系,有str1进程自己负责.
 
第二部:shell进程由于接受都str1发送的信号而被唤醒,于是切换到shell进程执行,释放str1进程的管理结构所占用的物理内存(页面)并接触与进程槽的关系.
 
 
 
多个用户进程同时运行
 
依次创建3个用户进程.进程号为5,6,7进程槽中的项号为4,5,6,线性地址空间的位置是4*64M~5*64M,5*64M~6*64M,6*64M~7*64M.
 
Str1执行过程中,str1每10ms产生一次始终中断;
 
	void do_timer(long cpl) 
{ 
	extern int beepcount; 
	extern void sysbeepstop(void); 

	if (beepcount) 
		if (!--beepcount) 
			sysbeepstop(); 

	if (cpl) 
		current->utime++; 
	else 
		current->stime++; 

	if (next_timer) { 
		next_timer->jiffies--; 
		while (next_timer && next_timer->jiffies <= 0) { 
			void (*fn)(void); 
			 
			fn = next_timer->fn; 
			next_timer->fn = NULL; 
			next_timer = next_timer->next; 
			(fn)(); 
		} 
	} 
	if (current_DOR & 0xf0) 
		do_floppy_timer(); 
	if ((--current->counter)>0) return; 削减时间片的动作
	current->counter=0; 
	if (!cpl) return; 
	schedule(); 
}
 

 在中断处理函数中调用schedule函数;
 
开始执行str2;
 
shell在创建玩新进程后会进入task_interruptible状态.shell进程调用schedule函数.
 
在schedule函数中,从进程槽task[64]的数组末端开始扫描当前系统中已存在的进程
 
之后开始第二次遍历.
 
 
 
4.文件系统
 
文件系统首先设计了一个数据结构,管理属于同一个文件所有的块,这个数据结构就是i节点。
 
 
 
 
 
5.IPC(进程间通讯)
 
管道机制
 
在父进程中创建一个子进程,然后在父进程中创建一个管道,父进程中不断往管道写数据,子进程不断从管道读数据.
 
假设读管道的进程开始运行,由于此时管道中没有数据,系统会将读管道进程挂起,切换到写管道进程中去.
 
管道默认规则:每次写管道执行哇比后,管道中就已经拥有了可以读出的数据,所以就会唤醒读管道进程;每次读管道操作执行完毕后,管道中就已经拥有了可以写入的空间,所以就会唤醒写管道进程.
 
 
 
信号机制
 
创建两个进程,一个发送信号sebdsig,一个接受及处理信号processig.
 
运行processig进程,在该进程中实现信号与处理函数的绑定.
 
single(SIGUSR1,sig_usr);
 
第一个参数是信号类型,第二个参数是信号处理函数的函数指针.
 
会调用系统的sys_signal函数.
 
 
 
int sys_signal(int signum, long handler, long restorer) 
{ 
	struct sigaction tmp; 

	if (signum<1 || signum>32 || signum==SIGKILL) 
		return -1; 
	tmp.sa_handler = (void (*)(int)) handler; 
	tmp.sa_mask = 0; 
	tmp.sa_flags = SA_ONESHOT | SA_NOMASK; 
	tmp.sa_restorer = (void (*)(void)) restorer; 
	handler = (long) current->sigaction[signum-1].sa_handler; 
	current->sigaction[signum-1] = tmp; 
	return handler; 
}
tmp.sa_handler = (void (*)(int)) handler; 执行了绑定工作.
current->sigaction[signum-1] = tmp; 给sigaction这个管理结构赋值.
 
sigaction[32]有32个成员,对应默认的32种信号.
 
 
 
 
 
然后调用pause函数,使该进程进入可中断等待状态.
 
int sys_pause(void) 
{ 
	current->state = TASK_INTERRUPTIBLE; 
	schedule(); 
	return 0; 
}
 

 执行sendsig进程
 
在sendsig函数中执行kill(pid,signo)函数.映射到sys_kill函数.
 
参数1:表示信号
 
参数2:接收该信号的进程的进程号.
 
int sys_kill(int pid,int sig) 
{ 
	struct task_struct **p = NR_TASKS + task; 
	int err, retval = 0; 

	if (!pid) while (--p > &FIRST_TASK) { 
		if (*p && (*p)->pgrp == current->pid) 
			if (err=send_sig(sig,*p,1)) 
				retval = err; 
	} else if (pid>0) while (--p > &FIRST_TASK) { 
		if (*p && (*p)->pid == pid) 
			if (err=send_sig(sig,*p,0)) 
				retval = err; 
	} else if (pid == -1) while (--p > &FIRST_TASK) 
		if (err = send_sig(sig,*p,0)) 
			retval = err; 
	else while (--p > &FIRST_TASK) 
		if (*p && (*p)->pgrp == -pid) 
			if (err = send_sig(sig,*p,0)) 
				retval = err; 
	return retval; 
} 

static void tell_father(int pid) 
{ 
	int i; 

	if (pid) 
		for (i=0;i<NR_TASKS;i++) { 
			if (!task[i]) 
				continue; 
			if (task[i]->pid != pid) 
				continue; 
			task[i]->signal |= (1<<(SIGCHLD-1)); 
			return; 
		} 
/* if we don't find any fathers, we just release ourselves */ 
/* This is not really OK. Must change it to make father 1 */ 
	printk("BAD BAD - no father found\n\r"); 
	release(current); 
}
 
 
 
 
 
 
 
 
 
err = send_sig(sig,*p,0)执行了发送信号的动作,他会在processig进程的信号位图signal中找到SIGUSR1这一信号对应的位置,然后将其置1,以此来发送信号.
 
然后返回用户空间,直至时间片用完.
 
调用schedual函数;
 
从这里可以反映出为什么要遍历两次进程槽.
 
当前的prodesig进程是处于可中断等待状态的,第一次遍历到prodesig的时候,他的信号位图四个哪里上就会有所体现,所以该进会被改为就绪状态.
 
第二次遍历时,便可以切换到prodesig进程执行.
 
然后同样会执行pause函数,但这次执行没有意义,有意义的是该函数会调用系统函数,当从系统函数返回时,会调用ret_from_sys_call函数.
 
 
 
ret_from_sys_call: 
	movl _current,%eax		# task[0] cannot have signals 
	cmpl _task,%eax 
	je 3f 
	cmpw $0x0f,CS(%esp)		# was old code segment supervisor ? 
	jne 3f 
	cmpw $0x17,OLDSS(%esp)		# was stack segment = 0x17 ? 
	jne 3f 
	movl signal(%eax),%ebx 
	movl blocked(%eax),%ecx 
	notl %ecx 
	andl %ebx,%ecx 
	bsfl %ecx,%ecx 
	je 3f 
	btrl %ecx,%ebx 
	movl %ebx,signal(%eax) 
	incl %ecx 
	pushl %ecx 
	call _do_signal 
	popl %eax 
3:	popl %eax 
	popl %ebx 
	popl %ecx 
	popl %edx 
	pop %fs 
	pop %es 
	pop %ds 
	iret
会调用do_signal函数.
void do_signal(long signr,long eax, long ebx, long ecx, long edx, 
	long fs, long es, long ds, 
	long eip, long cs, long eflags, 
	unsigned long * esp, long ss) 
{ 
	unsigned long sa_handler; 
	long old_eip=eip; 
	struct sigaction * sa = current->sigaction + signr - 1; 
	int longs; 
	unsigned long * tmp_esp; 

	sa_handler = (unsigned long) sa->sa_handler; 
	if (sa_handler==1) 
		return; 
	if (!sa_handler) { 
		if (signr==SIGCHLD) 
			return; 
		else 
			do_exit(1<<(signr-1)); 
	} 
	if (sa->sa_flags & SA_ONESHOT) 
		sa->sa_handler = NULL; 
	*(&eip) = sa_handler; 
	longs = (sa->sa_flags & SA_NOMASK)?7:8; 
	*(&esp) -= longs; 
	verify_area(esp,longs*4); 
	tmp_esp=esp; 
	put_fs_long((long) sa->sa_restorer,tmp_esp++); 
	put_fs_long(signr,tmp_esp++); 
	if (!(sa->sa_flags & SA_NOMASK)) 
		put_fs_long(current->blocked,tmp_esp++); 
	put_fs_long(eax,tmp_esp++); 
	put_fs_long(ecx,tmp_esp++); 
	put_fs_long(edx,tmp_esp++); 
	put_fs_long(eflags,tmp_esp++); 
	put_fs_long(old_eip,tmp_esp++); 
	current->blocked |= sa->sa_mask; 
}
 
 
 
6.编译
 
 
 
 Linux中头文件与同名源文件的关系
 
系统自带的头文件用尖括号括起来，这样编译器会在系统文件目录下查找， #include <xxx.h> 。
 
用户自定义的文件用双引号括起来，编译器首先会在用户目录下查找，然后在到C++安装目录（比如VC中可以指定和修改库文件查找路径，Unix和 Linux中可以通过环境变量来设定）中查找，最后在系统文件中查找。 #include “xxx.h” 6.2 头文件如何来关联源文件 
 
这个问题实际上是说，已知头文件“a.h”声明了一系列函数，“b.cpp”中实现了这些函数，那么如果我想在“c.cpp”中使用“a.h”中声明的这 些在“b.cpp”中实现的函数，通常都是在“c.cpp”中使用#include “a.h”,那么c.cpp是怎样找到b.cpp中的实现呢？ 
 
其实.cpp和.h文件名称没有任何直接关系，很多编译器都可以接受其他扩展名。比如偶现在看到偶们公司的源代码，.cpp文件由.cc文件替代了。 
 
在Turbo C中，采用命令行方式进行编译，命令行参数为文件的名称，默认的是.cpp和.h，但是也可以自定义为.xxx等等。 
 
谭浩强老师的《C程序设计》一书中提到，编译器预处理时，要对#include命令进行“文件包含处理”：将file2.c的全部内容复制 到#include “file2.c”处。这也正说明了，为什么很多编译器并不care到底这个文件的后缀名是什么----因为#include预处理就是完成了一个“复制 并插入代码”的工作。 
 
编译的时候，并不会去找b.cpp文件中的函数实现，只有在link的时候才进行这个工作。我们在b.cpp或c.cpp中用#include “a.h”实际上是引入相关声明，使得编译可以通过，程序并不关心实现是在哪里，是怎么实现的。源文件编译后成生了目标文件（.o或.obj文件），目标 文件中，这些函数和变量就视作一个个符号。在link的时候，需要在makefile里面说明需要连接哪个.o或.obj文件（在这里是b.cpp生成 的.o或.obj文件），此时，连接器会去这个.o或.obj文件中找在b.cpp中实现的函数，再把他们build到makefile中指定的那个可以 执行文件中。 
 
在Unix下，甚至可以不在源文件中包括头文件，只需要在makefile中指名即可（不过这样大大降低了程序可读性，是个不好的习惯哦^ ^）。在VC中，一般情况下不需要自己写makefile，只需要将需要的文件都包括在project中，VC会自动帮你把makefile写好。 
 
通常，编译器会在每个.o或.obj文件中都去找一下所需要的符号，而不是只在某个文件中找或者说找到一个就不找了。因此，如果在几个不同文件中实现了同一个函数，或者定义了同一个全局变量，链接的时候就会提示“redefined”。