Create an operating system (zz) that supports graphical interfaces)

Original article: http://www.binghua.com/Article/Class6/Class7/200409/267.html
(For reprint and reference, please note the original author and source)
(PDF: http://www.binghua.com/Soft/Class9/Class16/200409/65.html)
(Source code: Http://www.binghua.com/Soft/Class9/Class16/200409/64.html)
Create an operating system that supports graphical interfaces (on)

Version 0.01:

(Corresponding pyos version: 2004_09_18_14_00)

Xie lingbo, Harbin Institute of Technology

(Email: xieyubo@126.com Website: http://purec.binghua.com)

(Qq: 13916830 Harbin Institute of Technology bbsid: iamxiaohan)

Preface

GUI is widely used in almost all mainstream operating systems and applications.ProgramThis is because it provides excellent human-computer interaction interfaces. Microsoft's well-known Windows is a very successful and obvious example. It is said that Microsoft's philosophy is "making computers more and more dummies, anyone can operate on it. "Obviously, the GUI is necessary to realize this dream.

With the support of the operating system, it is relatively easy to compile a program with a graphical interface, because the operating system manages the graphics card for you, provides you with a variety of graphic functions, such as painting points, draw lines, draw rectangles, and fill. You only need to display what you want, you can directly call such functions to generate them, and the operating system will complete the rest for you.

However, if you want to write an operating system from scratch, but you cannot use the convenience functions provided by the existing operating system, how should you complete such a GUI?

This article will take the pyos system as an example to briefly describe how to make your own operating system support the graphical interface. If you want to better understand the content of this article, you need to have some knowledge about the operating system boot process. For more information, see References 1 in this article, you also need to understand the assembly language. For more information, see references 2 in this article. Experiment in this articleCodeCompleted by assembly and C language. If you are not familiar with C language, refer to references 3 in this article.

The standard GUI should contain graphical display and support for user input. The most widely used user input device on the GUI is the mouse. Therefore, this article intends to describe the two parts separately. The previous section describes the display of the graphic interface and the next section describes the support for the mouse.

Due to limited knowledge and level, you are welcome to contact me if you have any suggestions for any improper or incorrect information. I will track the feedback on this article on the Harbin Institute of Technology pure C Forum (http://purec.binghua.com), the information and source code described in this article can also be found above.

I. Introduction to the standard VESA video card interface

The so-called standard is actually a protocol, such as the video card interface standard, that is, the protocol for communication between the video card and the host. Through this protocol, the host can operate and control the video card. For example, if the host wants the video card to draw a dot in (x, y), what operations should be performed on the video card? This is clearly stated in the Protocol. Therefore, if we want to operate a video card, we only need to follow the instructions and regulations in the Agreement. The Agreement here is just like a manual.

With the development of graphics cards, many protocols have emerged, such as the license protocol, CGA protocol, and VGA protocol, the most widely used protocol is the VESA protocol developed by the International Association for Video Electronics Standards Association. The latest Protocol version is 3.0, however, not all graphics cards currently support this Protocol, especially many virtual machines. Therefore, this article uses version 2.0 as the basis for description, because each version is backward compatible, therefore, a 2.0-based program can be applied to version 3.0 without modification.

The VESA standard includes many sub-standards. The most useful for operating system writing is the VBE standard (vesa bios Extension). In actual system writing, we follow this standard, by calling the BIOS 0x10 interrupt, and operating the video card, when calling this interrupt, what is stored in the ax register is the function of the video card you want to use. For example, the VESA 2.0 standard stipulates that the 0x4f00 function can return the VESA standard information supported by the video card, and the 0x4f01 function can return the information of the specified display mode, such as the number of row and column pixels, the number of bytes per pixel. It is very convenient to call these functions. For example, by reading the VESA standard, we know that the 0x4f02 function can be used to set the display mode. When this function is called, BX stores the number of the display mode to be set. Therefore, if we want to set the display mode of the video card to 0x111, we should write the following code:

MoV ax, 0x4f02; sets the interrupt function number, indicating that the 0x4f02 function is used.

MoV BX, 0x111; sets the display mode number, indicating that 0x111 is used.

Int 0x10; call the BIOS 0x10 interrupt, set the video card function

After the above code is executed, the video card is set to the 0x111 display mode. What are the display features of this mode? See the following table:

(Table 1 VESA standard-defined display mode (partial ))

Pattern number

Resolution

Color

Zero x 100

640*400

256

Zero X 101

640*480

256

Zero X 102

800*600

16

Zero x 103

800*600

256

Zero X 104

1024*768

16

Zero X 105

1024*768

256

Zero X 106

1280*1024

16

Zero X 107

1280*1024

256

0x10d

300*200

1: 5: 5: 5

0x10e

320*200

0x10f

320*200

Zero x 110

640*480

1: 5: 5: 5

Zero x 111

640*480

Zero x 112

640*480

Zero X 113

800*600

1: 5: 5: 5

Zero x 114

800*600

Zero x 115

800*600

Zero X 116

1024*768

1: 5: 5: 5

Zero X 117

1024*768

Zero x 118

1024*768

Zero X 119

1280*1024

1: 5: 5: 5

0x11a

1280*1024

0x11b

1280*1024

The above table lists some display modes defined by the VESA standard, in which colors have two forms. One is the so-called "palette" mode, and the other is the so-called "true color" mode. The "palette" mode is mainly used to ensure compatibility with old-fashioned graphics cards, generally, the number of video memory on a video card is very small. Therefore, the video card can only store up to 256 (8 bits) or less 16 colors (4 bits) at a time ), as shown in the previous section of this table. The video card organizes these colors into a table, which is called a palette. The color information of each vertex is actually a subscript used to retrieve the true colors from the palette. For example, if the color of a vertex is 2, the third color in the color palette is used (because the number starts from 0, SO 2 corresponds to the third item in the color palette ). Obviously, not all colors can be recorded in a small palette, so in general, for a given color, we need to display it with the most similar color in the palette.

Currently, graphics cards generally have large video memory, so they can store the color information of a point completely. We know that any color can be synthesized by red (R), Green (G), and blue (B) colors of different intensity (brightness). Therefore, we need to record or give the color information of a vertex. We only need to give the intensity (brightness) of the three colors, red, green, and blue. Therefore, there are a variety of different encoding methods, such as the "" mode, it indicates that the highest five bits represent the red intensity, with the middle of the 6 bits, representing the green intensity, use the last five digits to represent the blue intensity. This represents a color. A total of 16 bits are required, that is, 2B. "8: 8" indicates the red intensity, the next 8 bits represent the green intensity, and the last 8 bits represent the blue intensity. A color is represented by 24 bits, that is, three bits. And so on. Because these colors are actually recorded, this pattern is also called the "true color" pattern, as shown in the following section of table 1.

As described above, we can select an appropriate display mode based on our needs, and then call the interrupt settings display card defined in The VBE standard.

VBE Standards describe a large number of functions. We will not describe them all here. We will only describe the functions required in the following article. If you want to know the functions described in the entire VBE standard, see reference 4 in this document.

Next we will describe the 0x4f01 function that we need below. This function returns the corresponding information of the display mode supported by the video card to the address specified by the user. It can be called as follows:

MoV ax, 0x4f01; indicates that 0x4f01 is used to obtain display mode information.

MoV CX, 0x111; indicates the display mode of 0x111.

MoV es, 0x9000

MoV Di, 0x0001; the preceding two statements indicate that the information is stored in ES: Di.

; (Here 0x9000: 0x0001), this is a piece of memory

; Starting address, and the memory size of this block must be at least 256b

The returned information is a 256-byte structure. Here we will only describe what we are interested in.

In the returned struct, the offset is 40, that is, ES: di + 40, which stores a linear address in 4 bytes. This is the linear address of the video card in this mode, therefore, if we write data directly to this address, the data will be directly written to the video storage, so that we can display the information we need to display. This is the so-called "Direct Screen Writing ".

The returned struct also contains many other information such as the pixels and column pixels of each row of the video card in this mode. For more information, see reference 4 in this article.

Ii. Experiment with pyos

2.1 guide code analysis

We are very pleased that we don't need to know much basic knowledge in this experiment, but we can quickly enter the experiment. Let's take a look at our experiment.

Before the experiment, we need to set a display mode for the experiment. For now, we set it to 640*480. The color mode is, that is, 0x111.

Let's take a look at the final results of this experiment:

Now, let's take a look at our guiding code:

Main:; main program

; Set the segment register below

MoV ax, boot_seg

MoV ds, ax

MoV ax, temp_data_seg

MoV SS, ax

MoV sp, 0 xFFFF

MoV [boot_driver], DL; get the start drive letter

Call open_a_20; open the A20 address line

Call save_boot_driver; Save the drive letter

Call show_message; displays the startup information.

Call read_setup; read the setup program

Jmp dword setup_seg: setup_offset; jump to the setup and execute

This is the pyos Boot Program (boot. ASM) main function code, it is now very simple, at first, you need to set the segment register, such as initializing the data segment register (DS), stack segment register (SS ), and Stack pointer (SP), and then read the setup program (steup. ASM), read it at setup_seg: setup_offset (both setup_seg and setup_offset are in Boot. A constant defined at the beginning of ASM). For detailed code of each subroutine, see the source code of this experiment.

Next, let's look at the setup (setup. ASM) Program:

Main:

; Initialize the register because the BIOS is interrupted and the call will use the stack or SS register.

; The CPU is initialized by the BIOS when it is started or reset, but now the segment is transferred, We need to reset it

MoV ax, setup_seg

MoV ds, ax

MoV ax, temp_data_seg

MoV SS, ax

MoV sp, 0 xFFFF

; Display startup information

Call show_message

; Get the start drive letter

Call get_boot_driver

; Set the Display Mode

Call set_vesa_model

; Read the kernel program

Call read_kernel

; Read the font library

Call read_font_lib

; Read the hit image

Call read_hit_pbmp

; The initialization is started for entering the protection mode.

Lgdt [gdt_descriptor]; load the gdt Descriptor

; The following settings run in 32-bit protection mode

CLI; disconnection

MoV eax, Cr0

Or eax, 1

MoV Cr0, eax

Jmp dword 0x8: kernel_entry

The above program is also very simple. First, reinitialize the segment register, set the graphic display mode, and then read the Kernel Program (this is the real kernel code of the operating system ), then read the font (which will be described in more detail below), and then read a hit image (hit is the abbreviation of "Harbin Institute of Technology, the image uses a BMP format, which will be described in detail below), then convert to the protected mode, and finally switch to the protected mode's kernel program, that is, it is executed in the real operating system kernel code. The reference 1 in this article describes how to switch to the protection mode in detail. If you have any questions about this part, refer to it. Next let's take a look at the code of the core subroutine set_vesa_model. For other code, see the source program of this experiment.

Set_vesa_model:; sets the video card mode.

Push es

Push FS

; Set the video card mode

MoV ax, 0x4f02

MoV BX, 0x4111; 640*480)

Int 0x10

; Obtain the linear address of the video memory in this mode

MoV BX, setup_seg

MoV es, BX

MoV Di, VESA

; Call the 0x4f01 function to obtain information

MoV ax, 0x4f01

MoV CX, 0x111

Int 0x10

; Store linear addresses

MoV eax, [ES: Vesa + 40]

MoV BX, temp_data_seg

MoV FS, BX

MoV [FS: 1], eax

Pop es

Pop FS

RET

The program is very simple. The following is a simple explanation. after entering the program, we first set the display mode of the video card:

; Set the video card mode

MoV ax, 0x4f02

MoV BX, 0x4111; 640*480)

Int 0x10

The above lines of code have been described earlier in the VBE standard. Here we set 640*480 (), that is, the corresponding 0x111 mode (see table 1). However, you will find that the data sent to BX is 0x4111 instead of 0x111. Why? This is mainly because we need to use the linear address mode, that is, to access all the memory space by directly accessing the physical memory space. Therefore, the input to the Bx should be 0x4000 | pattern number, 0X4000 | 0x111 = 0x4111 (perform and operate the mode number and 0x4000, which is also specified by the VBE label ).

Then, we use the 0x4f01 function to obtain the linear address of the video card memory in this mode:

; Obtain the linear address of the video memory in this mode

MoV BX, setup_seg

MoV es, BX

MoV BX, temp_data_seg

MoV FS, BX

MoV Di, VESA

; Call the 0x4f01 function to obtain information

MoV ax, 0x4f01

MoV CX, 0x111

Int 0x10

Since es = temp_data_seg, DI = VESA, the read information is stored at temp_data_seg: Vesa. Then, the linear address of the video card in this mode is retrieved from the information:

; Store linear addresses

MoV eax, [ES: Vesa + 40]

MoV BX, temp_data_seg

MoV FS, BX

MoV [FS: 1], eax

Pop es

Pop FS

RET

The above code is very simple. Because the linear address of the video card in this mode exists in the offset of 40 in the returned information block, use "mov eax, [ES: VESA + 40] "read from eax, and then put it in [FS: 1]. Because FS is equal to temp_data_seg, it is stored in temp_data_seg: 1.

The setup_seg, Vesa, and temp_data_seg in the above program are all constants originally defined in the program. For details, see the source code.

2.2 pyos Memory Structure

In this experiment, pyos does not have a file system and a memory management and allocation program. Therefore, in this experiment, pyos uses the absolute positioning of disks and memory, that is to say, the location of all data in the memory is fixed. Let's take a look at the memory structure of pyos.

0x0000: 0x7c00: the boot. ASM code is stored here, which is automatically read by the BIOS when the system powers up.

0x1000: 0x0000: The setup. ASM code is stored here, which is read by boot. ASM.

0x2000: 0x0000: the kernel code (mainly kernle. c) is stored here, which is read by setup. ASM.

0x6000: 0x0000: Hit image data is stored here, which is read by setup. ASM.

0x7000: 0x0000: The English dot matrix font data is stored here, which is read by setup. ASM.

0x8000: 0x0000: the data in the Chinese dot matrix font is stored here, which is read by setup. ASM.

0x9000: 0x0000: The Boot drive letter is stored here and saved by boot. ASM.

0x9000: 0x0001: stores the linear address of the video card.

2.3 pyos graphics driver

After the program jumps to the kernel code through "jmp dword 0x8: kernel_entry" at the end of setup. ASM, the operating system starts to operate. Let's take a look at this kernel code:

# Include "system. H"

# Include "Vesa. H"

Void kernel_main ()

{

// System initialization

System_init ();

// Clear screen

Unsigned short color = vesa_component d_rgb (255,255,255 );

// Draw a rectangle

Vesa_draw_rect (0, 0,639,479, color, 1 );

............ (The remaining drawing code is omitted)

For (;;);

}

The above code is very simple. It first initializes the system and then clears the screen. pyos clears the screen using the most snail ded method, which treats the whole screen as a rectangle (X: 0 ~ 639, Y: 0 ~ 479), and then draw each vertex in the rectangle with a color. Vesa_compond_rgb () is used to input R (red), g (green), and blue (B) the value is synthesized into a 16-bit long integer (because the mode is used, the color of a total vertex is represented by a 16-bit integer). Then, it calls vesa_draw_rect () function to draw this rectangle, let's look at this function:

// Draw a rectangle Function

Void vesa_draw_rect (unsigned int X1, unsigned int Y1, unsigned int X2, unsigned Y2, unsigned short color, int dose_fill_it)

{

Vesa_draw_x_line (Y1, x1, x2, color );

Vesa_draw_x_line (Y2, x1, x2, color );

Vesa_draw_y_line (x1, Y1, Y2, color );

Vesa_draw_y_line (X2, Y1, Y2, color );

If (dose_fill_it ){

Vesa_fill_rect (x1, Y1, X2, Y2, color );

}

}

It is very simple. It first draws the border of the rectangle, and then determines whether to call the vesa_fill_rect () function to fill the rectangle based on the user input parameters. Let's take a look at this Fill function:

// Rectangle filling function

Void vesa_fill_rect (unsigned int X1, unsigned int Y1, unsigned int X2, unsigned int Y2, unsigned short color)

{

For (INT x = x1; x <X2 + 1; ++ X ){

For (INT y = Y1; y <y2 + 1; ++ y ){

Vesa_draw_point (X, Y, color );

}

}

}

Dizzy! It's too simple. It turns out that the vesa_draw_point () function is constantly called, and all vertices in the rectangle are drawn in the same color. So, we have to trace the source to see the vesa_draw_point () function:

// Vertex Function

Void vesa_draw_point (unsigned int X, unsigned int y, unsigned short color)

{

Static const unsigned int x_max = 639; // number of workers per line

Static const unsigned int y_max = 479; // number of workers in each column

// Prevent cross-border attacks

If (x> x_max ){

X = x_max;

}

If (Y> y_max ){

Y = y_max;

}

// Obtain the linear address of the video memory.

Unsigned short * Video = (unsigned short *) (* (unsigned int *) 0x90001 ));

// Calculate the offset of the vertex

Unsigned int offset = y * (x_max + 1) + X;

* (Video + offset) = color;

}

This function is the foundation of the entire pyos VESA graphics card driver. It is used to draw lines, draw rectangles, and fill rectangles. Now let's analyze it. Pay attention to the following line of code:

// Obtain the linear address of the video memory.

Unsigned short * Video = (unsigned short *) (* (unsigned int *) 0x90001 ));

