FreeBSD架构手册：英文版深入解析 - CSDN文库

需积分: 18 181 浏览量更新于2024-07-20 收藏 1.51MB PDF 举报

"FreeBSD系统架构手册是一本详细介绍FreeBSD操作系统设计原理和技术的英文PDF文档。该手册由FreeBSD文档项目编撰，包含了多位作者的贡献，并且不断更新以保持内容的时效性。尽管存在中文版，但用户推荐阅读英文原版以获取更清晰、准确的理解。手册可供在FreeBSD的官方网站或FTP服务器以及其镜像站点上下载，提供了多种格式和压缩选项以满足不同用户需求。" 《FreeBSD系统架构手册》深入解析了FreeBSD操作系统的核心结构和设计理念，是了解和学习FreeBSD不可或缺的参考资料。手册涵盖了多个主题，包括但不限于： 1. **FreeBSD简介**：阐述FreeBSD项目的历史、目标以及它与其它开源操作系统的区别，同时介绍了FreeBSD社区及其对开源软件的贡献。 2. **内核设计**：详述FreeBSD内核的体系结构，包括进程管理、内存管理、虚拟文件系统、网络堆栈、设备驱动等核心组件的工作原理。 3. **系统安装与配置**：指导用户如何规划硬件环境，安装FreeBSD系统，并进行基本的系统配置。 4. **软件包与ports系统**：解释FreeBSD如何通过ports系统来管理和更新软件包，以及如何构建自定义的软件集。 5. **安全与防火墙**：介绍FreeBSD的安全特性，如FreeBSD jails、Kerberos认证、IPFW和pf防火墙，以及安全策略的制定。 6. **性能优化**：讨论系统性能监控工具，如dtrace，以及如何调整内核参数和系统设置以提升系统性能。 7. **网络服务**：涵盖DNS、NFS、Samba、SMTP服务器等网络服务的配置和管理。 8. **硬件支持**：列出FreeBSD支持的硬件设备，包括CPU、存储、网络设备等，并提供相关驱动程序的信息。 9. **故障排查**：提供诊断和解决FreeBSD系统问题的方法，包括日志分析、调试工具的使用等。 10. **开发与编程**：讲解FreeBSD上的开发环境，包括编译工具链、调试器，以及如何为FreeBSD编写和贡献代码。手册鼓励感兴趣的读者参与到FreeBSD文档项目的改进工作中，通过向相关邮件列表发送邮件贡献自己的力量。这不仅有助于手册内容的完善，也有助于FreeBSD社区的发展。《FreeBSD系统架构手册》是系统管理员、开发者和所有对FreeBSD感兴趣的用户的重要参考资料，它详细地揭示了FreeBSD操作系统的内部运作机制，帮助读者掌握其核心技术和最佳实践。

The BIOS

6

kernel

Copyright(c)1992-2013TheFreeBSD↺

Project.

Copyright(c)1979,1980,1983,1986,↺

1988,1989,1991,1992,1993,1994

TheRegentsoftheUniversityof↺

California.Allrightsreserved.

FreeBSDisaregisteredtrademarkofThe↺

FreeBSDFoundation.

FreeBSD10.0-RELEASE#0r260789:ThuJan↺

1622:34:59UTC2014

root@snap.freebsd.org:/usr/obj/usr/src/

sys/GENERICamd64

FreeBSDclangversion3.3(tags/RELEASE_33/

final183502)20130610

a

This prompt will appear if the user presses a key just after selecting an OS to boot at the boot0 stage.

1.3.The BIOS

When the computer powers on, the processor's registers are set to some predefined values. One of the registers is

the instruction pointer register, and its value after a power on is well defined: it is a 32-bit value of 0xfffffff0 . The

instruction pointer register (also known as the Program Counter) points to code to be executed by the processor.

Another important register is the cr0 32-bit control register, and its value just after a reboot is 0. One of cr0's bits,

the PE (Protection Enabled) bit, indicates whether the processor is running in 32-bit protected mode or 16-bit real

mode. Since this bit is cleared at boot time, the processor boots in 16-bit real mode. Real mode means, among other

things, that linear and physical addresses are identical. The reason for the processor not to start immediately in

32-bit protected mode is backwards compatibility. In particular, the boot process relies on the services provided

by the BIOS, and the BIOS itself works in legacy, 16-bit code.

The value of 0xfffffff0 is slightly less than 4GB, so unless the machine has 4GB of physical memory, it cannot

point to a valid memory address. The computer's hardware translates this address so that it points to a BIOS mem-

