MIT教学操作系统xv6详解与源码分析

需积分: 17 140 浏览量更新于2024-07-18 1 收藏 174KB PDF 举报

“mit教学用的操作系统最新版源代码”是一个基于Unix V6版本的简化实现，名为xv6。这个操作系统源代码适用于现代x86架构的多处理器系统，使用ANSI C语言编写，旨在教育目的，让学生了解操作系统的基本原理和实现。在深入探讨xv6之前，我们先理解一下Unix V6。Unix V6是Dennis Ritchie和Ken Thompson合作开发的早期Unix版本之一，对后来的操作系统设计产生了深远影响。xv6则是为了复现Unix V6的核心概念，但它并非直接移植，而是根据现代硬件和编程标准进行了调整。 xv6的设计思路紧密遵循Unix V6，但包含了一些现代操作系统的特点，如多处理器支持（MP）。它借鉴了多个开源项目，包括来自JOS（用于底层硬件交互的代码）、Plan 9（多处理器相关的代码，如entryother.S, mp.h, mp.c, lapic.c）、FreeBSD（ioapic.c）以及NetBSD（console.c）的部分组件。此外，还有多位贡献者，如Russ Cox、Cliff Frey、Xiao Yu等，为xv6的实现提供了代码或技术支持。学习xv6的源代码，学生可以了解到操作系统的基本组成部分，例如： 1. **内存管理**：xv6如何分配和回收内存，以及如何使用页表进行地址转换。 2. **进程管理**：包括进程创建、上下文切换、同步原语和锁的实现。 3. **文件系统**：理解如何实现简单的文件系统结构，包括文件的读写、目录操作等。 4. **设备驱动**：如何与硬件设备交互，例如IDE硬盘驱动和键盘鼠标等输入设备的处理。 5. **中断处理**：理解中断服务例程和中断向量的概念，以及如何处理中断请求。 6. **多处理器支持**：如何在多核CPU环境下协调进程执行，以及中断处理的MP兼容性。 xv6的简洁性和教育性质使得它成为教授操作系统原理的理想教材。通过阅读和分析xv6的源代码，学生不仅可以了解操作系统的核心机制，还能实际动手修改和调试，从而获得更深入的理解。由于xv6的代码量较小（不到10000行），这对于初学者来说是可管理的，能够帮助他们在相对较短的时间内掌握操作系统设计的基础。此外，mit的教学网站提供了更多的在线资源和支持，包括文档、讨论和问题解答，进一步增强了学习体验。对于想要进入操作系统领域的开发者，研究xv6是一个非常有价值的起点。

Aug 29 15:52 2017 xv6/mmu.h Page 5

0900 // Gate descriptors for interrupts and traps

0901 struct gatedesc {

0902 uint off_15_0 : 16; // low 16 bits of offset in segment

0903 uint cs : 16; // code segment selector

0904 uint args : 5; // # args, 0 for interrupt/trap gates

0905 uint rsv1 : 3; // reserved(should be zero I guess)

0906 uint type : 4; // type(STS_{TG,IG32,TG32})

0907 uint s : 1; // must be 0 (system)

0908 uint dpl : 2; // descriptor(meaning new) privilege level

0909 uint p : 1; // Present

0910 uint off_31_16 : 16; // high bits of offset in segment

0911 };

0912

0913 // Set up a normal interrupt/trap gate descriptor.

0914 // − istrap: 1 for a trap (= exception) gate, 0 for an interrupt gate.

0915 // interrupt gate clears FL_IF, trap gate leaves FL_IF alone

0916 // − sel: Code segment selector for interrupt/trap handler

0917 // − off: Offset in code segment for interrupt/trap handler

0918 // − dpl: Descriptor Privilege Level −

0919 // the privilege level required for software to invoke

0920 // this interrupt/trap gate explicitly using an int instruction.

0921 #define SETGATE(gate, istrap, sel, off, d) \

0922 { \

0923 (gate).off_15_0 = (uint)(off) & 0xffff; \

0924 (gate).cs = (sel); \

0925 (gate).args = 0; \

0926 (gate).rsv1 = 0; \

0927 (gate).type = (istrap) ? STS_TG32 : STS_IG32; \

0928 (gate).s = 0; \

0929 (gate).dpl = (d); \

0930 (gate).p = 1; \

0931 (gate).off_31_16 = (uint)(off) >> 16; \

0932 }

