Question

我一直在用C编写内核。我一直在使用GCC交叉编译器，在Windows系统上编写并以16位实模式为目标。我没有可用的C库来编写内核。我已经开始使用一些代码来假设将字符直接打印到屏幕上。这是kernel.c：

中的函数

int main()
{
  char *src = (char *)0xB8000000L;
  *src = 'M';
  src += 2;
  *src = 'D';
  return 0;
}

我使用参数-m16使用GCC编译了我的代码，以生成将以实模式运行的代码。我使用这些命令生成kernel.bin：

gcc -ffreestanding -c -m16 kernel.c -o kernel.o
ld -Ttext 0x10000 -o kernel.pe kernel.o
objcopy -O binary kernel.pe kernel.bin

Stack Overflow用户Michael Petch解决了我的linker problem，但评论说代码本身不正确。他发表了这样的评论：

除链接器问题外，您是否尝试将旧的TurboC / MSVC 16位代码转换为GCC？我发现（char *）0xB8000000L可疑。如果它是一个真正的16位C编译器，它可能是好的，如果它是（char far *）0xB8000000L。 GCC不是一个真正的16位C编译器，并没有旧式远指针的概念。所以，即使你得到这个代码来编译，这可能不会做你认为它做的事情，我假设从GCC的-m16选项你正在尝试创建一个实模式16位内核（而不是受保护的）模式一）？

我一直在尝试在C中为我自己的操作系统实现自己的printf类功能。我上面提供的代码只是我理解的一小部分。我在程序集中创建了一个bootloader（8086）。

迈克尔是否正确？如果是，我该如何解决此问题并直接写入0xb8000的视频内存？

Answer 1