ory block.

The BIOS (Basic Input Output System) is a chip on the motherboard that has a relatively small amount of read-only

memory (ROM). This memory contains various low-level routines that are specific to the hardware supplied with

the motherboard. The processor will rst jump to the address 0xf0, which really resides in the BIOS's memory.

Usually this address contains a jump instruction to the BIOS's POST routines.

The POST (Power On Self Test) is a set of routines including the memory check, system bus check, and other low-

level initialization so the CPU can set up the computer properly. The important step of this stage is determining the

boot device. Modern BIOS implementations permit the selection of a boot device, allowing booting from a floppy,

CD-ROM, hard disk, or other devices.

The very last thing in the POST is the INT 0x19 instruction. The INT 0x19 handler reads 512 bytes from the

rst sector of boot device into the memory at address 0x7c00 . The term rst sector originates from hard drive

architecture, where the magnetic plate is divided into a number of cylindrical tracks. Tracks are numbered, and

every track is divided into a number (usually 64) of sectors. Track numbers start at 0, but sector numbers start

from 1. Track 0 is the outermost on the magnetic plate, and sector 1, the rst sector, has a special purpose. It is

also called the MBR, or Master Boot Record. The remaining sectors on the rst track are never used.

This sector is our boot-sequence starting point. As we will see, this sector contains a copy of our boot0 program.

A jump is made by the BIOS to address 0x7c00 so it starts executing.

1.4.The Master Boot Record (boot0 )

After control is received from the BIOS at memory address 0x7c00 , boot0 starts executing. It is the rst piece of

code under FreeBSD control. The task of boot0 is quite simple: scan the partition table and let the user choose

Chapter1.Bootstrapping and Kernel Initialization

7

which partition to boot from. The Partition Table is a special, standard data structure embedded in the MBR (hence

embedded in boot0 ) describing the four standard PC “partitions”

1

. boot0 resides in the filesystem as /boot/

boot0 . It is a small 512-byte le, and it is exactly what FreeBSD's installation procedure wrote to the hard disk's

MBR if you chose the “bootmanager” option at installation time. Indeed, boot0 is the MBR.

As mentioned previously, the INT 0x19 instruction causes the INT 0x19 handler to load an MBR (boot0 ) into

memory at address 0x7c00 . The source le for boot0 can be found in sys/boot/i386/boot0/boot0.S - which is

an awesome piece of code written by Robert Nordier.

A special structure starting from offset 0x1be in the MBR is called the partition table. It has four records of 16 bytes

each, called partition records, which represent how the hard disk is partitioned, or, in FreeBSD's terminology, sliced.

One byte of those 16 says whether a partition (slice) is bootable or not. Exactly one record must have that ag set,

otherwise boot0 's code will refuse to proceed.

A partition record has the following elds:

• the 1-byte filesystem type

• the 1-byte bootable ag

• the 6 byte descriptor in CHS format

• the 8 byte descriptor in LBA format

A partition record descriptor contains information about where exactly the partition resides on the drive. Both

descriptors, LBA and CHS, describe the same information, but in different ways: LBA (Logical Block Addressing) has

the starting sector for the partition and the partition's length, while CHS (Cylinder Head Sector) has coordinates

for the rst and last sectors of the partition. The partition table ends with the special signature 0xaa55 .

The MBR must t into 512 bytes, a single disk sector. This program uses low-level “tricks” like taking advantage of

the side effects of certain instructions and reusing register values from previous operations to make the most out

of the fewest possible instructions. Care must also be taken when handling the partition table, which is embedded

in the MBR itself. For these reasons, be very careful when modifying boot0.S .

Note that the boot0.S source le is assembled “as is”: instructions are translated one by one to binary, with no

additional information (no ELF le format, for example). This kind of low-level control is achieved at link time

through special control ags passed to the linker. For example, the text section of the program is set to be located

at address 0x600 . In practice this means that boot0 must be loaded to memory address 0x600 in order to function

properly.

It is worth looking at the Makefile for boot0 (sys/boot/i386/boot0/Makefile ), as it defines some of the run-

time behavior of boot0 . For instance, if a terminal connected to the serial port (COM1) is used for I/O, the macro

SIO must be defined (-DSIO ). -DPXE enables boot through PXE by pressing F6. Additionally, the program defines

a set of ags that allow further modification of its behavior. All of this is illustrated in the Makefile. For example,

look at the linker directives which command the linker to start the text section at address 0x600 , and to build the