0933

0934 #endif

0935

0936

0937

0938

0939

0940

0941

0942

0943

0944

0945

0946

0947

0948

0949

Sheet 09

Aug 29 15:52 2017 xv6/elf.h Page 1

0950 // Format of an ELF executable file

0951

0952 #define ELF_MAGIC 0x464C457FU // "\x7FELF" in little endian

0953

0954 // File header

0955 struct elfhdr {

0956 uint magic; // must equal ELF_MAGIC

0957 uchar elf[12];

0958 ushort type;

0959 ushort machine;

0960 uint version;

0961 uint entry;

0962 uint phoff;

0963 uint shoff;

0964 uint flags;

0965 ushort ehsize;

0966 ushort phentsize;

0967 ushort phnum;

0968 ushort shentsize;

0969 ushort shnum;

0970 ushort shstrndx;

0971 };

0972

0973 // Program section header

0974 struct proghdr {

0975 uint type;

0976 uint off;

0977 uint vaddr;

0978 uint paddr;

0979 uint filesz;

0980 uint memsz;

0981 uint flags;

0982 uint align;

0983 };

0984

0985 // Values for Proghdr type

0986 #define ELF_PROG_LOAD 1

0987

0988 // Flag bits for Proghdr flags

0989 #define ELF_PROG_FLAG_EXEC 1

0990 #define ELF_PROG_FLAG_WRITE 2

0991 #define ELF_PROG_FLAG_READ 4

0992

0993

0994

0995

0996

0997

0998

0999

Sheet 09

Aug 29 15:52 2017 xv6/entry.S Page 1

1000 # The xv6 kernel starts executing in this file. This file is linked with

1001 # the kernel C code, so it can refer to kernel symbols such as main().

1002 # The boot block (bootasm.S and bootmain.c) jumps to entry below.

1003

1004 # Multiboot header, for multiboot boot loaders like GNU Grub.

1005 # http://www.gnu.org/software/grub/manual/multiboot/multiboot.html

1006 #

1007 # Using GRUB 2, you can boot xv6 from a file stored in a

1008 # Linux file system by copying kernel or kernelmemfs to /boot

1009 # and then adding this menu entry:

1010 #

1011 # menuentry "xv6" {

1012 # insmod ext2

1013 # set root=’(hd0,msdos1)’

1014 # set kernel=’/boot/kernel’

1015 # echo "Loading ${kernel}..."

1016 # multiboot ${kernel} ${kernel}

1017 # boot

1018 # }

1019

1020 #include "asm.h"

1021 #include "memlayout.h"

1022 #include "mmu.h"

1023 #include "param.h"

1024

1025 # Multiboot header. Data to direct multiboot loader.

1026 .p2align 2

1027 .text

1028 .globl multiboot_header

1029 multiboot_header:

1030 #define magic 0x1badb002

1031 #define flags 0

1032 .long magic

1033 .long flags

1034 .long (−magic−flags)

1035

1036 # By convention, the _start symbol specifies the ELF entry point.

1037 # Since we haven’t set up virtual memory yet, our entry point is

1038 # the physical address of ’entry’.

1039 .globl _start

1040 _start = V2P_WO(entry)

1041

1042 # Entering xv6 on boot processor, with paging off.

1043 .globl entry

1044 entry:

1045 # Turn on page size extension for 4Mbyte pages

1046 movl %cr4, %eax

1047 orl $(CR4_PSE), %eax

1048 movl %eax, %cr4

1049 # Set page directory

Sheet 10

Aug 29 15:52 2017 xv6/entry.S Page 2

1050 movl $(V2P_WO(entrypgdir)), %eax

1051 movl %eax, %cr3

1052 # Turn on paging.

1053 movl %cr0, %eax

1054 orl $(CR0_PG|CR0_WP), %eax

1055 movl %eax, %cr0

1056

1057 # Set up the stack pointer.

1058 movl $(stack + KSTACKSIZE), %esp

1059

1060 # Jump to main(), and switch to executing at

1061 # high addresses. The indirect call is needed because

1062 # the assembler produces a PC−relative instruction

1063 # for a direct jump.

1064 mov $main, %eax

1065 jmp *%eax

1066

