计算机科学与工程学院
课程设计报告
题目全称：Linux内核初起代码分析
学生学号：姓名：
指导老师：职称：
指导老师评语：
签字：课程设计成绩：
目录
摘要 (2)
第一章引言 (1)
1.1 问题的提出 (1)
1.2任务与分析 (1)
第二章代码分析 (2)
2.1系统初始化过程流程 (2)
2.2数据结构 (2)
2.3常量和出错信息的意义 (4)
2.4调用关系图 (4)
2.5各模块/函数的功能及详细框图 (5)
2.5.1 static void time_init(void)分析 (6)
2.5.2 void main(void)分析 (6)
2.5.3 pause()分析 (8)
2.5.4 static int printf(const char *fmt, ...)分析 (8)
2.5.5 void init(void)分析 (9)
第三章内核调试 (12)
3.1运行环境 (12)
3.2编译内核过程 (12)
第四章总结与体会 (15)
致谢 (16)
参考文献 (17)
摘要
随着计算机的普及,计算机发挥着越来越重要的作用，计算机的使用也越来越普遍，所以让更多的人能够更好的使用和掌握一些计算机方法显得十分重要。充分发挥计算机的作用也显得十分重要。操作系统应运而生。操作系统是一种软件,用来帮助其他的程序控制计算机并和用户进行交互。因而,对操作系统的研究是很有必要的。操作系统包含了多个部分或者组件,最核心的部分是内核。其他的部分用来帮助内核完成计算机资源的管理和应用程序的控制。Linux操作系统是使用很广泛的,高质量的一个操作系统。此次起始代码分析，我分析了init/main.c文件中的main()、init()以及编译内核代码。main()中主要是关于起始的调用和设备和系统信息初始化,以及创建进程。此时中断仍被禁止着，做完必要的设置后就将其开启init()是创建进程，并检测是否出错，出错则再次创建执行并打印出出错信息。init()函数运行在任务0 第1 次创建的子进程（任务1）中。它首先对第一个将要执行的程序（shell）的环境进行初始化，然后加载该程序并执行之。对Linux 初起代码的分析有助于了解操作系统的启动,可以更好地理解和认识操作系统是如何管理计算机资源的。
关键词：操作系统;Linux;初起代码
第一章引言
1.1 问题的提出
操作系统是一种软件，用来帮助其他的程序控制计算机并和用户进行交互。操作系统包含了众多程序用来控制计算机的核心功能，并且操作系统是链接用户和计算机硬件的桥梁，便于人们有效管理。尽管在过去操作系统取得了长足的进步，但是基本的目标并未改变：通过使用操作系统来处理公共任务，程序员便可以更容易地编写应用程序。
应用程序是一种软件，用来向计算机的用户提供某种服务，而不仅仅是控制计算机硬件。尽管在外观上和功能上有所不同，但是所有的操作系统都具有一些相同之处：初始化计算机硬件，以便操作系统和其他持续可以正常工作；为使用操作系统的程序分配系统资源，如内存和处理时间；跟踪调试运行的多个程序；为所有使用系统设备的程序提供规范的访问接口。
操作系统包含了多个部分或者组件，最核心的部分是内核。其他的部分用来帮助内核完成计算机资源的管理和应用程序的控制。操作系统控制了计算机上运行的各种应用程序。没有操作系统各类函数的调用，应用程序就无法执行。因而，对操作系统的研究是很有必要的。 Linux操作系统是使用很广泛的，高质量的一个操作系统，而且作为一个开源的系统，可以很方便的查看起代码并进行分析，有利于更好的认识和了解操作系统。此次对Linux 初起代码的分析有助于了解操作系统的启动，可以更好地理解和认识操作系统是如何管理计算机资源的。
1.2任务与分析
本课题主要的目的是了解一个操作系统的初起过程。根据操作系统的基础知识，分析init/main.c中关于系统初起的相关代码，了解一个操作系统的初起过程，得到相关的框图，写出设计说明书。
1)代码分析结果, 包括但不限于：
2)数据结构
3)常量和出错信息的意义
4)调用关系图
5)各模块/函数详细框图
分析思路：
1)了解基础知识，找到相关的源码；
2)对代码充分阅读，先得到单个函数的数据结构和框图；
3)将多个函数的框图汇总，绘出整体的框图；
使用的源代码是
Linux/init/main.c
(C) 1991 Linus Torvalds
第二章代码分析
2.1系统初始化过程流程
系统整个初始化过程见图2.1所示：
图2.1 内核初始化程序流程示意图
2.2 数据结构
1)时间结构：
#define CLOCKS_PER_SEC 100 /* 系统时钟滴答频率，100HZ */
typedef long clock_t; /* 从进程开始系统经过的时钟滴答数 */ struct tm
{
int tm_sec; /* 秒数 [0，59] */
int tm_min; /* 分钟数 [0，59] */
int tm_hour; /* 小时数 [0，59] */
int tm_mday; /* 1 个月的天数 [0，31] */
int tm_mon; /* 1 年中月份 [0，11] */
int tm_year; /* 从1900 年开始的年数 */
int tm_wday; /* 1 星期中的某天 [0，6]（星期天=0） */ int tm_yday; /* 1 年中的某天 [0，365] */
int tm_isdst; /* 夏令时标志 */
};
2)存放硬盘参数表信息：
struct drive_info
{
char dummy[32];
}drive_info; /* 用于存放硬盘参数表信息 */
3)tty 等待队列数据结构和tty 数据结构：
struct tty_queue
{
unsigned long data; /* 等待队列缓冲区中当前数据指针字符数 */ unsigned long head; /* 缓冲区中数据头指针 */
unsigned long tail; /* 缓冲区中数据尾指针 */
struct task_struct *proc_list; /* 等待进程列表 */
char buf[TTY_BUF_SIZE]; /* 队列的缓冲区 */
};
struct tty_struct /* tty 数据结构 */
{
struct termios termios; /* 终端io 属性和控制字符数据结构 */
int pgrp; /* 所属进程组 */
int stopped; /* 停止标志 */
void (*write) (struct tty_struct * tty); /* tty 写函数指针 */
struct tty_queue read_q; /* tty 读队列 */
struct tty_queue write_q; /* tty 写队列 */
struct tty_queue secondary; /* tty 辅助队列(存放规范模式字符序列) */ }; /* 可称为规范(熟)模式队列 */
4)请求队列中项的结构和块设备结构：
struct request
/* 请求队列中项的结构。其中如果dev=-1，则表示该项没有被使用 */
{
int dev; /* 使用的设备号 */
int cmd; /* 命令(READ或 WRITE) */
int errors; /* 操作时产生的错误次数 */
unsigned long sector; /* 起始扇区(1块=2扇区) */
unsigned long nr_sectors; /* 读/写扇区数 */
char *buffer; /* 数据缓冲区 */
struct task_struct *waiting; /* 任务等待操作执行完成的地方 */
struct buffer_head *bh; /* 缓冲区头指针(include/Linux/fs.h,68) */ struct request *next; /* 指向下一请求项 */
};
struct blk_dev_struct /* 块设备结构 */
{ void (*request_fn) (void); /* 请求操作的函数指针 */
struct request *current_request; /* 请求信息结构 */
};
2.3常量和出错信息的意义
定义系统调用嵌入式汇编宏函数。不带参数的系统调用宏函数。type name(void)。%0 - eax(__res)，%1 - eax(__NR_##name)。其中name 是系统调用的名称，与__NR_ 组合形成上面的系统调用符号常数，从而用来对系统调用表中函数指针寻址。返回：如果返回值大于等于0，则返回该值，否则置出错号errno，并返回-1。
#define _syscall0(type,name)
type name(void)
{
long __res;
__asm__ volatile ( "int $0x80" \/* 调用系统中断0x80 */
:"=a" (__res) \ /* 返回值eax(__res) */
:"" (__NR_
##name)); \ /* 输入为系统中断调用号__NR_name */ if (__res >= 0) \ /* 如果返回值>=0，则直接返回该值*/
return (type) __res; errno = -__res; \ /* 否则置出错号，并返回-1 */
return -1;}
/* 有1 个参数的系统调用宏函数。type name(atype a) */
/* %0 - eax(__res)，%1 - eax(__NR_name)，%2 - ebx(a) */
#define _syscall1(type,name,atype,a) \
type name(atype a)
{
long __res;
__asm__ volatile ( "int $0x80" : "=a" (__res) : "" (__NR_##name), "b" ((long)(a)));
if (__res >= 0)
return (type) __res;
errno = -__res;
return -1; }
extern int errno; /* 出错号，全局变量*/
static inline _syscall0(int,fork)
/*这是unistd.h 中的内嵌宏代码。以嵌入汇编的形式调用Linux 的系统调用中断0x80。该中断是所有系统调用的入口。该条语句实际上是int fork()创建进程系统调用。syscall0 名称中最后的0 表示无参数，1 表示1 个参数*/
static inline _syscall0(int,pause)
/* int pause()系统调用：暂停进程的执行，直到收到一个信号*/
static inline _syscall1(int,setup,void *,BIOS)
/* int setup(void * BIOS)系统调用，仅用于Linux 初始化（仅在这个程序中被调用）*/
static inline _syscall0(int,sync)
/* int sync()系统调用更新文件系统*/
2.4调用关系图
在内核源代码的init/目录中只有一个main.c 文件。系统在执行完boot/目录中的head.s 程序后就
会将执行权交给main.c。该程序虽然不长，但却包括了内核初始化的所有工作。
main.c 程序首先利用前面setup.s 程序取得的系统参数设置系统的根文件设备号以及一些内存全局变量。这些内存变量指明了主内存的开始地址、系统所拥有的内存容量和作为高速缓冲区内存的末端地址。如果还定义了虚拟盘（RAMDISK），则主内存将适当减少。整个内存的映像示意图见图3.1 所示。
图2.1 系统中内存功能划分示意图
图中，高速缓冲部分还要扣除被显存和ROM BIOS 占用的部分。高速缓冲区是用于磁盘等块设备临时存放数据的地方，以1K（1024）字节为一个数据块单位。主内存区域的内存是由内存管理模块mm通过分页机制进行管理分配，以4K 字节为一个内存页单位。内核程序可以自由访问高速缓冲中的数据，但需要通过mm 才能使用分配到的内存页面。
然后，内核进行所有方面的硬件初始化工作。包括陷阱门、块设备、字符设备和tty，包括人工设置第一个任务（task 0）。待所有初始化工作完成后就设置中断允许标志以开启中断，main()也切换到了任务0 中运行。
在整个内核完成初始化后，内核将执行权切换到了用户模式（任务0），也即CPU 从0 特权级切换到了第3 特权级。此时main.c 的主程序就工作在任务0 中。然后系统第一次调用进程创建函数fork()，创建出一个用于运行init()的子进程。
2.5各模块/函数的功能及详细框图
该程序首先确定如何分配使用系统物理内存，然后调用内核各部分的初始化函数分别对内存管理、中断处理、块设备和字符设备、进程管理以及硬盘和软盘硬件进行初始化处理。在完成了这些操作之后，系统各部分已处于可运行状态。此后程序把自己―手工‖移动到任务0（进程0）中运行，并使用fork()调用首次创建出进程1（init 进程）。在init进程中程序将继续进行应用环境的初始化并执行shell 登录程序。而原进程0则会在系统空闲时被调度执行，此时任务0仅执行pause()系统调用，并又会调用调度函数。
在init 进程中，如果终端环境建立成功，则会再生成一个子进程（进程2），用于运行shell 程序/bin/sh。若该子进程退出，则父进程进入一个死循环内，继续生成子进程，并在此子进程中再次执行shell 程序/bin/sh，而父进程则继续等待。
由于创建新进程的过程是通过完全复制父进程代码段和数据段的方式实现的，因此在首次使用fork()创建新进程init 时，为了确保新进程用户态堆栈没有进程0 的多余信息，要求进程0 在创建首个新进程之前不要使用用户态堆栈，也即要求任务0 不要调用函数。因此在main.c 主程序移动到任务0 执行后，任务0 中的代码fork()不能以函数形式进行调用。程序中实现的方法是采用gcc 函数内嵌的形式来执行这个系统调用。
通过申明一个内嵌（inline）函数，可以让gcc 把函数的代码集成到调用它的代码中。这会提高代码执行的速度，因为省去了函数调用的开销。另外，如果任何一个实际参数是一个常量，那么在编译时这些已知值就可能使得无需把内嵌函数的所有代码都包括进来而让代码也得到简化。
另外，任务0 中的pause()也需要使用函数内嵌形式来定义。如果调度程序首先执行新创建的子进程init，那么pause()采用函数调用形式不会有什么问题。但是内核调度程序执行父进程（进程0）和子进程init 的次序是随机的，在创建了init 后有可能首先会调度进程0 执行。因此pause()也必须采用宏定义来实现。
对于Linux 来说，所有任务都是在用户模式运行的，包括很多系统应用程序，如shell 程序、网络子系统程序等。内核源代码lib/目录下的库文件就是专门为这里新创建的进程提供支持函数的。
2.5.1 static void time_init(void)分析
该子程用于读取取CMOS 时钟，并设置开机时间startup_time(秒)。
struct tm time;
/* 时间结构tm 定义在include/time.h 中*/
do {
time.tm_sec = CMOS_READ(0); /* 当前时间秒值（均是BCD 码值）*/
time.tm_min = CMOS_READ(2); /* 当前分钟值*/
time.tm_hour = CMOS_READ(4); /* 当前小时值*/
time.tm_mday = CMOS_READ(7); /* 一月中的当天日期*/
time.tm_mon = CMOS_READ(8); /* 当前月份（1—12）*/
time.tm_year = CMOS_READ(9); /* 当前年份*/
} while (time.tm_sec != CMOS_READ(0));
CMOS 的访问速度很慢。为了减小时间误差，在读取了下面循环中所有数值后，若此时CMOS 中秒值发生了变化，那么就重新读取所有值。
BCD_TO_BIN(time.tm_sec); /* 转换成二进制数值*/
BCD_TO_BIN(time.tm_min);
BCD_TO_BIN(time.tm_hour);
BCD_TO_BIN(time.tm_mday);
BCD_TO_BIN(time.tm_mon);
BCD_TO_BIN(time.tm_year);
time.tm_mon--; /* tm_mon 中月份范围是0—11 */
startup_time = kernel_mktime(&time);
/* 调用kernel/mktime.c 中函数，计算从1970年1月1日0时起到开机当日经过的秒数，作为开机时间*/
2.5.2 void main(void)分析
main()函数中完成启动时对设备内核初始化,以及创建进程。此时中断仍被禁止着，做完必要的设置后就将其开启。下面这段代码用于保存:根设备号：ROOT_DEV；高速缓存末端地址：buffer_memory_end；机器内存：memory_end；主内存开始地址：main_memory_start；
ROOT_DEV = ORIG_ROOT_DEV; /* ROOT_DEV 定义在fs/super.c */
drive_info = DRIVE_INFO; /* 复制0x90080 处的硬盘参数表 */
memory_end = (1<<20) + (EXT_MEM_K<<10);
/* 内存大小=1Mb 字节+扩展内存(k)*1024 字节 */
memory_end &= 0xfffff000; /* 忽略不到4Kb（1 页）的内存数 */
if (memory_end > 16*1024*1024) /* 如果内存超过16Mb，则按16Mb 计 */
memory_end = 16*1024*1024;
if (memory_end > 12*1024*1024) /* 如果内存>12Mb，则设置缓冲区末端=4Mb */ buffer_memory_end = 4*1024*1024;
else if (memory_end > 6*1024*1024) /* 否则如果内存>6Mb，则设置缓冲区末端=2Mb */ buffer_memory_end = 2*1024*1024;
else
buffer_memory_end = 1*1024*1024; /* 否则则设置缓冲区末端=1Mb */
main_memory_start = buffer_memory_end; /* 主内存起始位置=缓冲区末端 */
/* 如果定义了内存虚拟盘，则初始化虚拟盘。此时主内存将减少。参见kernel/blk_drv/ramdisk.c。*/
#ifdef RAMDISK
main_memory_start += rd_init(main_memory_start, RAMDISK*1024);
#endif
mem_init(main_memory_start,memory_end); /* 内核进行所有方面的初始化工作 */
trap_init(); /* 陷阱门（硬件中断向量）初始化。（kernel/traps.c） */ blk_dev_init(); /* 块设备初始化。（kernel/blk_drv/ll_rw_blk.c）*/ chr_dev_init(); /* 字符设备初始化。（kernel/chr_drv/tty_io.c）*/ tty_init(); /* tty 初始化。（kernel/chr_drv/tty_io.c）*/
time_init(); /* 设置开机启动时间：startup_time */
sched_init(); /* 调度程序初始化(加载了任务0 的tr,ldtr)（kernel/sched.c）*/ buffer_init(buffer_memory_end); /* 缓冲管理初始化，建内存链表等。（fs/buffer.c）*/ hd_init(); /* 硬盘初始化。（kernel/blk_drv/hd.c）*/
floppy_init(); /* 软驱初始化。（kernel/blk_drv/floppy.c）*/
sti(); /* 所有初始化工作都做完了，开启中断 */
/* 下面过程通过在堆栈中设置的参数，利用中断返回指令启动任务0 执行 */
move_to_user_mode(); /* 移到用户模式下执行。（include/asm/system.h）*/
if (!fork()) {
init(); /* 在新建的子进程（任务1）中执行 */
}
main()流程图如图2.2:
图2.2 main()流程图
2.5.3 pause()分析
代码开始以任务0 的身份运行。对于任何其它的任务，pause()将意味着我们必须等待收到一个信号才会返回就绪运行态，但任务0（task0）是唯一的例外情况，因为任务0 在任何空闲时间里都会被激活（当没有其它任务在运行时），因此对于任务0 pause()仅意味着我们返回来查看是否有其它任务可以运行，如果没有的话我们就回到这里，一直循环执行pause()。
pause()系统调用（kernel/sched.c,144）会把任务0 转换成可中断等待状态，再执行调度函数。但是调度函数只要发现系统中没有其它任务可以运行时就会切换到任务0，而不依赖于任务0 的状态。
2.5.4 static int printf(const char *fmt, ...)分析
产生格式化信息并输出到标准输出设备stdout(1)，这里是指屏幕上显示。参数'*fmt'指定输出将采用的格式。该子程序正好是vsprintf 如何使用的一个例子。该程序使用vsprintf()将格式化的字符串放入printbuf 缓冲区，然后用write()将缓冲区的内容输出到标准设备（1--stdout）。
static int printf(const char *fmt, ...)
{
va_list args;
int i;
va_start(args, fmt);
write(1,printbuf,i=vsprintf(printbuf, fmt, args));
va_end(args);
return i;
}
2.5.5 void init(void)分析
argv[0]中的字符―-‖是传递给shell 程序sh 的一个标志。通过识别该标志，sh
程序会作为登录shell 执行。其执行过程与在shell 提示符下执行sh 不太一样。
static char * argv_rc[] = { "/bin/sh", NULL }; /* 调用执行程序时参数的字符串数组*/
static char * envp_rc[] = { "HOME=/", NULL }; /* 调用执行程序时的环境字符串数组*/
static char * argv[] = { "-/bin/sh",NULL }; /* 同上*/
static char * envp[] = { "HOME=/usr/root", NULL };
在main()中已经进行了系统初始化，包括内存管理、各种硬件设备和驱动程序。init()函数运行在任务0 第1 次创建的子进程（任务1）中。它首先对第一个将要执行的程序（shell）的环境进行初始化，然后加载该程序并执行之。
setup((void *) &drive_info);
/* 这是一个系统调用。用于读取硬盘参数包括分区表信息并加载虚拟盘（若存在的话）和安装根文件系统设备。该函数对应函数是sys_setup() */
然后以读写访问方式打开设备―/dev/tty0‖，它对应终端控制台。由于这是第一次打开文件操作，因此产生的文件句柄号（文件描述符）肯定是0。该句柄是UNIX 类操作系统默认的控制台标准输入句柄stdin。这里把它以读和写的方式打开是为了复制产生标准输出（写）句柄stdout 和标准出错输出句柄stderr。
(void) open("/dev/tty0",O_RDWR,0);
(void) dup(0); /* 复制句柄，产生句柄1 号-- stdout 标准输出设备*/
(void) dup(0); /* 复制句柄，产生句柄2 号-- stderr 标准出错输出设备*/
打印缓冲区块数和总字节数，每块1024 字节，以及主内存区空闲内存字节数。
printf("%d buffers = %d bytes buffer space\n\r",NR_BUFFERS,
NR_BUFFERS*BLOCK_SIZE);
printf("Free mem: %d bytes\n\r",memory_end-main_memory_start);
fork()用于创建一个子进程(任务2)。对于被创建的子进程，fork()将返回0 值，对于原进程(父进程)则返回子进程的进程号pid。该子进程关闭了句柄0(stdin) 、以只读方式打开/etc/rc 文件，并使用execve()函数将进程自身替换成/bin/sh 程序(即shell 程序)，然后执行/bin/sh 程序。所带参数和环境变量分别由argv_rc 和envp_rc 数组给出。函数_exit()退出时的出错码1 –操作未许可；2 -- 文件或目录不存在。
if (!(pid=fork())) {
close(0);
if (open("/etc/rc",O_RDONL Y,0))
_exit(1); /* 如果打开文件失败，则退出(lib/_exit.c,10) */
execve("/bin/sh",argv_rc,envp_rc); /* 替换成/bin/sh 程序并执行*/
_exit(2); /* 若execve()执行失败则退出*/
}
下面还是父进程（1）执行的语句。wait()等待子进程停止或终止，返回值应是子进程的进程号(pid)。这三句的作用是父进程等待子进程的结束。&i 是存放返回状态信息的位置。如果wait()返回值不等于子进程号，则继续等待。
if (pid>0)
while (pid != wait(&i))
/* 空循环*/
如果执行到这里，说明刚创建的子进程的执行已停止或终止了。下面循环中首先再创建一个子进程，如果出错，则显示―初始化程序创建子进程失败‖信息并继续执行。对于所创建的子进程将关闭所有以前还遗留的句柄(stdin, stdout, stderr)，新创建一个会话并设置进程组号，然后重新打开
/dev/tty0作为stdin，并复制成stdout 和stderr。再次执行系统解释程序/bin/sh。但这次执行所选用的参数和环境数组另选了一套。然后父进程再次运行wait()等待。如果子进程又停止了执行，则在标准输出上显示出错信息―子进程pid 停止了运行，返回码是i‖，然后继续重试下去，形成一个死循环。
while (1) {
if ((pid=fork())<0) {
printf("Fork failed in init\r\n");
continue;
}
if (!pid) { /* 新的子进程*/
close(0);close(1);close(2);
setsid(); /* 创建一新的会话*/
(void) open("/dev/tty0",O_RDWR,0);
(void) dup(0);
(void) dup(0);
_exit(execve("/bin/sh",argv,envp));
}
while (1)
if (pid == wait(&i))
break;
printf("\n\rchild %d died with code %04x\n\r",pid,i);
sync(); /* 同步操作，刷新缓冲区*/
}
_exit(0); /* 注意！是_exit()，不是exit() */
_exit()和exit()都用于正常终止一个函数。但_exit()直接是一个sys_exit 系统调用，而exit()则通常是普通函数库中的一个函数。它会先执行一些清除操作，例如调用执行各终止处理程序、关闭所有标准IO 等，然后调用sys_exit。
init（）流程图2.3:
第三章内核调试
3.1 运行环境
内核编译运行于模拟Linux环境的Bochs-2.1.1中。
3.2 编译内核过程
1)用Bochs运行Linux0.11,开始如图3.1：
图3.1Bochs运行Linux0.11
2)进入/usr/src/Linux/init, 使用ls命令显示当前目录文件,可以看到我们需要的main.c文件，如图
3.2：
图3.2 ls命令显示当前目录文件
3)vi main.c可以编译启动代码,insert插入,Esc+:wq保存并退出,如图3.3：
图3.3 vi编译启动代码
4)返回Linux目录,使用make clean清除源代码生成的执行文件和中间的目标文件,如图3.4：
图3.4 make clean
5)然后使用make命令编译生成新的内核,如图3.5：
图3.5 make命令编译生成新的内核
6)然后修复grub引导(这里不再赘述)，重启后可看到多选菜单，默认首选就是我修改main.c编译
的内核，如图3.6：
图3.6 新建grub引导
7)进入后启动显示信息。首先，显示的是硬盘信息以及执行起始程序（kernel（）），由此可见，启
动时先要对硬件初始化和起始程序位置。然后显示硬盘是否有错误信息以及磁盘使用情况。因为LINUX编程有严格的限制,我试着将printf()定义移到main()之前，修改main（）的内容并使之显示，没有成功，我就只修改了init()里的内容。可以看到显示打印出磁盘信息，然后用fork （）创建一个进程，然后打开/etc/rc/、执行bin/sh，由于没有出错，就没有跳转到出错的死循环中，没有错误信息显示，最后打印出创建进程成功。系统初始化完成，返回值OK。由此可以验证我们对初起代码main.c分析的正确性。如图3.7：
图3.7
第四章总结与体会
该程序首先确定如何分配使用系统物理内存，然后调用内核各部分的初始化函数分别对内存管理、中断处理、块设备和字符设备、进程管理以及硬盘和软盘硬件进行初始化处理。在内核源代码的init/目录中只有一个main.c 文件。系统在执行完boot/目录中的head.s 程序后就会将执行权交给main.c。该程序虽然不长，但却包括了内核初始化的所有工作。因此在阅读该程序的代码时需要参照很多其它程序中的初始化部分。而关于main.c，其中的头文件定义，需要引用到头文件等，因此要分析其数据结构，就需要查看Linux目录下的相关文件。main.c中最主要是分析main()函数调用关系，而面对大篇幅的代码，光看是很容易迷糊的，所以我选用了代码查看的软件SourceInsight。此次起始代码分析，分析了main()、time()、init()以及各个头文件定义等。通过申明一个内嵌（inline）函数，可以让gcc 把函数的代码集成到调用它的代码中。这会提高代码执行的速度，因为省去了函数调用的开销。另外，如果任何一个实际参数是一个常量，那么在编译时这些已知值就可能使得无需把内嵌函数的所有代码都包括进来而让代码也得到简化。
另外，任务0 中的pause()也需要使用函数内嵌形式来定义。如果调度程序首先执行新创建的子进程init，那么pause()采用函数调用形式不会有什么问题。但是内核调度程序执行父进程（进程0）和子进程init 的次序是随机的，在创建了init 后有可能首先会调度进程0 执行。因此pause()也必须采用宏定义来实现。
由于自己第一次接触内核代码，一时有些茫然，面对大量的代码无从下手。Linux是基于C语言编写的，所以自然需要C语言更为深层的知识，借助一些内核查看工具和相关书籍，可以方便的查看代码并且分析出各个模块的调用关系，编译出自己的Linux内核。出于对Linux的爱好以及平时对Linux的知识也比较丰富，所以我查找和获取Linux初起原代码也比较容易。大家通力合作，最终完成了对Linux初起代码的分析任务。过程是艰辛的，但收获也很大，让我认识到面对一个Linux 内核，不能恐惧，只要静下心来，一步一步分析，最终就能得出框架，并且加深了我对Linux相关知识的认识，开阔了眼界。
致谢
能够完成这次课程设计我要感谢老师对我的悉心指导，没有你们的工作，我不可能完成这次对于我来说算得上是陌生的任务，没有你们的帮助，我们会走更多的弯路；没有你平时的教育，我知识不会得到提高，不会有丰富的眼界。另外感谢同学们的帮助，在关键的时候，总是能够给我耐心的帮助，我由于对操作系统的知识不是很熟悉，在我遇到困难的时候你们总是能给我耐心的讲解，让我在完成任务的同时也能够掌握一些知识，我觉得这是我本次设计最大的收获。也让我感觉到了友谊的力量，再次谢谢你们。
参考文献
[1] 李善平. Linux内核2.4版源代码分析大全. 北京：机械工业出版社，2002，1.
[2] 陈莉君. 深入分析Linux内核源代码. 北京：人民邮电出版社，2002，8.
[3] 陈向群.操作系统教程.北京：北京大学出版社，2007，01.
[4] 罗宇.操作系统课程设计.北京：机械工业出版社，2005，9.
[5] Gary Nutt.Linux操作系统内核实习. 北京：机械工业出版社，2002，1.
中北大学 操作系统课程设计 说明书 学院、系：软件学院 专业：软件工程 学生姓名：徐春花学号： 设计题目：基于Linux的模拟文件系统的设计与实现 起迄日 期: 2014年6月14日- 2014年6月26日指导教薛海丽
师: 2014 年 6月 26 日 前言 简单地说，Linux是一套免费使用和自由传播的类Unix操作系统，它主要用于基于Intel x86系列CPU的计算机上。这个系统是由世界各地的成千上万的程序员设计和实现的。其目的是建立不受任何商品化软件的版权制约的、全世界都能自由使用的Unix兼容产品。 Linux不仅为用户提供了强大的操作系统功能，而且还提供了丰富的应用软件。用户不但可以从Internet上下载Linux及其源代码，而且还可以从Internet上下载许多Linux的应用程序。可以说，Linux本身包含的应用程序以及移植到Linux上的应用程序包罗万象，任何一位用户都能从有关Linux的网站上找到适合自己特殊需要的应用程序及其源代码，这样，用户就可以根据自己的需要下载源代码，以便修改和扩充操作系统或应用程序的功能。这对Windows NT、Windows98、MS-DOS或OS2
等商品化操作系统来说是无法做到的。 Linux具有：稳定、可靠、安全的优点，并且有强大的网络功能。其中有对读、 写进行权限控制、审计跟踪、核心授权等技术，这些都为安全提供了保障。在相关软 件的支持下，可实现WWW、FTP、DNS、DHCP、E-mail等服务，还可作为路由器 使用，利用IPCHAINSIPTABLE网络治理工具可构建NAT及功能全面的防火墙。 Linux是在GNU公共许可权限下免费获得的，是一个符合POSIX标准的操作系 统。Linux操作系统软件包不仅包括完整的Linux操作系统，而且还包括了文本编辑 器、高级语言编译器等应用软件。它还包括带有多个窗口管理器的X-Windows图形 用户界面，如同我们使用Windows NT一样，允许我们使用窗口、图标和菜单对系 统进行操作。 目录 1需求分析 (3) 1.1 功能介绍 (3) 1.2 目的及意义 (5) 1.2.1 目的 (5) 1.2.2 意义 (6) 1.3 设计成果 (7) 2总体设计 (8) 2.1功能介绍 (8) 2.2模块关联 (9) 3详细设计 (12)
Linux内核崩溃原因分析及错误跟踪技术 随着嵌入式Linux系统的广泛应用，对系统的可靠性提出了更高的要求，尤其是涉及到生命财产等重要领域，要求系统达到安全完整性等级3级以上[1]，故障率（每小时出现危险故障的可能性）为10-7以下，相当于系统的平均故障间隔时间（MTBF）至少要达到1141年以上，因此提高系统可靠性已成为一项艰巨的任务。对某公司在工业领域14 878个控制器系统的应用调查表明，从2004年初到2007年9月底，随着硬软件的不断改进，根据错误报告统计的故障率已降低到2004年的五分之一以下，但查找错误的时间却增加到原来的3倍以上。 这种解决问题所需时间呈上升的趋势固然有软件问题，但缺乏必要的手段以辅助解决问题才是主要的原因。通过对故障的统计跟踪发现，难以解决的软件错误和从发现到解决耗时较长的软件错误都集中在操作系统的核心部分，这其中又有很大比例集中在驱动程序部分[2]。因此，错误跟踪技术被看成是提高系统安全完整性等级的一个重要措施[1]，大多数现代操作系统均为发展提供了操作系统内核“崩溃转储”机制，即在软件系统宕机时，将内存内容保存到磁盘[3]，或者通过网络发送到故障服务器[3]，或者直接启动内核调试器[4]等，以供事后分析改进。 基于Linux操作系统内核的崩溃转储机制近年来有以下几种： (1) LKCD（Linux Kernel Crash Dump）机制[3]; (2) KDUMP（Linux Kernel Dump）机制[4]； (3) KDB机制[5]； (4) KGDB机制[6]。 综合上述几种机制可以发现,这四种机制之间有以下三个共同点： (1) 适用于为运算资源丰富、存储空间充足的应用场合； (2) 发生系统崩溃后恢复时间无严格要求； (3) 主要针对较通用的硬件平台，如X86平台。 在嵌入式应用场合想要直接使用上列机制中的某一种，却遇到以下三个难点无法解决： (1) 存储空间不足 嵌入式系统一般采用Flash作为存储器，而Flash容量有限，且可能远远小于嵌入式系统中的内存容量。因此将全部内存内容保存到Flash不可行。
Linux 系统课程设计报告 专业班级： 学号： 姓名： 同组成员： 2016年6月2日星期四
序论实验要求 实验目的 了解Linux内核源代码的目录结构及各目录的相关内容。 了解Linux内核各配置选项内容和作用。 掌握Linux内核配置文件的作用。 掌握Linux内核的编译过程。 掌握将新增内核代码加入到Linux内核结构中的方法。 实验指引 尽管目前Linux 2.6版本内核已经增加了很多对ARM体系甚至是S3C2440 CPU 的支持，但仍然需要对内核作一些小的修改来适应我们的开发板，并且需要重新配置、编译和重新生成新的内核映像。本实验从软硬件准备到下载到开发板等一系列连贯的操作来进行嵌入式Linux内核的移植。本实验的内核版本为2.6.29.1。 第一章Linux内核基础知识 1.1Linux版本 Linux主要的版本定义为“[主].[次].[发布].[修改]”的样式，次版本为奇数表示此版本为开发中版本，次版本为偶数表示此版本为稳定版本。 Linux内核的版本号可以从源代码的顶层目录下的Makefile中看到，比如2.6.29.1内核的Makefile中： VERSION = 2 PATCHLEVEL = 6 SUBLEVEL = 29 EXTRA VERSION = .1 其中的“VERSION”和“PATCHLEVEL”组成主版本号，比如 2.4、2.5、2.6等，稳定版本的德主版本号用偶数表示(比如2.6的内核)，开发中的版本号用奇数表示(比如2.5)，它是下一个稳定版本内核的前身。“SUBLEVEL”称为次版本号，它不分奇偶，顺序递增，每隔1~2个月发布一个稳定版本。“EXTRAVERSION”称为扩展版本号，它不分奇偶，顺序递增，每周发布几次扩展本版号。 1.2什么是标准内核 按照资料上的习惯说法，标准内核(或称基础内核)就是指主要在https://www.doczj.com/doc/c21903442.html,/维护和获取的内核，实际上它也有平台属性的。这些linux
目录 1.什么是Linux2 2.Linux系统的特性2 1.开放性2 2.多用户2 3.多任务2 4.良好的用户界面2 5.设备独立性2 6.提供了丰富的网络功能3 7.可靠的系统安全3 8.良好的可移植性3 3.常用操作命令3 1、ping命令3 2、ifconfig命令4 3．ftp命令4 4、netstat命令4 4.Samba配置5 5.ftp服务器配置6 6.shell编程6 总结9 参考文献 (9)
前言 今天，自由软件Linux正越来越显示出其咄咄逼人的气势。在传统由微软的windowsNT、Nowell 的Netware和UNIX占据的网络操作系统市场上，Linux正日益成为一个令人生畏的对手。 据估计现在全球已有800万Linux用户，有29%的互联网服务器采用了Linux系统，这一数字超过微软WindowsNT6个百分点。在1998年Linux将保持25%的年增长率，超过其他操作系统增长的总和。 随着IBM、Intel、Oracle、CA、网景为代表的众多IT巨头们纷纷宣布支持Linux、那些曾经对Linux 不屑一顾的著名软件公司的老板们不得不回过头来重新审视这个有Internet上的一群业余 1.什么是Linux Linux是一套免费使用和自由传播的UNIX操作系统，它主要用于基于Intel系列CPU的计算机上。这个系统是由世界各地的成千上万的程序员设计和实现的。其目的是建立不受任何商品化软件的制约的，全世界都能自由使用的UNIX兼容产品。Linux的出现，最早开始于一位名叫Linux Torvalds 的计算机爱好者，当时他是芬兰赫尔辛基大学的学生。他的目的是想要设计一个代替Minix(Minix 是由一位名叫Andrew Tannebaum的计算机教授编写的一个操作系统示教程序)的操作系统，这个操作系统可用于386、486或奔腾处理器的个人计算机上，并且具有UNIX操作系统的全部功能，因而开始了Linux出行的设计。 2.Linux系统的特性 1.开放性 开放性是指系统遵循世界标准规X，特别是遵循开放系统互连（OSI）国际标准。凡遵循国际标准所开发的软件的硬件，都能彼此兼容，可方便地实现互连。 2.多用户 多用户是指系统资源可以被不同用户各自拥有，即每个用户对自己的资源（例如：文件，设备）有特定的权限，互不影响，Linux和UNIX都具有多用户的特性。 3.多任务 多任务是现代计算机的最主要的一个特点。它是指计算机同时执行多个程序，而且各个程序的运行互相独立。Linux系统调度每一个进程平等地访问CPU。由于CPU的处理速度非常快，其结果是启动的应用程序看起来好像在并行运行。事实上，从CPU执行一个应用程序中的一组指令到Linux调度CPU,再次运行这个程序之间只有很短的时间延迟，用户是感觉不出来的。 4.良好的用户界面 Linux向用户提供了两种界面：用户界面和系统调用界面。Linux的传统用户界面基于文本的命令行界面，即shell。它既可以联机使用，又可存在文件上脱机使用。Linux还为用户图形用户界面。5.设备独立性
河南中医学院 《linux操作系统》课程设计报告 题目：基于Linux的进程调度模拟程序 所在院系：信息技术学院 专业年级：2011级计算机科学与技术完成学生：2011180021 郭姗 指导教师：阮晓龙 完成日期：201X 年06 月22 日 目录 1. 课程设计题目概述3 2. 研究内容与目的4 3. 研究方法5 4. 研究报告6 5. 测试报告/实验报告7 6. 课题研究结论8 7. 总结9
1、课程设计题目概述 随着Linux系统的逐渐推广，它被越来越多的计算机用户所了解和应用. Linux是一个多任务的操作系统，也就是说，在同一个时间内，可以有多个进程同时执行。如果读者对计算机硬件体系有一定了解的话，会知道我们大家常用的单CPU计算机实际上在一个时间片断内只能执行一条指令，那么Linux是如何实现多进程同时执行的呢？原来Linux使用了一种称为"进程调度（process scheduling）"的手段，首先，为每个进程指派一定的运行时间，这个时间通常很短，短到以毫秒为单位，然后依照某种规则，从众多进程中挑选一个投入运行，其他的进程暂时等待，当正在运行的那个进程时间耗尽，或执行完毕退出，或因某种原因暂停，Linux就会重新进行调度，挑选下一个进程投入运行。因为每个进程占用的时间片都很短，在我们使用者的角度来看，就好像多个进程同时运行一样了。本文就是对进程调度进行研究、实验的。 本文首先对Linux系统进行了简要的介绍, 然后介绍了进程管理的相关理论知识。其次，又介绍最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）、先来先服务算法的相关知识，并对进程调度进行最高优先数优先的调度算法和先来先服务算法模拟实验，并对比分析两种算法的优缺点，从而加深对进程概念和进程调度过程/算法的理解 设计目的：在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个。也就是说能运行的进程数大于处理机个数。为了使系统中的进程能有条不紊地工作，必须选用某种调度策略，选择某一进程占用处理机。使得系统中的进程能够有条不紊的运行，同时提高处理机的利用率以及系统的性能。所以设计模拟进程调度算法（最高优先数优先的调度算法、先来先服务算法），以巩固和加深处理进程的概念，并且分析这两种算法的优缺点。关键词：linux 进程调度调度算法
《Linux网络编程》 课程设计 班级： 姓名： 指导老师：
一、设计背景 Linux操作系统作为一个开源的操作系统被越来越多的人所应用，它的好处在于操作系统源代码的公开化！只要是基于GNU公约的软件你都可以任意使用并修改它的源代码。通过这次课程设计能更好的学习网络编程知识和掌握LINUX平台上应用程序设计开发的过程，将大学四年所学知识综合运用，为未来的工作学习打下基础。 二、设计目的 1、学习epoll 跟FTP被动模式 2、掌握linux基本命令，例如ls、cd、login； 3、学会如何编译、运行 三、环境要求 1、centos 64位操作系统 2、gcc编译器 四、设计原理 4．1客户端 客户端程序的主要任务有以下3个： （1）、分析用户输入的命令。 （2）、根据命令向服务器发出请求 （3）、接受服务器返回请求的结果 客户端为用户提供了3种命令：（1）、get:从服务器下载文件（2）、list:列出客户端当前目录的内容（3）、quit离开 4.2 服务器端 （1）、分析请求代码。 （2）、根据请求代码做相应的处理 （3）、等待返回结果或者应答信息
五、软件测试结果
六、部分主代码 #include "ftserve.h" int main(int argc, char *argv[]) { int sock_listen, sock_control, port, pid; if (argc != 2) { printf("usage: ./ftserve port\n"); exit(0); } port = atoi(argv[1]); // create socket if ((sock_listen = socket_create(port)) < 0 ) { perror("Error creating socket"); exit(1); } while(1) { // wait for client request
Linux 网络编程》课程设计 班级： 姓名： 指导老师：
、设计背景 Linux 操作系统作为一个开源的操作系统被越来越多的人所应用，它的好处在于操作系统源代码的公开化！只要是基于GNU公约的软件你都可以任意使用并修改它的源代码。通过这次课程设计能更好的学习网络编程知识和掌握LINUX平台上应用程序设计开发的过程，将大学四年所学知识综合运用，为未来的工作学习打下基础。 二、设计目的 1学习epoll跟FTP被动模式 2、掌握linux 基本命令，例如ls 、cd、login ； 3、学会如何编译、运行 三、环境要求 1、centos 64 位操作系统 2、gcc 编译器 四、设计原理 4．1 客户端 客户端程序的主要任务有以下 3 个： （1）、分析用户输入的命令。 （2）、根据命令向服务器发出请求 （3）、接受服务器返回请求的结果 客户端为用户提供了 3 种命令：（1）、get: 从服务器下载文件（2）、list: 列出客户端当前目录的内容（3）、quit 离开 服务器端 （1）、分析请求代码。 （2）、根据请求代码做相应的处理 （3）、等待返回结果或者应答信息 五、软件测试结果
六、部分主代码 #include "" int main(int argc, char *argv[]) { int sock_listen, sock_control, port, pid; if (argc != 2) { printf("usage: ./ftserve port\n"); exit(0); } port = atoi(argv[1]); uth", "r"); if (fd == NULL) { perror("file not found"); exit(1); } while ((num_read = getline(&line, &len, fd)) != -1) { memset(buf, 0, MAXSIZE); strcpy(buf, line); pch = strtok (buf," "); strcpy(username, pch); if (pch != NULL) { pch = strtok (NULL, " "); strcpy(password, pch); } // remove end of line and whitespace trimstr(password, (int)strlen(password)); if ((strcmp(user,username)==0) && (strcmp(pass,password)==0)) { auth = 1; break; } } free(line); fclose(fd); return auth; } * Log in connected client
探究linux内核,超详细解析子系统 Perface 前面已经写过一篇《嵌入式linux内核的五个子系统》，概括性比较强，也比较简略，现在对其进行补充说明。 仅留此笔记，待日后查看及补充！Linux内核的子系统 内核是操作系统的核心。Linux内核提供很多基本功能，如虚拟内存、多任务、共享库、需求加载、共享写时拷贝（Copy-On-Write）以及网络功能等。增加各种不同功能导致内核代码不断增加。 Linux内核把不同功能分成不同的子系统的方法，通过一种整体的结构把各种功能集合在一起，提高了工作效率。同时还提供动态加载模块的方式，为动态修改内核功能提供了灵活性。系统调用接口用户程序通过软件中断后，调用系统内核提供的功能，这个在用户空间和内核提供的服务之间的接口称为系统调用。系统调用是Linux内核提供的，用户空间无法直接使用系统调用。在用户进程使用系统调用必须跨越应用程序和内核的界限。Linux内核向用户提供了统一的系统调用接口，但是在不同处理器上系统调用的方法
各不相同。Linux内核提供了大量的系统调用，现在从系统 调用的基本原理出发探究Linux系统调用的方法。这是在一个用户进程中通过GNU C库进行的系统调用示意图，系 统调用通过同一个入口点传入内核。以i386体系结构为例，约定使用EAX寄存器标记系统调用。 当加载了系统C库调用的索引和参数时，就会调用0x80软件中断，它将执行system_call函数，这个函数按照EAX 寄存器内容的标示处理所有的系统调用。经过几个单元测试，会使用EAX寄存器的内容的索引查system_call_table表得到系统调用的入口，然后执行系统调用。从系统调用返回后，最终执行system_exit，并调用resume_userspace函数返回用户空间。 linux内核系统调用的核心是系统多路分解表。最终通过EAX寄存器的系统调用标识和索引值从对应的系统调用表 中查出对应系统调用的入口地址，然后执行系统调用。 linux系统调用并不单层的调用关系，有的系统调用会由
摘要 Linux是一款免费的操作系统，用户可以通过网络或其他途径免费获得，并可以任意修改其源代码。这是其他的操作系统所做不到的。正是由于这一点，来自全世界的无数程序员参与了Linux的修改、编写工作，程序员可以根据自己的兴趣和灵感对其进行改变，这让Linux 吸收了无数程序员的精华，不断壮大。 Linux的基本思想有两点：第一，一切都是文件；第二，每个软件都有确定的用途。其中第一条详细来讲就是系统中的所有都归结为一个文件，包括命令、硬件和软件设备、操作系统、进程等等对于操作系统内核而言，都被视为拥有各自特性或类型的文件。 这次的课程设计为了熟悉以下内容Linux 基本网络命令，配置网络文件，建立个人账户，配置samba服务器，配置vsFTp服务器，shell编程。 关键词：Linux 基本网络命令配置网络文件建立个人账户配置samba服务器配置vsFTp服务器 shell编程
Linux课程设计 目录 1. 绪论 (1) 1. 1引言 (1) 2. 操作系统特性 (1) 2.1 linux的主要特性 (1) 2.2 UNIX的主要特点 (2) 3.系统设计 (3) 3.1设计的目的与意义 (3) 3.2课程设计的目标 (3) 3.3课程设计的要求 (3) 4 .课程设计的具体内容 (4) 4.1 基本网络命令及使用方法 (4) 4.2 telnet建立多账户测试 (8) 4.3 配置samba服务器,实现不同系统之间的文件共享 (10) 4.4 配置vsFTP服务器 (11) 4.5 简单shell编程 (14) 总结 (17) 参考文献 (18)
1.绪论 1. 1引言 Linux是一种自由和开放源码的类Unix操作系统，存在着许多不同的Linux 版本，但它们都使用了Linux内核。Linux可安装在各种计算机硬件设备中，比如手机、平板电脑、路由器、视频游戏控制台、台式计算机、大型机和超级计算机。Linux是一个领先的操作系统，世界上运算最快的10台超级计算机运行的都是Linux操作系统。严格来讲，Linux这个词本身只表示Linux内核，但实际上人们已经习惯了用Linux来形容整个基于Linux内核，并且使用GNU 工程各种工具和数据库的操作系统。Linux得名于天才程序员林纳斯?托瓦兹。 Linux操作系统是UNIX操作系统的一种克隆系统，它诞生于1991 年的10 月5 日（这是第一次正式向外公布的时间）。以后借助于Internet网络，并通过全世界各地计算机爱好者的共同努力，已成为今天世界上使用最多的一种UNIX 类操作系统，并且使用人数还在迅猛增长。 Linux是一套免费使用和自由传播的类Unix操作系统，是一个基于POSIX 和UNIX的多用户、多任务、支持多线程和多CPU的操作系统。它能运行主要的UNIX工具软件、应用程序和网络协议。它支持32位和64位硬件。Linux继承了Unix以网络为核心的设计思想，是一个性能稳定的多用户网络操作系统。它主要用于基于Intel x86系列CPU的计算机上。这个系统是由全世界各地的成千上万的程序员设计和实现的。其目的是建立不受任何商品化软件的版权制约的、全世界都能自由使用的Unix兼容产品。 2. 操作系统特性 2.1 linux的主要特性 （1）基本思想 Linux的基本思想有两点：第一，一切都是文件；第二，每个软件都有确定的用途。其中第一条详细来讲就是系统中的所有都归结为一个文件，包括命令、硬件和软件设备、操作系统、进程等等对于操作系统内核而言，都被视为拥有各自特性或类型的文件。至于说Linux是基于Unix的，很大程度上也是因为这两者的基本思想十分相近。 （2）发展领域 职业领域：系统应用类（网管\系统管理和维护人员\安全管理人员中低端行业领域）待遇属于中下。 系统开发类行业（JAVA软件开发\C语言软件开发\WEB开发\嵌入式软件开发）其中嵌入式软件开发是linux应用最广的领域待遇属于中等发展方向：UNIX往高端领域和产业发展，例如：AIX、HP-UX、Solaris 等等。 （3）完全免费 Linux是一款免费的操作系统，用户可以通过网络或其他途径免费获得，并可以任意修改其源代码。这是其他的操作系统所做不到的。正是由于这一点，来自全世界的无数程序员参与了Linux的修改、编写工作，程序员可以根据自己的兴趣和灵感对其进行改变，这让Linux吸收了无数程序员的精华，不断壮大。
《Linux课程设计》 设计题目：shell 编程实现用户信息管理专业：软件工程 指导教师：蔡照鹏王斌斌 班级： 学号： 姓名： 同组人： 计算机科学与工程学院
Linux是一种自由和开放源码的类Unix操作系统，存在着许多不同的Linux版本，但它们都使用了Linux内核。Linux可安装在各种计算机硬件设备中。Linux是一个领先的操作系统，世界上运算最快的10台超级计算机运行的都是Linux操作系统。严格来讲，Linux这个词本身只表示Linux 内核，但实际上人们已经习惯了用Linux来形容整个基于Linux内核，并且使用GNU 工程各种工具和数据库的操作系统。Linux得名于天才程序员林纳斯·托瓦兹。 Linux操作系统是UNIX操作系统的一种克隆系统，它诞生于1991 年的10 月5 日（这是第一次正式向外公布的时间）。以后借助于Internet网络，并通过全世界各地计算机爱好者的共同努力，已成为今天世界上使用最多的一种UNIX 类操作系统，并且使用人数还在迅猛增长。Linux是一套免费使用和自由传播的类Unix操作系统，是一个基于POSIX 和UNIX的多用户、多任务、支持多线程和多CPU的操作系统。它能运行主要的UNIX工具软件、应用程序和网络协议。它支持32位和64位硬件。Linux 继承了Unix以网络为核心的设计思想，是一个性能稳定的多用户网络操作系统。它主要用于基于Intel x86系列CPU的计算机上。这个系统是由全世界各地的成千上万的程序员设计和实现的。其目的是建立不受任何商品化软件的版权制约的、全世界都能自由使用的Unix兼容产品。
目录 前言 (2) 正文 (3) 1 课程设计的目的和意义 (3) 2 目标与总体方案 (4) 2.1课程设计的目标 (4) 2.2课程设计的总体方案 (4) 3 课程设计方法和内容 (4) 3.1软硬件环境说明 (4) 3.2常用网络操作命令 (5) 3.3网络配置文件与配置方法 (8) 3.4 TELNET 建立多帐户测试 (9) 3.5配置NFS服务器，实现文件系统的远程挂载 (10) 3.6配置SAMBA服务器 (13) 4 SELL编程 (17) 5 GCC简单使用 (21) 6 FTP服务器配置 (24) 致谢 (26) 参考文献 (27)
前言 Linux是一套免费使用和自由传播的类 Unix操作系统，它主要用于基于 Intel x86系列 CPU的计算机上。这个系统是由世界各地的成千上万的程序员设计和实现的。其目的是建立不受任何商品化软件的版权制约的、全世界都能自由使用的 Unix兼容产品。 Linux 的出现，最早开始于一位名叫 Linus Torvalds的计算机业余爱好者，当时他是芬兰赫尔辛基大学的学生。他的目的是想设计一个代替 Minix（是由一位名叫 Andrew Tannebaum的计算机教授编写的一个操作系统示教程序）的操作系统， UNIX特点： （1）模块化程度高 Linux的内核设计非常精巧，分成进程调度、内存管理、进程间通信、虚拟文件系统和网络接口五大部分;其独特的模块机制可根据用户的需要，实时地将某些模块插入或从内核中移走，使得Linux系统内核可以裁剪得非常小巧，很适合于嵌入式系统的需要. （2）源码公开 由于Linux系统的开发从一开始就与GNU项目紧密地结合起来，所以它的大多数组成部分都直接来自GNU项目。任何人、任何组织只要遵守GPL条款，就可以自由使用Linux 源代码。 （3）广泛的硬件支持 Linux能支持x86、ARM、MIPS、ALPHA和PowerPC等多种体系结构的微处理器。 （4）安全性及可靠性好内核高效稳定 Linux内核的高效和稳定已在各个领域内得到了大量事实的验证。Linux中大量网络管理、网络服务等方面的功能，可使用户很方便地建立高效稳定的防火墙、路由器、工作站、服务器等。为提高安全性，它还提供了大量的网络管理软件、网络分析软件和网络安全软件等。 (5)具有优秀的开发工具 开发嵌入式系统的关键是需要有一套完善的开发和调试工具。传统的嵌入式开发调试工具是在线仿真器(In Circuit Emulator，ICE)，它通过取代目标板的微处理器，给目标程序提供一个完整的仿真环境，从而使开发者能非常清楚地了解到程序在目标板上的工作状态，便于监视和调试程序。在线仿真器的价格非常高，而且只适合做非常底层的调试。如果使用的是嵌人式Linux，一旦软硬件能支持正常的串口功能，即使不用在线仿真器，也可以很好地进行开发和调试工作，从而节省了一笔不小的开发费用。嵌入式Linux为开发者提供了一套完整的工具链(Tool Chain)，能够很方便地实现从操作系统到应用软件各个级别的调试。 由于UNIX系统对各种数据库，特别是关系型数据库管理系统提供了强大的支持能力，因此主要的数据库厂家，包括Oracle,Informix,Sybase,Progress等都将UNIX作为优选的运行平台，而且创造出极高的性能价格比。
本文档的Copyleft归wwwlkk所有，使用GPL发布，可以自由拷贝、转载，转载时请保持文档的完整性，严禁用于任何商业用途。 E-mail: wwwlkk@https://www.doczj.com/doc/c21903442.html, 来源: https://www.doczj.com/doc/c21903442.html,/?business&aid=6&un=wwwlkk#7 linux2.6.35内核IMQ源码实现分析 （1）数据包截留并重新注入协议栈技术 (1) （2）及时处理数据包技术 (2) （3）IMQ设备数据包重新注入协议栈流程 (4) （4）IMQ截留数据包流程 (4) （5）IMQ在软中断中及时将数据包重新注入协议栈 (7) （6）结束语 (9) 前言：IMQ用于入口流量整形和全局的流量控制，IMQ的配置是很简单的，但很少人分析过IMQ的内核实现，网络上也没有IMQ的源码分析文档，为了搞清楚IMQ的性能，稳定性，以及借鉴IMQ的技术，本文分析了IMQ的内核实现机制。 首先揭示IMQ的核心技术： 1.如何从协议栈中截留数据包，并能把数据包重新注入协议栈。 2.如何做到及时的将数据包重新注入协议栈。 实际上linux的标准内核已经解决了以上2个技术难点，第1个技术可以在NF_QUEUE机制中看到，第二个技术可以在发包软中断中看到。下面先介绍这2个技术。 （1）数据包截留并重新注入协议栈技术
（2）及时处理数据包技术 QoS有个技术难点：将数据包入队，然后发送队列中合适的数据包，那么如何做到队列中的数
激活状态的队列是否能保证队列中的数据包被及时的发送吗？接下来看一下，激活状态的队列的 证了数据包会被及时的发送。 这是linux内核发送软中断的机制，IMQ就是利用了这个机制，不同点在于：正常的发送队列是将数据包发送给网卡驱动，而IMQ队列是将数据包发送给okfn函数。
辽宁工业大学linux 课程设计（论文） 题目：REDHAT LINUX 系统下搭建FTP 服务器 学院：软件学院 专业班级：软件工程125班 学号： 121301143 学生姓名：张白冰 指导教师：陈浩 教师职称：讲师 起止时间： 2012.12.1—2012.12.5
课程设计（论文）任务及评语
目录 第一章安装VSFTP套件 (1) 1.1首先查看我的Redhat5上是否已经安装 (1) 1.2 如果没有安装话，就要选择一种方式安装 (1) 1.3 VsFtp的配置文件 (3) 第二章配置FTP服务器 (4) 2.1最简单的vsfrpd.conf设定 (4) 2.2 配置好FTP服务器后，使用匿名用户及实体用户上传下载文件进行测试。 (5) 第三章总结 (9) 参考文献 (10)
第一章安装VSFTP套件 1.1首先查看我的Redhat5上是否已经安装 rpm -qa| grep vsftpd 如果已经安装就会出现vstfp的版本号相关的信息，如果没有出现就是没有安装1.2 如果没有安装话，就要选择一种方式安装 可以到官方网站去下载 https://www.doczj.com/doc/c21903442.html, 也可以用光盘安装，RedHat 5的安盘里自带的，所以我选择光盘安装 (1)先把光盘挂载到系统上： mount /dev/cdrom /mnt 这样光盘的内容就被挂载到/mnt的设备上，现在可以通过/mnt访问光盘上的内容了 (2)在光盘上安装vsftp,并且启动vsftp rpm -ivh vsftpd* (3)修改启动方式，改为系统启动时，自动启动 chkconfig vsftpd on 也可以查看启动方式 chkconfig --list |grep vsftpd 只要在第2--5为on就能随机启动 (4)启动ftp service vsftpd start (5)连接测试 vsftp默认安装目录是:/etc/vsftpd 默认有一个ftp目录:var/ftp vsftp默认是用允许匿名用户【anonymous】登陆，允许下载，但是不允许上传 如果连不上，可能是linux 防火墙的原因 停止防火墙：service iptables stop 开启防火墙：service iptables start （1）从光盘中找到从光盘中找到从光盘中找到从光盘中找到 vsftp的的的的rpm 安装包安装包安装包安装包
Linux课程设计---编写proc文件系统相关的内核模块 学号：20085229 姓名：杜森 班级：08级网络一班 指导教师：于群 日期：2011年6月29号
一、背景知识： 1、内核模块。 操作系统采用两种体系结构：微内核（Micro kernel），最常用的功能模块被设计成内核模式运行的一个或一组进程，而其它大部分不十分重要的功能模块都作为单独的进程在用户模式下运行！单内核（Monolithic kernel，有时也叫宏内核Macro kernel）！内核一般作为一个大进程的方式存在。该进程内部又可以被分为若干模块，在运行的时候，它是一个独立的二进制映象为了弥补单一体系结构的这一缺陷，Linux操作系统使用了模块机制。用户可以根据需要，在不需要对内核重新编译的情况下，模块可以动态地载入内核或从内核中移出！如图所示，模块可通过 insmod命令插入内核，也可以通过rmmod命令从内核中删除。 2、进程管理 Linux的每一个进程都有自己的属性，用一个task struct数据结构表示，即进程控制块Ⅲ(Process Concrol Block，PCB)。它对进程在其生命周期内涉及的所有事件进行全面的描述，主要有进程标识符(PID)、进程状态信息、进程调度信息、进程所占的内存区域、相关文件的文件描述符、处理器环境信息、信号处理、Linux操作系统内核分析与研究资源安排、同步处理等几个方面。在一个系统中，通常可拥有数百个甚至数千个进程，相应地就有很多进程控 制块。为了有效地对它们加以管理，应该用适当地方式将这些进程控制块组织起来。 进程控制块数据结构主要域定义如下： task_struct结构：在linux/sched.h中 struct task_struct{ volatile long state; //系统进程状态，一共有五种状态： //0 可运行态 //1 可中断的等待态 //2 不可中断的等待态 //3 僵死态
学号 课程论文 题目：Linux嵌入式应用 作者班级 院部计算机学院专业计算机科学与技术指导教师职称 完成时间2018年1月2日
摘要 进几年来，随着物联网的迅猛发展，嵌入式系统的应用在国内也发展得如火如荼，尤其是Linux嵌入式系统。Linux作为一套免费使用并自由传播的性能稳定的多用户的类Unix操作系统，正在向各个方面广泛扩展及改进应用，在目前嵌入式开发系统中，大约有一半以上使用的是Linux系统。本文主要介绍嵌入式系统的应用现状，以及Linux系统在嵌入式开发中的优势、应用和前景。 关键词: 嵌入式；Linux
ABSTRACT In the past few years, with the rapid development of the Internet of things, the application of embedded system has also been developing at home, especially the Linux embedded system. The spread of Linux as a free of charge and free of stable performance of multi-user unix-like operating system, is widely extended in all directions and improve application, in the embedded development system, there are about more than half are using the Linux system. This paper mainly introduces the application status of embedded system and the advantages, application and prospect of Linux system in embedded development. Key words: Embedded; Linux
目录 前言 (1) 正文 (2) 1设计背景 (2) 1.1设计的目的与意义 (2) 1.2课程设计的目标 (2) 1.3课程设计的要求 (2) 1.4课程设计的方案 (2) 2 网络命令 (3) 2.1 常用的网络命令 (3) 2.2 telnet建立多账户测试 (7) 2.3 smba服务器的配置 (9) 2.4 ftp服务器配置 (12) 2.5 shell编程 (15) 总结 (16) 参考文献 (17)
Linux是一种自由和开放源码的类Unix操作系统，存在着许多不同的Linux 版本，但它们都使用了Linux内核。Linux可安装在各种计算机硬件设备中。Linux 是一个领先的操作系统，世界上运算最快的10台超级计算机运行的都是Linux 操作系统。严格来讲，Linux这个词本身只表示Linux内核，但实际上人们已经习惯了用Linux来形容整个基于Linux内核，并且使用GNU 工程各种工具和数据库的操作系统。Linux得名于天才程序员林纳斯·托瓦兹。 Linux操作系统是UNIX操作系统的一种克隆系统，它诞生于1991 年的10 月5 日（这是第一次正式向外公布的时间）。以后借助于Internet网络，并通过全世界各地计算机爱好者的共同努力，已成为今天世界上使用最多的一种UNIX 类操作系统，并且使用人数还在迅猛增长。 Linux是一套免费使用和自由传播的类Unix操作系统，是一个基于POSIX 和UNIX的多用户、多任务、支持多线程和多CPU的操作系统。它能运行主要的UNIX工具软件、应用程序和网络协议。它支持32位和64位硬件。Linux继承了Unix以网络为核心的设计思想，是一个性能稳定的多用户网络操作系统。它主要用于基于Intel x86系列CPU的计算机上。这个系统是由全世界各地的成千上万的程序员设计和实现的。其目的是建立不受任何商品化软件的版权制约的、全世界都能自由使用的Unix兼容产品。 UNIX特点： （1）模块化程度高 （2）源码公开 （3）广泛的硬件支持 （4）安全性及可靠性好内核高效稳定 (5)具有优秀的开发工具
武汉理工大学华夏学院 课程设计报告书 课程名称：《Linux操作系统》课程论文 题目：比较Linux系统与Windows系统 系名：信息工程系 专业班级：软件1121 姓名：钟伟 学号： 指导教师:杨铭熙 2015 年5 月13 日 软件1121班《Linux操作系统》课程论文题 题目： 比较Linux系统与Windows系统的在以下各方面异同 1.硬盘配额管理 2.内存配额 3.批处理系统 4.用户管理 5.服务器安装与配置（至少讨论两种） 6.源码共享机制 7.安全机制 8.针对我国网络安全机制之利弊
要求: 1.第11周三下午5点以前交（电子版发到指定邮箱，纸版交老师） 2.论述不得与人雷同。 关于Linux和windows的比较我们可以从以下几个方面来进行比较 1硬盘配额管理 我认为Linux磁盘配额的作用和windows磁盘配额的作用基本上是相同的,在我们的电脑磁盘出厂经过初始化后，要想使用，就要对其进行分区，由于受MBR分区表的限制，最多分成4个主分区，如果想要更多的分区，那么可以分成3个主分区和1个扩展分区，其中的扩展分区进而分成多个逻辑分区。接下来，如果Windows系统和Linux系统将要对磁盘的分区进行访问，那么就需要进行下面的工作： 1.Windows想要访问 （1）为分区分配文件系统类型，例如设置为FAT16、或FAT32又或者NTFS。 （2）为该分区分配盘符，例如D盘，也可以想象成把其中的一个分区挂载到我的电脑/D盘目录下面。接下来，对D盘进行操作，如写文件，其实就是在相应的磁盘分区里面操作了。 2.Linux想要访问 （1）为分区分配文件系统类型，例如设置为ext2、ext3等。 （2）由于我们无法直接访问磁盘分区，因此我们需要把相应的分区挂载到一个目录下面。在Windows下面可以在图形化的界面（磁盘管理器）里面看到各个分区，进而能够分配盘符，但是在Linux下面无法看到分区，而是给每个分区起了个名字，以文件形式存在，例如（sda1，其中sd表示sata接口的磁盘，hd表示IDE接口的磁盘；a表示第一块磁盘，如果还有一块磁盘，那么就b；1表示磁盘的第一个主分区，相应的2、3,4表示第2、3、4个分区，5表示第一个逻辑分区。）接下来可以将磁盘的某一个分区挂载到特定目录，例如把sda2 挂载到/home 目录。接下来，对/home进行操作，如写文件，其实就是在相应的磁盘分区里面操作了。（1）Windows可以通过给其分配盘符来访问它，而它具体的设备可以在设备管理器里面看；（2）Linux可以将其挂载到/media目录下面进而对其进行访问，而它具体的设备可以在/dev 目录下面找到。 2内存配额 通过学习，我了解到在虚拟内存的使用上，Linux内核为用户管理了非常多的细节问题，用户可以认为自己真正拥有4GB地址空间，而不用关心虚拟内存是否提交物理存储等问题。Windows NT则为程序员提供了多种虚拟内存使用方案，虽然这些方案的使用有些复杂，但却提供了一定程度上的灵活性。它也支持DOS和Win16程序的执行，但为了提供这种兼容性，它的内存管理付出了极高的性能代价。在内存管理上，Linux 和Windows NT在面对相同的进程地址空间大小时，对内存布局的使用方式不同。Windows NT实际只为进程准备了2GB弱的可用虚拟地址空间，而Linux中的进程地址空间使用更灵活些。 Linux 和Windows NT虽然均提供了内存共享技术，但它们的实现有些细微的差别。Linux提供给用户的接口非常简单，只需将自己的虚拟内存空间区域附加到共享内存对象之上。Windows NT则是通过内存映射文件提供共享内存机制，从使用上讲，略显复杂。 Linux 和Windows NT在高速缓存的使用上有一些共同之处，均尽量采用系统的全部空闲RAM作为高速缓存区域，但Linux在高速缓存管理上有一些独到之处，这是它性能之所以高的根本原因并且Linux的内存交换管理灵活性很强，用户可以在普通的文件系统上建立“无洞”的文件作为交换空间，还可以使用多个交换文件，从而可以动态增加交换文件。它也提供了利用交换分区作为交换空间的方法，此方法是优选的交换空间方案。Windows NT的页面文件很难摆脱碎片化的危险，为了保证它采用无碎片的页面文件，必须采取一定的措施。 3批处理系统