output le “as is” (strip out any le formatting):

BOOT_BOOT0_ORG?=0x600

LDFLAGS=-estart -Ttext${BOOT_BOOT0_ORG}\

-Wl,-N,-S,--oformat,binary

Figure1.1.sys/boot/i386/boot0/Makefile

Let us now start our study of the MBR, or boot0 , starting where execution begins.

1

http://en.wikipedia.org/wiki/Master_boot_record

The Master Boot Record (boot0 )

8

Note

Some modifications have been made to some instructions in favor of better exposition. For

example, some macros are expanded, and some macro tests are omitted when the result of

the test is known. This applies to all of the code examples shown.

start:

cld #Stringopsinc

xorw%ax,%ax #Zero

movw%ax,%es #Address

movw%ax,%ds # data

movw%ax,%ss #Setup

movw0x7c00,%sp # stack

Figure1.2.sys/boot/i386/boot0/boot0.S

This rst block of code is the entry point of the program. It is where the BIOS transfers control. First, it makes

sure that the string operations autoincrement its pointer operands (the cld instruction)

2

. Then, as it makes no

assumption about the state of the segment registers, it initializes them. Finally, it sets the stack pointer register

(%sp) to address 0x7c00 , so we have a working stack.

The next block is responsible for the relocation and subsequent jump to the relocated code.

movw$0x7c00,%si #Source

movw$0x600,%di #Destination

movw$512,%cx #Wordcount

rep #Relocate

movsb # code

movw%di,%bp #Addressvariables

movb$16,%cl #Wordstoclear

rep #Zero

stosb # them

incb -0xe(%di) #SettheSfieldto1

jmpmain-0x7c00+0x600 #Jumptorelocatedcode

Figure1.3.sys/boot/i386/boot0/boot0.S

Because boot0 is loaded by the BIOS to address 0x7C00 , it copies itself to address 0x600 and then transfers control

there (recall that it was linked to execute at address 0x600 ). The source address, 0x7c00 , is copied to register %si.

