标签归档:kernel

Linux内核学习总结

文章目录:

  1. 实验:通过反汇编一个简单的C程序,分析汇编代码理解计算机是如何工作的
  2. 实验:完成一个简单的时间片轮转多道程序内核代码
  3. 实验:跟踪分析Linux内核的启动过程
  4. 使用库函数API和C代码中嵌入汇编代码两种方式使用同一个系统调用
  5. 从system_call开始到iret
  6. 分析Linux内核创建一个新进程的过程
  7. linux可执行文件的装载
  8. 理解进程调度时机跟踪分析进程调度与进程切换的过程

1#我对linux系统的理解

linux很难,这8周的学习我对绝对还是不理解Linux的。只能说比学之前更理解它了。很多细节深入到底层硬件方面的问题,所以还需要有计算机组成原理的知识,尤其是在堆栈方面的讨论。

linux的哲学

Linux is built with a certain set of unifying principles in mind. Understanding these principles is very helpful in understanding how the system works as a whole. They are known as the “Linux Way”, which is derived from the philosophy behind the UNIX system.

The Linux Way can be summarized as:

  • Use programs that do only one task, but do it well.
    <br/>
    
  • To accomplish complex tasks, use several programs linked together.
    
  • Store information in human-readable plain text files whenever it is possible.
    
  • There is no "one true way" to do anything.
    
  • Prefer commandline tools over graphical tools.
    

Most traits of Linux are a consequence of these principles. In accordance with them, a Linux system is built out of small, replaceable components. We will examine the most important of them in more detail. Those are: the boot loader, the kernel, the shell, the X window server, the window manager and the desktop environment. After that, we will have a look at the file system in Linux. Finally, we will discuss the security of a computer running Linux.

——

Linux Guide/How Linux Works

简单总结就是KISS(keep it simple and stupid)原则

  • 用程序来完成一项任务,然后把任务做好。

  • 复杂的任务用多个程序来完成。

  • 把信息存在更人性化的文本中。

  • 没有唯一的方法。

  • 命令行能做的事就不用图形工具来完成。

这些原则使linux保持简单且高效。

用户通过交互程序与内核打交道,而内核则与硬件直接打交道。这样就把用户、内核、硬件分离开。因此内核就是理解linux的关键。

在内核与用户之间并不是直接关联的,而是通过系统调用来把用户和内核隔离开。这样既安全又方便程序员进行编程,而不是深入到内核中去操作。

内核中又分为多个模块,各各模块管理者不同的任务

通过这些模块与硬件进行打交道
整体框架大概就是这样。我并不是程序员,从我学习的目的来说我并不需要深入到每个模块是如何实现的一些具体细节。就像程序员编程不需要知道每个轮子是怎么制造的一样。 Kernel (operating system)
2#反思实验都做了些什么?

八周下来,周周有实验。再把每周标题串起来,构建一条思路。


###先整体:1~3周

1.计算机只能读懂机器代码,因此我们编程后还要将代码转换成机器代码

2.计算机要高效,就必须多个进程进行轮转。因此就产生了切换时机问题,上下文保存切换问题。

###再系统:4~5周

所谓三层皮目的就是将用户与内核分隔开。用户程序调用API,API调用系统调用,系统调用调用内核

###最后细节:6~8周

三层皮之间的相互调用必然涉及到不用的程序执行,也就是进程切换。进程又可分为用户空间和内核空间进程。进程进行切换,又设计到上下文的保存于切换,于是又回到底层的堆栈操作上。实际上我认为,在这里程序员就不再需要讨论堆栈操作了,将堆栈操作留给系统去做就可以了。否则就会陷入到无限的细节中。这也就是为什么对内核进行层层封装了。

#3.总结课程

这门课让我对linux有了一个感性的认识,这些认识对我日后学习嵌入式必然有帮助。我学习这门课的目的也大体达到。剩下的一些问题,或者说缺乏的理性认识,则可以在实践中慢慢摸索。