1067 .comm stack, KSTACKSIZE

1068

1069

1070

1071

1072

1073

1074

1075

1076

1077

1078

1079

1080

1081

1082

1083

1084

1085

1086

1087

1088

1089

1090

1091

1092

1093

1094

1095

1096

1097

1098

1099

Sheet 10

Aug 29 15:52 2017 xv6/entryother.S Page 1

1100 #include "asm.h"

1101 #include "memlayout.h"

1102 #include "mmu.h"

1103

1104 # Each non−boot CPU ("AP") is started up in response to a STARTUP

1105 # IPI from the boot CPU. Section B.4.2 of the Multi−Processor

1106 # Specification says that the AP will start in real mode with CS:IP

1107 # set to XY00:0000, where XY is an 8−bit value sent with the

1108 # STARTUP. Thus this code must start at a 4096−byte boundary.

1109 #

1110 # Because this code sets DS to zero, it must sit

1111 # at an address in the low 2^16 bytes.

1112 #

1113 # Startothers (in main.c) sends the STARTUPs one at a time.

1114 # It copies this code (start) at 0x7000. It puts the address of

1115 # a newly allocated per−core stack in start−4,the address of the

1116 # place to jump to (mpenter) in start−8, and the physical address

1117 # of entrypgdir in start−12.

1118 #

1119 # This code combines elements of bootasm.S and entry.S.

1120

1121 .code16

1122 .globl start

1123 start:

1124 cli

1125

1126 # Zero data segment registers DS, ES, and SS.

1127 xorw %ax,%ax

1128 movw %ax,%ds

1129 movw %ax,%es

1130 movw %ax,%ss

1131

1132 # Switch from real to protected mode. Use a bootstrap GDT that makes

1133 # virtual addresses map directly to physical addresses so that the

1134 # effective memory map doesn’t change during the transition.

1135 lgdt gdtdesc

1136 movl %cr0, %eax

1137 orl $CR0_PE, %eax

1138 movl %eax, %cr0

1139

1140 # Complete the transition to 32−bit protected mode by using a long jmp

1141 # to reload %cs and %eip. The segment descriptors are set up with no

1142 # translation, so that the mapping is still the identity mapping.

1143 ljmpl $(SEG_KCODE<<3), $(start32)

1144

1145

1146

1147

1148

1149

Sheet 11

Aug 29 15:52 2017 xv6/entryother.S Page 2

1150 .code32 # Tell assembler to generate 32−bit code now.

1151 start32:

1152 # Set up the protected−mode data segment registers

1153 movw $(SEG_KDATA<<3), %ax # Our data segment selector

1154 movw %ax, %ds # −> DS: Data Segment

1155 movw %ax, %es # −> ES: Extra Segment

1156 movw %ax, %ss # −> SS: Stack Segment

1157 movw $0, %ax # Zero segments not ready for use

1158 movw %ax, %fs # −> FS

1159 movw %ax, %gs # −> GS

1160

1161 # Turn on page size extension for 4Mbyte pages

1162 movl %cr4, %eax

1163 orl $(CR4_PSE), %eax

1164 movl %eax, %cr4

1165 # Use entrypgdir as our initial page table

1166 movl (start−12), %eax

1167 movl %eax, %cr3

1168 # Turn on paging.

1169 movl %cr0, %eax

1170 orl $(CR0_PE|CR0_PG|CR0_WP), %eax

1171 movl %eax, %cr0

1172

1173 # Switch to the stack allocated by startothers()

1174 movl (start−4), %esp

1175 # Call mpenter()

1176 call *(start−8)

1177

1178 movw $0x8a00, %ax

1179 movw %ax, %dx

1180 outw %ax, %dx

1181 movw $0x8ae0, %ax

1182 outw %ax, %dx

1183 spin:

1184 jmp spin

1185

1186 .p2align 2

1187 gdt:

1188 SEG_NULLASM

1189 SEG_ASM(STA_X|STA_R, 0, 0xffffffff)

1190 SEG_ASM(STA_W, 0, 0xffffffff)

1191

1192

1193 gdtdesc:

1194 .word (gdtdesc − gdt − 1)

1195 .long gdt

1196

1197

1198

1199

Sheet 11

Aug 29 15:52 2017 xv6/main.c Page 1

1200 #include "types.h"