The destination address, 0x600 , to register %di. The number of bytes to copy, 512 (the program's size), is copied

to register %cx. Next, the rep instruction repeats the instruction that follows, that is, movsb , the number of times

dictated by the %cx register. The movsb instruction copies the byte pointed to by %si to the address pointed to

by %di. This is repeated another 511 times. On each repetition, both the source and destination registers, %si and

%di, are incremented by one. Thus, upon completion of the 512-byte copy, %di has the value 0x600 +512= 0x800 ,

and %si has the value 0x7c00 +512= 0x7e00 ; we have thus completed the code relocation.

Next, the destination register %di is copied to %bp. %bp gets the value 0x800 . The value 16 is copied to %cl in

preparation for a new string operation (like our previous movsb ). Now, stosb is executed 16 times. This instruction

copies a 0 value to the address pointed to by the destination register (%di, which is 0x800 ), and increments it. This is

repeated another 15 times, so %di ends up with value 0x810 . Effectively, this clears the address range 0x800 -0x80f .

This range is used as a (fake) partition table for writing the MBR back to disk. Finally, the sector eld for the CHS

addressing of this fake partition is given the value 1 and a jump is made to the main function from the relocated

code. Note that until this jump to the relocated code, any reference to an absolute address was avoided.

2

When in doubt, we refer the reader to the official Intel manuals, which describe the exact semantics for each instruction: http://www.in-

tel.com/content/www/us/en/processors/architectures-software-developer-manuals.html.

Chapter1.Bootstrapping and Kernel Initialization

9

The following code block tests whether the drive number provided by the BIOS should be used, or the one stored

in boot0 .

main:

testb$SETDRV,-69(%bp) #Setdrivenumber?

jnzdisable_update #Yes

testb%dl,%dl #Drivenumbervalid?

jssave_curdrive #Possibly(0x80set)

Figure1.4.sys/boot/i386/boot0/boot0.S

This code tests the SETDRV bit (0x20) in the ags variable. Recall that register %bp points to address location 0x800 ,

so the test is done to the ags variable at address 0x800 -69= 0x7bb . This is an example of the type of modifications

that can be done to boot0 . The SETDRV ag is not set by default, but it can be set in the Makefile. When set, the

drive number stored in the MBR is used instead of the one provided by the BIOS. We assume the defaults, and that

the BIOS provided a valid drive number, so we jump to save_curdrive.

The next block saves the drive number provided by the BIOS, and calls putn to print a new line on the screen.

save_curdrive:

movb%dl,(%bp) #Savedrivenumber

pushw%dx #Alsointhestack

#ifdef TEST /*testcode,printinternalbiosdrive*/

rolb$1,%dl

movw$drive,%si

callputkey

#endif

callwputn #Printanewline

Figure1.5.sys/boot/i386/boot0/boot0.S

Note that we assume TEST is not defined, so the conditional code in it is not assembled and will not appear in our

executable boot0 .

Our next block implements the actual scanning of the partition table. It prints to the screen the partition type for

each of the four entries in the partition table. It compares each type with a list of well-known operating system

le systems. Examples of recognized partition types are NTFS (Windows®, ID 0x7), ext2fs (Linux®, ID 0x83), and,

of course, ffs/ufs2 (FreeBSD, ID 0xa5). The implementation is fairly simple.

movw$(partbl+0x4),%bx #Partitiontable(+4)

xorw%dx,%dx #Itemnumber

read_entry:

movb%ch,-0x4(%bx) #Zeroactiveflag(ch==0)

btw%dx,_FLAGS(%bp) #Entryenabled?

jncnext_entry #No

movb(%bx),%al #Loadtype

test%al,%al #skipemptypartition

jznext_entry

movw$bootable_ids,%di #Lookuptables

movb$(TLEN+1),%cl #Numberofentries

repne #Locate

scasb # type

addw$(TLEN-1),%di #Adjust

movb(%di),%cl #Partition

addw%cx,%di # description

callwputx #Displayit

next_entry:

incw%dx #Nextitem

addb$0x10,%bl #Nextentry

jncread_entry #Tilldone

Figure1.6.sys/boot/i386/boot0/boot0.S

The Master Boot Record (boot0 )

10

It is important to note that the active ag for each entry is cleared, so after the scanning, no partition entry is

active in our memory copy of boot0 . Later, the active ag will be set for the selected partition. This ensures that

only one active partition exists if the user chooses to write the changes back to disk.

The next block tests for other drives. At startup, the BIOS writes the number of drives present in the computer

to address 0x475 . If there are any other drives present, boot0 prints the current drive to screen. The user may

command boot0 to scan partitions on another drive later.

popw%ax #Drivenumber

subb$0x79,%al #Doesnext

cmpb0x475,%al # driveexist?(fromBIOS?)

jbprint_drive #Yes

decw%ax #Alreadydrive0?

jzprint_prompt #Yes

Figure1.7.sys/boot/i386/boot0/boot0.S

We make the assumption that a single drive is present, so the jump to print_drive is not performed. We also

assume nothing strange happened, so we jump to print_prompt .

This next block just prints out a prompt followed by the default option:

print_prompt:

movw$prompt,%si #Display

callwputstr # prompt

movb_OPT(%bp),%dl #Display

decw%si # default

callwputkey # key

jmpstart_input #Skipbeep

Figure1.8.sys/boot/i386/boot0/boot0.S

Finally, a jump is performed to start_input, where the BIOS services are used to start a timer and for reading user

input from the keyboard; if the timer expires, the default option will be selected:

start_input:

xorb%ah,%ah #BIOS:Get

int$0x1a # systemtime

movw%dx,%di #Tickswhen

addw_TICKS(%bp),%di # timeout

read_key:

movb$0x1,%ah #BIOS:Check

int$0x16 # forkeypress

jnzgot_key #Haveinput

xorb%ah,%ah #BIOS:int0x1a,00

int$0x1a # getsystemtime

cmpw%di,%dx #Timeout?

jbread_key #No

Figure1.9.sys/boot/i386/boot0/boot0.S

An interrupt is requested with number 0x1a and argument 0 in register %ah. The BIOS has a predefined set of

services, requested by applications as software-generated interrupts through the int instruction and receiving

arguments in registers (in this case, %ah). Here, particularly, we are requesting the number of clock ticks since last

midnight; this value is computed by the BIOS through the RTC (Real Time Clock). This clock can be programmed

to work at frequencies ranging from 2Hz to 8192Hz. The BIOS sets it to 18.2Hz at startup. When the request is

satisfied, a 32-bit result is returned by the BIOS in registers %cx and %dx (lower bytes in %dx). This result (the %dx

part) is copied to register %di, and the value of the TICKS variable is added to %di. This variable resides in boot0

at offset _TICKS (a negative value) from register %bp (which, recall, points to 0x800 ). The default value of this

剩余293页未读，继续阅读

idontlikenickname

粉丝: 4
资源: 6

最新资源