《Linux内核分析》课程后最大的遗憾?好吧,那就是缺乏对细节的把握。这单单看视频是不够的。

==================================================

sunfy + 原创作品转载请注明出处 + 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000

分析Linux内核创建一个新进程的过程

task_struct数据结构

linux进程管理分析

In user space, the process is the process identifier (PID) said. From the user’s perspective, a PID is a numeric value, can uniquely identify a process. A PID does not change during the whole life process, but PID can be re used in the process is destroyed, so they are not always ideal cache.

In user space, to create the process can be used in several ways. You can execute a program (which leads to create a new process), also can be in within the program, called a fork or Exec System Call. Fork calls will lead to create a child process, and the exec call will use the new program instead of the current process context.

在用户空间中,每个进程都有一个独一无二的PID。从用户的角度来看,PID在整个进程过程中都不能够改变,但当进程被回收后,PID则可以再次被利用。

在用户态中创建一个进程有多种方法。

  1. 你可以运行一个程序,而程序就会自动创建一个进程。

  2. 也可以在一个进程中庸系统调用创建一个进程。例如:Fork可以创建一个子进程。

精简的task_struct:

Task_struct 在/linux/include/linux/sched.h.

Task_struct

{

  • Volatile long state;
    
  • Long counter;
    
  • Long priority
    
  • Unsigned long signals;  // pending sigs
    
  • Unsigned long blocked; //masked sigs
    
  • Int pid, pgrp, uid, euid, gid, egid;
    
  • Struct linux_binfmt;
    
  • Struct task_struct p_opptr;    // ptr to original parent
    
  • Struct task_struct p_pptr;     // ptr to immediate parent
    
  • Struct task_struct p_cptr;     // ptr to most recent child
    
  • Struct task_struct p_ysptr;    // ptr to following sibling
    
  • Struct task_struct p_osptr;    // ptr to previous sibling
    
  • Struct task_struct *next_task;  // in process list
    
  • Struct task_struct *prev_task;  // in process list
    
  • Struct task_struct *next_run; // in ready queue
    
  • Struct task_struct *prev_run; //in ready queue
    
  • Struct mm_struct  mm[1];
    
  • Unsigned long kernel_stack_page;
    
  • Unsigned long saved_kernel_stack;
    
  • Struct fs_struct fs[1];
    
  • Long utime, stime, cutime, cstime, start_time;
    
  • Struct sem_queue *semsleeping;
    
  • Struct wait_queue *wait_chldexit;
    
  • Struct sigaction sigaction[32];
    
  • Struct rlimit rlim[RLIM_NLIMITS];
    
  • Struct thread_struct tss;  // includes saved registers
    
  • Unsigned long policy;  // SCHED_FIFO,SCHED_RR,SCHED_OTHER
    
  • Unsigned long rt_priority;
    
  • // for SMPs
    
  • Int processor, last processor;
    
  • Int lock_depth;
    
  • }

进程的状态:

task_struct field:

long state;

5 States (see include/linux/sched.h):

  • #define TASK_RUNNING            0
    
  • #define TASK_INTERRUPTIBLE      1
    
  • #define TASK_UNINTERRUPTIBLE    2
    
  • #define TASK_ZOMBIE             4
    
  • #define TASK_STOPPED            8
    

进程的创建:

从该图可以看出do_fork是创建进程的基本函数。do_fork在/linux/kernel/fork.c,包括copy_process().

所以我们主要来看看do_fork:

在 Linux 内核中,供用户创建进程的系统调用fork()函数的响应函数是 sys_fork()、sys_clone()、sys_vfork()。这三个函数都是通过调用内核函数 do_fork() 来实现的。根据调用时所使用的 clone_flags 参数不同,do_fork() 函数完成的工作也各异。

Clone flags = CLONE_VM, CLONE_FS, CLONE_FILES, CLONE_SIGHAND, CLONE_PID

/

/do_fork中的主要函数调用