1201 #include "defs.h"

1202 #include "param.h"

1203 #include "memlayout.h"

1204 #include "mmu.h"

1205 #include "proc.h"

1206 #include "x86.h"

1207

1208 static void startothers(void);

1209 static void mpmain(void) __attribute__((noreturn));

1210 extern pde_t *kpgdir;

1211 extern char end[]; // first address after kernel loaded from ELF file

1212

1213 // Bootstrap processor starts running C code here.

1214 // Allocate a real stack and switch to it, first

1215 // doing some setup required for memory allocator to work.

1216 int

1217 main(void)

1218 {

1219 kinit1(end, P2V(4*1024*1024)); // phys page allocator

1220 kvmalloc(); // kernel page table

1221 mpinit(); // detect other processors

1222 lapicinit(); // interrupt controller

1223 seginit(); // segment descriptors

1224 picinit(); // disable pic

1225 ioapicinit(); // another interrupt controller

1226 consoleinit(); // console hardware

1227 uartinit(); // serial port

1228 pinit(); // process table

1229 tvinit(); // trap vectors

1230 binit(); // buffer cache

1231 fileinit(); // file table

1232 ideinit(); // disk

1233 startothers(); // start other processors

1234 kinit2(P2V(4*1024*1024), P2V(PHYSTOP)); // must come after startothers()

1235 userinit(); // first user process

1236 mpmain(); // finish this processor’s setup

1237 }

1238

1239 // Other CPUs jump here from entryother.S.

1240 static void

1241 mpenter(void)

1242 {

1243 switchkvm();

1244 seginit();

1245 lapicinit();

1246 mpmain();

1247 }

1248

1249

Sheet 12

Aug 29 15:52 2017 xv6/main.c Page 2

1250 // Common CPU setup code.

1251 static void

1252 mpmain(void)

1253 {

1254 cprintf("cpu%d: starting %d\n", cpuid(), cpuid());

1255 idtinit(); // load idt register

1256 xchg(&(mycpu()−>started), 1); // tell startothers() we’re up

1257 scheduler(); // start running processes

1258 }

1259

1260 pde_t entrypgdir[]; // For entry.S

1261

1262 // Start the non−boot (AP) processors.

1263 static void

1264 startothers(void)

1265 {

1266 extern uchar _binary_entryother_start[], _binary_entryother_size[];

1267 uchar *code;

1268 struct cpu *c;

1269 char *stack;

1270

1271 // Write entry code to unused memory at 0x7000.

1272 // The linker has placed the image of entryother.S in

1273 // _binary_entryother_start.

1274 code = P2V(0x7000);

1275 memmove(code, _binary_entryother_start, (uint)_binary_entryother_size);

1276

1277 for(c = cpus; c < cpus+ncpu; c++){

1278 if(c == mycpu()) // We’ve started already.

1279 continue;

1280

1281 // Tell entryother.S what stack to use, where to enter, and what

1282 // pgdir to use. We cannot use kpgdir yet, because the AP processor

1283 // is running in low memory, so we use entrypgdir for the APs too.

1284 stack = kalloc();

1285 *(void**)(code−4) = stack + KSTACKSIZE;

1286 *(void**)(code−8) = mpenter;

1287 *(int**)(code−12) = (void *) V2P(entrypgdir);

1288

1289 lapicstartap(c−>apicid, V2P(code));

1290

1291 // wait for cpu to finish mpmain()

1292 while(c−>started == 0)

1293 ;

1294 }

1295 }

1296

1297

1298

1299

Sheet 12

剩余98页未读，继续阅读

lita_russell_pat

粉丝: 0
资源: 4

MIT教学操作系统xv6详解与源码分析

操作系统课程网站源代码（含数据库）

操作系统这是我学校的教学课件，很使用的，也很全

mit67:用于处理室内场景识别数据集（CVPR 09-MIT）的注释的python模块

MIT Xv6 操作系统源码详解最新版 rev10

最新的.netFramework的源代码

action源码java-StaticRouting:一场戏！生成Java源代码的框架模块，该Java源代码将http请求静态路由到操作

luoxuepub:分享源代码

RFRotate(iPhone源代码)

Information:科创服务器源代码

open_source-chat：这是一个开放源代码和多平台的开放源代码聊天应用程序的项目

最新资源