First, in section 2.2, we know that the linear address of the video card memory is stored at 0x9000: 0001 (this linear address is 32 bits, that is, 4B). Therefore, convert 0x9000: 0001 to a linear address of 0x90001. Then, in the C language, convert it to a pointer pointing to the unsigned int type and use the * operator, the pointer is taken out, that is, the data stored at the address 0x90001, that is, the linear address of the memory stored here is obtained, then, convert it into an unsigned short pointer. This is because every vertex is represented by 2B bytes, that is, an unsigned short type data, this linear address is also the address of (0, 0.

Then, we calculated the offset of the (x, y) point through the column coordinate: X, row coordinate: Y, and finally assigned the color information to this (x, y) the memory address where the vertex is located, then (x, y) points show the color we specified. It's actually that simple!

2.4 display of English, Chinese, and graphics

Let's first talk about graphics. Here we mainly refer to bitmaps, that is, the display of BMP-format images. bitmaps are recorded only by data for each vertex (BIT) on this graph, it contains the color information of each vertex, such as a 24-Bit Bitmap, that is, each vertex on this graph uses a 24-bit data, that is, three bytes of data are saved. Of course, the stored data can be the color index value in the color palette or RGB data. Then, we can read the color data of each vertex and write them into the corresponding Display memory, as described in Section 2.3, draw them all at. Of course, when using bitmap, you need to know how many bytes each vertex of this bitmap represents, how many vertices a row has, and how many rows there are in total, whether to store one row or one column. Of course, these are implementation problems. I will not talk about them here, after understanding the principles, you can decide your own implementation method and create your own image format.

Every English character is the same as every Chinese character. They are also graphs. However, in general, this graph only needs to be displayed in one color. Therefore, we do not need to record the color information of each point, but only need to record whether each point needs to be displayed. If we do not need to display the point, we can record it as 0, we can record the vertices to be displayed as 1. Therefore, if there are eight vertices in a row, we only need to use 8 bits, that is, 1B can be stored, 0th ~ 7 bits, corresponding to 0 ~ . If the value is 1, draw the point of the corresponding digit on the video card.

The Chinese characters used in pyos use a 16*16 dot matrix font. In this font, each Chinese character is represented by 16*16 vertices, that is, 16 rows, with 16 vertices per line, as mentioned above, we can represent 16 points in each line in 16 bits, that is, 2B. Therefore, a Chinese character occupies 2*16 = 32B, which is also called a model, people put all Chinese character information, that is, all the fonts, together to form a font. to display the information, they only need to extract the corresponding fonts from the font, analyze each bit of it, and assign the color values to the corresponding points on the display (video card.

The same is true for English characters. In pyos, 8x16 English dot matrix fonts are used. In this font, each English font is represented by 8x16 vertices, with 16 lines, each line has eight vertices, that is, the space of 1B. Therefore, the space occupied by an English character is 1*16 = 16B. The display principles and methods are described in the previous section.

Now the question is, how do you know the starting position of an English character or a Chinese character in the font? For English, each character has an ascii code. In an English font, English symbols are usually stored in the ASCII order. Therefore, the English ASCII code is used, multiply by the space occupied by each English character to get the location of the English character in the English font.

Chinese is a little troublesome. We know that a Chinese character is represented by two bytes. The first byte equals the area code of the Chinese character plus 161, and the second byte equals the location code of the Chinese character plus 161, chinese characters are stored by region code and location code. A total of 94 Chinese characters in the national standard have 94 locations and each region has 94 locations. This is what we often call the "Location Code ", the Chinese character model is stored in a zone according to the location code. Therefore, after knowing the location code of a Chinese character, we can calculate the position of the Chinese character in the font library. For example, the first section of a Chinese character is character, the second byte is CH2, so the area code of Chinese characters is sector = ch1-161, the position of Chinese characters is position = ch2-161, then the position of Chinese characters in the font is: pos_in_font = (sector * 94 + position) * size. Size indicates the space occupied by each Chinese Character in the font.

It should be noted that the above is a theoretical description, which is not necessarily used in practice. For example, in this pyos experiment, because the amount of data to be displayed is very small, therefore, you do not need to load all the large font libraries into the memory. Therefore, you have written a program to extract the words to be displayed from the font. Then, load the generated small font library into the memory. At last, it is displayed in the order of extraction from the small font library (please refer to the instructions in the source program of this experiment ). Of course, how to extract a small font library from the font library requires the above theoretical description.

For a detailed description of Chinese character display, refer to reference 5 in this article.

The font library mentioned above refers to a dot matrix font. In this font, each word is like a bitmap. In actual use, there is also a vector font library. For more information, see the relevant literature.

III. Further instructions on this experiment

This experiment describes how to develop the GUI of the operating system, but the description is very simple and has many shortcomings. Here are some notes:

First of all, the settings and other operations on the video card described in the first chapter of this article are completed in real mode. This is mainly because VESA proposed earlier and has limited support for the protection mode, now VESA 3.0 provides a relatively complete protection mode interface. You can reset the resolution and display mode of the video card in protection mode. However, Vesa 2.0 does not provide such interfaces. You cannot reset them in protection mode. There are three solutions: one is to let the user select the display mode before your operating system enters the real mode. After the operating system enters the protection mode, the user is no longer allowed to choose (this is not a solution), the second is to switch back to the protection mode, and the third is to switch to the virtual 8086 (Virtual 86) mode, the latter two methods are difficult and troublesome. If you are interested, try them.

Second, a considerable amount of data in this experiment, such as the number of bytes displayed in each row and the number of bytes displayed in each row, are known and set to fixed, although there is no problem in most cases, as a more general or better system, it should be dynamically read from the video card through The VBE standard, because it is possible that your video card does not support the previously assumed values, you can obtain the corresponding data and information by calling the 0x4f00 and 0x4f01 functions in Chapter 1.

This pyos uses the linear address mode or linear buffer mode, that is, the video memory address of the video card is fully and continuously mapped to the linear memory space, however, some video cards do not support this mode. Instead, you need to use the so-called page mode to divide the video memory into several pages, with each page being 64 kB or kb, then Map them to a block of 64 kB or kb in the memory. If you want to display a part that exceeds 64 kB or kb, you need to call the function provided by VBE to switch pages, switch to the page you specified (map the page you specified to the memory.

In addition, when setting the video card mode for pyos, the system does not check whether an error occurs or whether the video card supports the set mode. in actual application systems, none of these should be assumed in advance, but must be detected.

For more information, see article 4.

After that, the graphic driver implemented by pyos is too simple and easy to draw. It is done by drawing points, and only a straight line is finished, instead of a diagonal line and rounded corner, this involves a considerable amount of graphics knowledge, and interested friends can study.

Finally, this experiment can only be viewed, but the user cannot access the operation and cannot be called an interface. In the next article, I will describe how to write a mouse driver to make up for this gap.

References

1. Operating System Boot inquiry (version 0.02) (Xie Yunbo) http://purec.binghua.com (pure C Forum)

2. ibm pc assembly language and programming (fourth editiom) (photoprinting) (Peter Abel) Tsinghua University Press

3. "C language university practical tutorial" (SU Xiaohong, Chen huipeng, Sun Zhigang) Electronic Industry Publishing House

4. vesa bios extension core functions standards http://www.vesa.org

5. Dot Matrix Chinese Character Display (Little Tiger) (net text, pure C Forum (http://purec.binghua.com) has been reproduced)