do_fork(clone_flags, unsigned long usp, struct pt_regs *regs)

{

  • p = copy_process();//调用该函数用来设置进程的信息,包括进程描述、其他数据等
    
    
    :
    
  • wake_up_new_task(p, clone_flags);
    

}

参数说明:

clone_flags:这和 clone( )的flags参数相同。

stack_start:这也和clone()中的child_stack参数一样。

regs:Pointer to the values of the general purpose registers saved into the Kernel Mode stack when switching from User Mode to Kernel Mode.

stack_size:我查到的资料并不太明确知道这个参数具体是做什么的。通常将它设置为0.

parent_tidptr, child_tidptr:这和clone()中的ptid and ctid参数一样。

clone主要的flags:

CLONE_PTRACE:P.S.: If CLONE_PTRACE is specified, and the calling process is being traced, then trace the child also.

CLONE_STOPPED:强制子进程从TASK_STOPPED状态开始。

CLONE_UNTRACED:Set by the kernel to override the value of the CLONE_PTRACE flag

CLONE_VM:Shares the memory descriptor and all page tables

所调用到的clone()函数是为了复制进程的描述。而该函数的主要功能是:

The copy_process( ) function sets up

  • the process descriptor

  • any other kernel data structure required for a child’s execution.

  • Its parameters are the same as do_fork( ), plus the PID of the child.

static task_t *copy_process( )

{       :

p = dup_task_struct(current);

:

retval = copy_thread(0,clone_flags,…, regs);

:

sched_fork§;

:

}

==================================================================================================================

==================分割线==============================

好乱,我自己都看的好乱。。。

不管了,直接上实验截图了。一知半解的。

cd LinuxKernel

rm -rf menu

git clone https://github.com/mengning/menu.git

cd menu

mv test_fork.c test.c

make

结合之前查的资料,虽然实验有些失败,但是还是可以得出这样一个过程:

fork() -> sys_clone() -> do_fork() -> dup_task_struct() -> copy_process() -> copy_thread() -> ret_from_fork()

好吧不得不承认,这章我不懂。。。为了证书只能在这里瞎掰了。

sunfy + 原创作品转载请注明出处 + 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000

从system_call开始到iret

自己搭建了实验环境,逃离实验楼,实在是太卡了。自己的环境就是爽!

实验开始:

先加如getuid和getuidAsm代码:


运行系统:


实验下,添加的功能是否可以
效果没问题。

用GDB调试,设置断点

一步一步执行


实验目的达到了。

===========================================================================================================================这里是分割线========================================

从system_call开始到iret

网上有几张图很好的说明了这个过程。

能力不足,不足以详细的说明从system_call到iret的详细过程。在查阅了些资料后,发现有几张图还是解释的不错的,于是就把他们贴出来了。其实也是一种偷懒啦~

下图引用

《linux系统调用原理分析(下)》

下图引用

《system_call中断处理过程》

经过《扒开系统调用的三层皮》2周的学习,对系统调用有些感性的认识,但是没有书看啊,总感觉还是挺乱的。

sunfy + 原创作品转载请注明出处 + 《Linux内核分析》MOOC课程http://www.xuetangx.com/courses/course-v1:ustcX+USTC001+_/about ”

使用库函数API和C代码中嵌入汇编代码两种方式使用同一个系统调用

Linux内核中设置了一组用于实现各种系统功能的子程序,称为系统调用。用户可以通过系统调用命令在自己的应用程序中调用它们。从某种角度来看,系统调用和普通的函数调用非常相似。区别仅仅在于,系统调用由操作系统核心提供,运行于核心态;而普通的函数调用由函数库或用户自己提供,运行于用户态。


首先man getuid查看相关信息

编程


编译并运行:

嵌入式汇编:

系统调用是怎么工作的?