如果您打算将{em> GCC 与-m16一起使用，那么它会自动假设您将在80386+上运行。我无法强调这一点，使用 GCC 创建16位代码充满了陷阱。你选择将你的内核放在内存中的0x10000会使情况变得更糟。 0x10000不能表示为16位偏移量，这可能会导致 GCC 发出可能无效的代码，尤其是如果您想要使用-O1打开优化， -O2，-O3等。即使访问全局变量也可能导致问题！

强烈推荐（几乎需要避免大多数麻烦）：如果将内核及其数据放在第一个64kb的内存中，可能会遇到的问题更少。内存地址0x00520的原点位于BIOS数据区域和低内存的保留区域之上。

预先警告： GCC -m16定位实模式按您的风险使用。你也可能失去理智。使用flat memory model（从0扩展到0xffffffff）将处理器置于32位保护模式，其中 CS = DS = ES 非常适合 GCC

此代码假设您不在unreal mode，尽管您的系统可能处于该模式。

GCC 假定 CS = DS = ES ，并且内存模型是扁平的。更改 ES 通常不是一个好主意。您可以使用 ES 进行保存，工作并将其全部还原，而无需干预 C 代码。由于 GCC 需要80386，我们可以使用其他段寄存器之一： FS 和 GS 。在此示例中，我们将使用 FS 。

另一个先决条件是您了解Real Mode Segmentation。我假设你已经创建了一个bootloader。物理内存地址的计算是：

Physical memory address = (segment << 4) + offset

Text mode (color)视频内存位于物理地址0xb8000。该内存的基数可以表示为一个段：偏移对0xb800：0x0000，因为：

(0xb800 << 4) + 0x0000 = 0xb8000

可见屏幕上的每个单元格都是WORD（16位）。 WORD 的高8位是属性，下面是链接中详细说明的字符。调色板在此Wiki page中进行了描述。

如果我们使用 FS 作为我们的片段，我们可以将其设置为0xb800并用它来引用视频内存。由于您的代码最终可能会使用 FS 来处理各种事情，因此我们会使用一些内联汇编程序代码保存它，在视频内存上运行并恢复 FS 以前是什么。

由于我使用内联汇编程序，您可能希望查看Peter Corde关于该主题的useful links列表。

将上述内容考虑在内的代码，并提供了一种连续更新屏幕的机制，通过我们设置为0xb800的 FS 段寄存器来定义属性。

代码的数量超出了您的喜好，但我希望展示的不仅仅是输出单个字符。代码注释可以帮助您继续前进。

#include <stdint.h>

/* use regparm(3) to use convention where first three
 * integer sized parameters are passed in registers (EAX, EDX, ECX) rather
 * than the stack. regparm(0) is default CDECL stack based
 * parameter passing. regparm(3) is generally faster overall, compared
 * to passing all parameters on the stack. Internally, the Linux kernel 
 * uses this convention to reduce stack overhead when functions
 * are called across different kernel modules.
 */
#define fastcall __attribute__((regparm(3)))
#define asmlinkage __attribute__((regparm(0)))

/* Global functions that will be exported */
extern fastcall void dispchar(uint16_t celldata, uint16_t offset);
extern fastcall void dispstring(const char *outstring, uint8_t attr,
                                uint16_t offset);
extern fastcall void dispchar_nofsupd(uint16_t celldata, uint16_t offset);
extern fastcall void dispstring_nofsupd(const char *outstring, uint8_t attr,
                                        uint16_t offset);
extern fastcall uint32_t getset_fs(uint32_t segment);
extern fastcall void set_fs(uint32_t segment);
extern fastcall uint32_t set_videomode_fs(void);
static inline uint16_t
tm_rowcol_to_vidoffset(uint16_t row, uint16_t col, uint16_t numcols);
static inline uint16_t
tm_charattr_to_celldata(uint8_t ochar, uint8_t attr);

/*----------------------------------------------------------*/

#define COLSPERROW 80
#define ROW  3
#define COL  40
#define RED_ON_BLACK     4 /* attribute= Red character on black background */
#define MAGENTA_ON_BLACK 5 /* attribute= Magenta character on black background */

/* Color text mode memory segment */
#define VIDEO_SEG 0xb800

/* Place main before all other code */
int
_main()
{
    /* Set FS to video mode segment and save previous value of FS */
    uint32_t oldfs = set_videomode_fs();
    dispchar_nofsupd(tm_charattr_to_celldata('A', RED_ON_BLACK),
                     tm_rowcol_to_vidoffset(ROW, COL, COLSPERROW));
    dispchar_nofsupd(tm_charattr_to_celldata('B', RED_ON_BLACK),
                     tm_rowcol_to_vidoffset(ROW, COL + 1, COLSPERROW));
    dispchar_nofsupd(tm_charattr_to_celldata(' ', RED_ON_BLACK),
                     tm_rowcol_to_vidoffset(ROW, COL + 2, COLSPERROW));
    dispstring_nofsupd("Hello World", RED_ON_BLACK,
                       tm_rowcol_to_vidoffset(ROW, COL + 3, COLSPERROW));

    /* Restore FS to original value when finished doing video mode work */
    set_fs(oldfs);

    /* Display Hello World using version dispstring
     * that saves/restores FS automatically */
    dispstring("Hello World", MAGENTA_ON_BLACK,
               tm_rowcol_to_vidoffset(ROW+1, COL + 3, COLSPERROW));

    return 0;
}


/* Convert Text Mode(TM) row, col, numcols
 * to a video offset. numcols is the number of columns
 * per row. Return value is a BYTE offset (not WORD)
 */
static inline uint16_t
tm_rowcol_to_vidoffset(uint16_t row, uint16_t col, uint16_t numcols)
{
    return ((row * numcols + col) * 2);
}

static inline uint16_t
tm_charattr_to_celldata(uint8_t ochar, uint8_t attr)
{
    return (uint16_t) (attr << 8) | (uint8_t) ochar;
}

/* Display character with FS change */
fastcall void
dispchar(uint16_t celldata, uint16_t offset)
{
    uint32_t oldfs = set_videomode_fs();
    dispchar_nofsupd(celldata, offset);
    set_fs(oldfs);
}

/* Display character with no FS change */
fastcall void
dispchar_nofsupd(uint16_t celldata, uint16_t offset)
{
    __asm__ ("movw %w[wordval], %%fs:%[memloc]\n\t"
             :
             :[wordval]"ri"(celldata),
              [memloc] "m"(*(uint32_t *)(uint32_t)offset)
              :"memory");
}

/* Set FS segment and return previous value */
fastcall uint32_t
getset_fs(uint32_t segment)
{
    uint32_t origfs;
    __asm__ __volatile__("mov %%fs, %w[origfs]\n\t"
                         "mov %w[segment], %%fs\n\t"
                         :[origfs] "=&rm"(origfs)
                         :[segment] "rm"(segment));
    return origfs;
}

/* Set FS segment */
fastcall void
set_fs(uint32_t segment)
{
    __asm__("mov %w[segment], %%fs\n\t"
            :
            :[segment]"rm"(segment));
}

/* Set FS to video mode segment 0xb800 */
fastcall uint32_t
set_videomode_fs(void)
{
    return getset_fs(VIDEO_SEG);
}

/* Display string with FS change */
fastcall void
dispstring(const char *outstring, uint8_t attr, uint16_t offset)
{
    uint32_t oldfs = set_videomode_fs();
    dispstring_nofsupd(outstring, attr, offset);
    set_fs(oldfs);
}

/* Display string with FS change */
fastcall void
dispstring_nofsupd(const char *outstring, uint8_t attr, uint16_t offset)
{
    const char *curchar = outstring;
    int i = 0;

    for (; *curchar; curchar++, i++)
        dispchar_nofsupd(tm_charattr_to_celldata(*curchar, attr),
                         offset + i * 2);
}

Windows上GCC的链接器脚本

在Windows下使用 GCC 时，您的kernel.bin可能会比您预期的要大。这是因为 GCC 正在使用的默认对齐规则。以下linker script可能有助于缩小尺寸：

ENTRY(__main);
OUTPUT(i386pe);

SECTIONS
{
    __kernelbase = 0x520;
    . = __kernelbase;

    .text : SUBALIGN(4) {
        *(.text.st);
        *(.text);
    }

    .data : 
        SUBALIGN(4) {
        __data_start = .;
        *(.rdata*);
        *(.data);
        __data_end = .;
        __bss_start = .;
        *(COMMON);
        *(.bss);
        __bss_end = .;
    }
}

此脚本设置为ORG 0x520（不是0x10000）。如前所述，强烈建议您不要使用0x10000的原点，因为您使用的是16位 GCC 生成的代码。将链接描述文件命名为linker.ld，然后您可以使用这些命令汇编并链接内核：

gcc -ffreestanding -c -m16 kernel.c -o kernel.o -O3
ld -o kernel.pe kernel.o -Tlinker.ld
objcopy -O binary kernel.pe kernel.bin

您必须修改引导加载程序，以便从内核0x520开始将内核扇区读入内存。

使用简单的引导加载程序和使用提供的代码/链接器脚本构建的内核，这就是 Bochs 在运行时显示的内容：

查看一些生成的代码

函数main的前几行保存当前 FS 寄存器，将 FS 设置为视频段0xb800并输出3个字符：

int
_main()
{
    /* Set FS to video mode segment and save previous value of FS */
    uint32_t oldfs = set_videomode_fs();
    dispchar_nofsupd(tm_charattr_to_celldata('A', RED_ON_BLACK),
                     tm_rowcol_to_vidoffset(ROW, COL, COLSPERROW));
    dispchar_nofsupd(tm_charattr_to_celldata('B', RED_ON_BLACK),
                     tm_rowcol_to_vidoffset(ROW, COL + 1, COLSPERROW));
    dispchar_nofsupd(tm_charattr_to_celldata(' ', RED_ON_BLACK),
                     tm_rowcol_to_vidoffset(ROW, COL + 2, COLSPERROW));
    dispstring_nofsupd("Hello World", RED_ON_BLACK,
                       tm_rowcol_to_vidoffset(ROW, COL + 3, COLSPERROW));
    [code that prints strings has been snipped for brevity]
    set_fs(oldfs);

使用此objdump命令可以看到生成的代码：

objdump -Dx kernel.pe --no-show-raw-insn -mi8086 -Mintel

我的编译器（使用-O3优化）的英特尔语法输出如下：

00000520 <__main>:
 520:   push   esi                     ; Save register contents
 522:   mov    eax,0xb800
 528:   push   ebx                     ; Save register contents
 52a:   mov    si,fs                   ; Save old FS to SI                  
 52d:   mov    fs,ax                   ; Update FS with 0xb800 (segment of video) 
 52f:   mov    WORD PTR fs:0x230,0x441 ; 0x441 = Red on black Letter 'A'
                                       ; Write to offset 0x230 ((80*3+40)*2) row=3,col=40
 536:   mov    WORD PTR fs:0x232,0x442 ; 0x442 = Red on black Letter 'B'
                                       ; Write to offset 0x232 ((80*3+41)*2) row=3,col=41
 53d:   mov    WORD PTR fs:0x234,0x420 ; 0x420 = Red on black space char
                                       ; Write to offset 0x234 ((80*3+42)*2) row=3,col=42

这行 C 代码恢复 FS ：

 set_fs(oldfs);

稍后使用此说明：

 571:   mov    fs,si                   ; Restore original value previously saved in SI

我已使用注释对反汇编进行了注释，以显示每个 WORD 值是如何在视频显示内存中更新的。很多 C 代码行，但输出很简单。

在不使用C库

1 个答案:

Windows上GCC的链接器脚本

查看一些生成的代码