一般的,进程是不能访问内核的。它不能访问内核所占内存空间也不能调用内核函数。CPU硬件决定了这些(这就是为什么它被称作"保护模式")。系统调用是这些规则的一个例外。其原理是进程先用适当的值填充寄存器,然后调用一个特殊的指令,这个指令会跳到一个事先定义的内核中的一个位置(当然,这个位置是用户进程可读但是不可写的)。在Intel CPU中,这个由中断

0x80

实现。硬件知道一旦你跳到这个位置,你就不是在限制模式下运行的用户,而是作为操作系统的内核–所以你就可以为所欲为。

进程可以跳转到的内核位置叫做sysem_call。这个过程检查系统调用号,这个号码告诉内核进程请求哪种服务。然后,它查看系统调用表(sys_call_table)找到所调用的内核函数入口地址。接着,就调用函数,等返回后,做一些系统检查,最后返回到进程(或到其他进程,如果这个进程时间用尽)。如果你希望读这段代码,它在<内核源码目录>/kernel/entry.S,Entry(system_call)的下一行。

对比结果相同

================================================

Linux 中 x86 的内联汇编 系统调用跟我学(1)
Linux系统调用列表
【linux系统编程】 Linux系统调用概述

> sunfy(与最后申请证书的姓名务必一致) + 原创作品转载请注明出处 + 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000

实验:跟踪分析Linux内核的启动过程

——————————-实验开始gdb————————————————-

进入gdb进行一步一步调试:

break start_kernel:

start_kernel()中调用了一系列初始化函数,以完成kernel本身的设置。 这些动作有的是公共的,有的则是需要配置的才会执行的。

在start_kernel()函数中,

  • 输出Linux版本信息(printk(linux_banner))

  • 设置与体系结构相关的环境(setup_arch())

  • 页表结构初始化(paging_init())

  • 使用"arch/alpha/kernel/entry.S"中的入口点设置系统自陷入口(trap_init())

  • 使用alpha_mv结构和entry.S入口初始化系统IRQ(init_IRQ())

  • 核心进程调度器初始化(包括初始化几个缺省的Bottom-half,sched_init())

  • 时间、定时器初始化(包括读取CMOS时钟、估测主频、初始化定时器中断等,time_init())

  • 提取并分析核心启动参数(从环境变量中读取参数,设置相应标志位等待处理,(parse_options())

  • 控制台初始化(为输出信息而先于PCI初始化,console_init())

  • 剖析器数据结构初始化(prof_buffer和prof_len变量)

  • 核心Cache初始化(描述Cache信息的Cache,kmem_cache_init())

  • 延迟校准(获得时钟jiffies与CPU主频ticks的延迟,calibrate_delay())

  • 内存初始化(设置内存上下界和页表项初始值,mem_init())

  • 创建和设置内部及通用cache(“slab_cache”,kmem_cache_sizes_init())

  • 创建uid taskcount SLAB cache(“uid_cache”,uidcache_init())

  • 创建文件cache(“files_cache”,filescache_init())

  • 创建目录cache(“dentry_cache”,dcache_init())

  • 创建与虚存相关的cache(“vm_area_struct”,“mm_struct”,vma_init())

  • 块设备读写缓冲区初始化(同时创建"buffer_head"cache用户加速访问,buffer_init())

  • 创建页cache(内存页hash表初始化,page_cache_init())

  • 创建信号队列cache(“signal_queue”,signals_init())

  • 初始化内存inode表(inode_init())

  • 创建内存文件描述符表(“filp_cache”,file_table_init())

  • 检查体系结构漏洞(对于alpha,此函数为空,check_bugs())

  • SMP机器其余CPU(除当前引导CPU)初始化(对于没有配置SMP的内核,此函数为空,smp_init())

  • 启动init过程(创建第一个核心线程,调用init()函数,原执行序列调用cpu_idle() 等待调度,init())

至此start_kernel()结束,基本的核心环境已经建立起来了。

【转)kernel 启动过程之三, start_kernel()函数 概叙】

break rest_init:

break kernel_init:

break run_init_process

启动完成:

================================================

Linux系统启动过程

关于linux系统的启动流程我们可以按步进行划分为如下:

POST加电自检–>BIOS(Boot Sequence)–>加载对应引导上的MBR(bootloader)–>主引导设置加载其BootLoader–>Kernel初始化–>initrd—>/etc/init进程加载/etc/inittab



详解linux系统的启动过程及系统初始化



Linux启动过程详解-《别怕Linux编程》之八

===============================================

sunfy + 原创作品转载请注明出处 + 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000

实验:完成一个简单的时间片轮转多道程序内核代码

本次实现是实验模拟操作系统是如何工作的。

mykernel

上图作证:


实验使用linux-3.9.4进行模拟。模拟操作系统如何进行进程管理以及中断处理。

Process Control Block 即PCB(进程控制块)。也称之为 Task Controlling Block。

查阅

WIKI

The role of the PCBs is central in process management: they are accessed and/or modified by most OS utilities, including those involved with scheduling, memory and I/O resource access and performance monitoring. It can be said that the set of the PCBs define the current state of the operating system. Data structuring for processes is often done in terms of PCBs. For example, pointers to other PCBs inside a PCB allow the creation of those queues of processes in various scheduling states (“ready”, “blocked”, etc.) that we previously mentioned.

可见PCB由操作系统创建和管理。同时PCB包含了足够充分的信息,这样就可以中断一个进程,并且在恢复执行该进程时就好像未被中断过一样。(《Operating Systems Internals and Design Principles》)

在mykernel中mypcb.h既是声明PCB数据结构头的文件。


PCB中定义了pid,state,stack,thread,task_entry,*next结构成员。

在定义了PCB类型的数据结构后,定义了实例变量tPCB.

在声明了PCB数据结构类型之后,Linux内核开始运作。

相关代码在mymain.c中。


该段代码在创建和管理PCB,也就是为进程设置足够充分的信息并保留下来,以便操作系统进行进程控制管理。
这是创建的一个进程。该进程是每隔1000万个时间单位打印出特定格式的信息。

为了实现多进程时间片轮转,还需要一个中断进程,不停的发出中断信号。这就是myinterrupt.c代码所执行的内容。


这就是当满足调剂时执行的中断程序。

这就是本次实验的主干内容。

可以说进程是由程序代码和相关数据还有PCB组成的。对于一个但处理器计算机,在任何时候最多只有一个进程在执行。而在运行的这个进程状态为运行态。

  • sunfy + 原创作品转载请注明出处 + 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000
    

实验:通过反汇编一个简单的C程序,分析汇编代码理解计算机是如何工作的

我把它写成实验报告模式,而不像是一篇文章。目的很明确,我只想学会这门课并且获得证书。但是无耐必须用真名才能获得证书,可是我不想再往上暴露自己。所以到时候就以“Zhengda”的名义获得证书吧。

希望学有所成。

在实验楼的截图:



将Code文件夹下载到本机上。进行代码阅读。

C语言代码

将C用GCC编译成汇编:gcc –S –o main.s main.c -m32


汇编解释:

查阅

IBM社区的帖子《Linux 汇编语言开发指南》

程序开始:


(eip应为10) (eax应为8) (eax应为8) (eax应为8) (eax应为8) (eax应为8) (eax应为8)

程序结束。

终于画好了。画的好辛苦~~

我对计算机是如何工作的理解:

计算机只能购识别数字逻辑。汇编语言十分接近计算机最底层的硬件。通过这一实验,我对计算机的工作有更进一步的了解。比起C语言,汇编更加繁琐与复杂。但却充分显示出计算机硬件是一步步进行寄存器操作的。

程序无非就是硬件电路在寄存器之间不断的存取读写,再将数据送到ALU进行各种运算。这正是冯洛伊曼的思想。

sunfy + 原创作品转载请注明出处 + 《Linux操作系统分析》MOOC课程http://www.xuetangx.com/courses/course-v1:ustcX+USTC001+_/about