问题[c](coding)

我正在尝试制作自己的操作系统，但目前遇到了一个小问题。我的欢迎消息无法在终端中加载。

除此之外，一切似乎都运行良好（我不确定是否还有其他错误）

以下是 QEMU 运行后显示的内容

make clear
make 
make run

这是我的档案，供参考。

内核

/* kernel.c - Main kernel entry point */

/* Video memory address */
#define VIDEO_MEMORY 0xB8000
/* Color: white on black */
#define COLOR 0x0F

/* Function to write a character to video memory */
void putchar(char c, int x, int y) {
    unsigned char *video_memory = (unsigned char*)VIDEO_MEMORY;
    int offset = (y * 80 + x) * 2;
    video_memory[offset] = c;
    video_memory[offset + 1] = COLOR;
}

/* Function to clear the screen */
void clear_screen() {
    unsigned char *video_memory = (unsigned char*)VIDEO_MEMORY;
    for(int i = 0; i < 80 * 25 * 2; i += 2) {
        video_memory[i] = ' ';
        video_memory[i + 1] = COLOR;
    }
}

/* Function to print a string */
void print_string(const char *str, int x, int y) {
    int i = 0;
    while(str[i] != '\0') {
        putchar(str[i], x + i, y);
        i++;
    }
}

/* Main kernel function */
void kernel_main() {
    // Clear screen
    
    clear_screen();
    // Display a welcome message
    print_string("NOX OS Kernel Loaded Successfully!", 20, 10);
    print_string("Welcome to the dark side...", 25, 12);
    
    // Halt the CPU
    while(1) {
        __asm__ volatile("hlt");
    }
}

链接器.ld

ENTRY(_start)

SECTIONS {
    . = 0x1000;    /* Match the address in the bootloader */
    
    .text : {
        *(.text)
    }
    
    .data : {
        *(.data)
    }
    
    .bss : {
        *(.bss)
    }
}

启动文件

; boot.asm - A simple bootloader
[bits 16]
[org 0x7c00]

; Set up segments
cli
mov ax, 0
mov ds, ax
mov es, ax
mov ss, ax
mov sp, 0x7c00
sti

; Display a message
mov si, boot_message
call print_string

; Load the kernel from disk
mov ah, 0x02    ; BIOS read sector function
mov al, 15      ; Number of sectors to read (adjust as needed)
mov ch, 0       ; Cylinder number
mov cl, 2       ; Sector number (sectors start from 1, bootloader is at 1)
mov dh, 0       ; Head number
mov dl, 0       ; Drive number (0 = floppy disk)
mov bx, 0x1000  ; Memory location to load the kernel
int 0x13        ; Call BIOS interrupt
jc disk_error   ; Jump if error (carry flag set)

; Switch to protected mode
cli                    ; Disable interrupts
lgdt [gdt_descriptor]  ; Load GDT

; Set protected mode bit
mov eax, cr0
or eax, 0x1
mov cr0, eax

; Far jump to 32-bit code
jmp CODE_SEG:protected_mode_entry

disk_error:
    mov si, disk_error_msg
    call print_string
    jmp hang

; Infinite loop for when we're done
hang:
    jmp hang

; Print string routine
print_string:
    lodsb
    or al, al
    jz done
    mov ah, 0x0E
    int 0x10
    jmp print_string
done:
    ret

; Global Descriptor Table
gdt_start:
    ; Null descriptor
    dd 0x0
    dd 0x0
    
    ; Code segment descriptor
    dw 0xffff    ; Limit (bits 0-15)
    dw 0x0000    ; Base (bits 0-15)
    db 0x00      ; Base (bits 16-23)
    db 10011010b ; Access byte
    db 11001111b ; Flags and Limit (bits 16-19)
    db 0x0       ; Base (bits 24-31)
    
    ; Data segment descriptor
    dw 0xffff    ; Limit 
    dw 0x0000    ; Base (bits 0-15)
    db 0x00      ; Base (bits 16-23)
    db 10010010b ; Access byte
    db 11001111b ; Flags and Limit
    db 0x0       ; Base (bits 24-31)
gdt_end:

gdt_descriptor:
    dw gdt_end - gdt_start - 1  ; GDT size
    dd gdt_start                ; GDT address

; Constants
CODE_SEG equ 0x08
DATA_SEG equ 0x10

; Messages
boot_message db 'NOX OS Booting...', 0
disk_error_msg db 'Error loading kernel!', 0

[bits 32]
protected_mode_entry:
    ; Set up segment registers for protected mode
    mov ax, DATA_SEG
    mov ds, ax
    mov es, ax
    mov fs, ax
    mov gs, ax
    mov ss, ax
    
    ; Set up a stack
    mov esp, 0x90000
    
    ; Far jump to the kernel using a code segment selector
    jmp CODE_SEG:0x1000

; Padding and boot signature
times 510-($-$$) db 0
dw 0xAA55

入口文件

; entry.asm - Assembly entry point that calls our C kernel
[bits 32]
[global _start]
[extern kernel_main]  ; Make sure this matches your C function name

section .text
_start:
    ; We're already in protected mode, skip trying to use BIOS interrupts
    
    ; Show a debug character at position 3
    mov byte [0xB8004], 'E'
    mov byte [0xB8005], 0x07
    
    ; Set up kernel stack
    mov esp, kernel_stack_top
    
    ; Call the C kernel main function
    call kernel_main
    
    ; Kernel should never return, but if it does:
    cli                 ; Disable interrupts
    hlt                 ; Halt the CPU
    jmp $               ; Infinite loop
    
; Reserve space for the kernel stack
section .bss
align 16
kernel_stack_bottom:
    resb 16384  ; 16 KB for kernel stack
kernel_stack_top:

Makefile

# Compiler settings
CC = x86_64-elf-gcc
CFLAGS = -m32 -nostdlib -nostdinc -fno-builtin -fno-stack-protector -nostartfiles -nodefaultlibs -Wall -Wextra -c
ASM = nasm
ASMFLAGS = -f elf32
LD = x86_64-elf-ld
LDFLAGS = -T src/kernel/linker.ld -m elf_i386

# Directories
SRC_DIR = src
BUILD_DIR = build

# Files
BOOT_SRC = $(SRC_DIR)/boot/boot.asm
KERNEL_ENTRY = $(SRC_DIR)/kernel/entry.asm
KERNEL_SRC = $(SRC_DIR)/kernel/kernel.c
BOOT_BIN = $(BUILD_DIR)/boot.bin
KERNEL_OBJ = $(BUILD_DIR)/kernel.o
ENTRY_OBJ = $(BUILD_DIR)/entry.o
KERNEL_BIN = $(BUILD_DIR)/kernel.bin
OS_IMAGE = $(BUILD_DIR)/nox-os.img

# Build rules
all: $(OS_IMAGE)

$(BOOT_BIN): $(BOOT_SRC)
    $(ASM) -f bin $< -o $@

$(ENTRY_OBJ): $(KERNEL_ENTRY)
    $(ASM) $(ASMFLAGS) $< -o $@

$(KERNEL_OBJ): $(KERNEL_SRC)
    $(CC) $(CFLAGS) $< -o $@

$(KERNEL_BIN): $(ENTRY_OBJ) $(KERNEL_OBJ)
    $(LD) $(LDFLAGS) -o $@ $^

$(OS_IMAGE): $(BOOT_BIN) $(KERNEL_BIN)
    dd if=/dev/zero of=$@ bs=512 count=2880
    dd if=$(BOOT_BIN) of=$@ conv=notrunc
    # Ensure the kernel is properly aligned at sector 2
    dd if=$(KERNEL_BIN) of=$(OS_IMAGE) seek=1 conv=notrunc bs=512

run: $(OS_IMAGE)
    qemu-system-i386 -fda $(OS_IMAGE) -boot a -monitor stdio -d int -no-reboot

clean:
    rm -rf $(BUILD_DIR)/*
    mkdir -p $(BUILD_DIR)

尝试增加读取的扇区boot.asm，但也没有用

typedef struct 
{
    WindowData data;
    bool vsync;
} Window;

typedef struct
{
    Window window;
    GLFWwindow *native_window;
} WindowsWindow;

Window *windowCreate(const WindowProperties props, Handle id)
{
    WindowsWindow *windows_window = malloc(sizeof(WindowsWindow));
    *windows_window = windowswindowCreate(props);
    glfwSetWindowUserPointer(windows_window->native_window, &windows_window->window.data);
    Window *window = (Window *)windows_window;
    window->data.id = id;
    return window;
}

void windowSetContextCurrent(Window *window)
{
    //log_info("Window Context current, %s", window->data.props.name);
    glfwMakeContextCurrent(((WindowsWindow *)window)->native_window);
}

所以这是一个小片段，希望能传达我之前所做的事情。我将特定于平台的窗口转换为通用窗口指针，然后在需要时将通用指针转换为特定于平台的指针以访问其特定于平台的数据（当前只是本机窗口），现在我遇到了对齐问题，特别是在我的 Nuklear GUI 层中，导致删除窗口时出错，窗口的 ID 现在访问窗口的宽度而不是窗口 ID（它在我的所有窗口数组中的索引），所以我访问 800 处的索引而不是 0。

因此，我们学到的教训是不要让指针指向不同类型的指针（也许有些用例很好，但绝对不是在这里）。有没有更好的方法来做到这一点？

我正在学习 C 语言，并试图了解 scanf 的工作原理。我无法理解一些术语：“输入项”、“初始子序列”、“匹配序列”等术语。 我正在阅读此https://pubs.opengroup.org/onlinepubs/9699919799/functions/scanf.html。它说：

输入项应定义为输入字节的最长序列（最多可达任何指定的最大字段宽度，可以根据转换说明符以字符或字节为单位来衡量），它是匹配序列的初始子序列。

假设格式为 i ，标准输入为4.5，其中%d表示初始子序列，匹配序列又是什么？输入项又是什么？

我认为输入项与该说明符相对应，即对于%d ，相应的符号是数字（可能是开头的 + - 符号），但随后它说：

除 % 转换说明符的情况外，输入项（或在 %n 转换说明的情况下，输入字节数）应转换为适合转换字符的类型。如果输入项不是匹配的序列，则转换说明的执行失败；

即输入项可能不对应，这意味着它不只由与说明符相对应的符号组成。

那么，您能给我解释一下这些术语吗？告诉我我是否在这里寻找 C 函数的文档？哪些网站是阅读 C 函数文档的最佳地点？

我想知道如何使用 c 在 Windows 控制台中“制作动画”。

我不确定我必须用谷歌搜索哪些提示/关键词才能找到我想要的答案。

这只是让我了解 c 和控制台的一个项目，因此效率和优化对我来说还不是真正关心的问题。我通常使用高级语言，主要是 oop。

我现在只是在嵌套循环中使用 printf() 来绘制“框架”。

我想要的是用新的线条“替换”已打印的线条，而不是将我的“框架”打印在彼此下方。

我想从父进程启动一个可执行文件。等到该进程完成，然后读回它写入 stdout 的内容。事实证明，您不能等待程序完成然后读取 FILE* 流，因为等待它完成意味着调用 pclose(FILE*)，到那时文件流将被销毁。在 Windows 文档中，它说要这样做：

char psBuffer[128];
    FILE* pPipe;

    /* Run DIR so that it writes its output to a pipe. Open this
     * pipe with read text attribute so that we can read it
     * like a text file.
     */

    if ((pPipe = _popen("dir *.c /on /p", "rt")) == NULL)
    {
        exit(1);
    }

    /* Read pipe until end of file, or an error occurs. */

    while (fgets(psBuffer, 128, pPipe))
    {
        puts(psBuffer);
    }

    int endOfFileVal = feof(pPipe);
    int closeReturnVal = _pclose(pPipe);

    if (endOfFileVal)
    {
        printf("\nProcess returned %d\n", closeReturnVal);
    }
    else
    {
        printf("Error: Failed to read the pipe to the end.\n");
    }

它打开管道，然后立即从流中读取。由于读取是在启动子进程后立即执行的，所以它很可能会读取流，但流为空或到达文件末尾，这种情况不是吗？为什么这是有效的？

我想使用 OpenMP 中的包容性扫描操作来实现一个算法。下面是我尝试这样做的描述，但未能获得比温和的加速更多的效果。

包含运算定义如下：对于输入向量，[x1,x2,x3,x4]它输出部分和的序列[x1, x1+x2, x1+x2+x3, x1+x2+x3+x4]。这是一个高度可并行化的操作，表面上看，这已经在 OpenMP 中得到了很好的实现。

我查看了以下参考资料：https://theartofhpc.com/pcse/omp-reduction.html#Scanprefixoperations （手册参考https://www.openmp.org/spec-html/5.0/openmpsu45.html#x68-1940002.9.6现在对我来说似乎太神秘了）

artofhpc 网站说，reduction 子句得到了一个修饰语inscan：

#pragma omp parallel for reduction(inscan,+:sumvar)`

在并行循环的主体中，有一个扫描指令，允许您存储部分结果。对于包含性扫描，reduction 变量在扫描指令之前更新：

  sumvar // update
#pragma omp scan inclusive(sumvar)
  partials[i] = sumvar

我尝试遵循相同的语法，以测量与标准串行缩减相比的性能，结果令人非常失望。我的代码位于文章底部。

在代码中，我只是做了一个简单的测试，考虑一个由区间 [-1,1] 中的随机值组成的 9000 万个非常大的向量，并使用越来越多的线程对其进行扫描并测量加速比。这是我的结果（我在重复运行时得到了相同的答案）。我的笔记本电脑 CPU 有 16 个硬件线程，但总体加速比令人失望，只有 1.36。（我本来期望会有更大的加速比！）

我使用 OpenMP 语法进行缩减的方式有问题吗？

➜  Desktop gcc -fopenmp scantest.c  && ./a.out

NumThreads  Speedup
1        0.458
2        1.173
3        1.424
4        1.686
5        1.635
6        1.501
7        1.522
8        1.499
9        1.455
10       1.416
11       1.395
12       1.393
13       1.352
14       1.336
15       1.353
16       1.357

#include<stdio.h>
#include<omp.h>
#include<math.h>
#include<stdlib.h>
#include<assert.h>

int main(int argc, char** argv){

  int N = 9e7;     // vector size 
  double* x;                   // vector to reduce
  double* partials_s;          // vector to scan into
  double* partials_p;          // vector to scan into
  
  double end, start;           // timing variables
  double sumvar;
  
  int tmax = argc>1? atoi(argv[1]):35;
  int threadcount ;

  // Allocate space for all vectors
  x           = (double*) malloc(sizeof(double)*N);
  partials_s  = (double*) malloc(sizeof(double)*N);
  partials_p  = (double*) malloc(sizeof(double)*N);
    
  // Populate the input vectors
  for(int i=0 ; i<N ; ++i){
    x[i] = -1+2.0*rand()/(double)RAND_MAX;
    partials_s[i] = 0.0;
    partials_p[i] = 0.0;
  }

  //-----------------------------------------
  // Serial inclusive scan
  //-----------------------------------------
  start = omp_get_wtime(); 
  sumvar = 0.0;
  for(int i=0 ; i<N ; ++i){
      sumvar += x[i];
      partials_s[i] = sumvar;
  }
  end = omp_get_wtime();
  double stime = end-start; // Time to run the serial code


  //-----------------------------------------------------------------------------
  // Performance of parallel inclusive scan. Print ratio of serial/parallel time
  //----------------------------------------------------------------------------
  printf("\nNumThreads  Speedup \n");
  for(threadcount=1;threadcount<=tmax;++threadcount){

    start = omp_get_wtime();

    sumvar = 0.0;
    #pragma omp parallel for num_threads(threadcount) reduction(inscan,+:sumvar)
    for(int i=0 ; i<N ; ++i){

      sumvar = sumvar + x[i]; // updating the value of sumvar
      #pragma omp scan inclusive(sumvar)
      partials_p[i] = sumvar;
    }
    end = omp_get_wtime();
    double ptime = end-start;

    printf("%d \t %.3f\n",threadcount,stime/ptime);

  }

  //for(int i=0 ; i<N ; ++i){
  //  printf("%.4f  %.4f\n", partials_s[i], partials_p[i]);
  //}

  // Deallocate
  free(x);
  free(partials_s);
  free(partials_p);
  
  return 0;
}

我有以下 C 代码，在 之后从父进程和子进程写入文件fork()。但是， 中的输出testfile.txt有时会损坏或出现意外顺序。

我附上了代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

int main() {
    int fd = open("testfile.txt", O_WRONLY | O_CREAT, 0644);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    if (fork() == 0) { 
        // Child process
        write(fd, "Child\n", 6);
        close(fd);
    } else {
        // Parent process
        write(fd, "Parent\n", 7);
        close(fd);
    }

    return 0;
}

问题：

• 文件有时包含"Child\nParent\n"，有时包含"Parent\nChild\n"
• 在某些情况下，输出被损坏或混杂
• 我期望每个过程单独写入，但它们似乎互相干扰

问题：

1. 为什么会发生这种情况？
2. 我如何确保每个进程的写入正确且独立？

设想

我遇到了一个奇怪的错误，当我向代码中添加一个随机变量时，它会改变输出。我弄清楚了导致问题的原因，但我并不完全确定它为什么会导致问题。

该代码旨在使用Luhns 算法验证信用卡号。它是 edX CS50 课程的一部分，但我决定尝试不使用他们定制的库，以便尽可能多地学习。

我遇到的问题是，如果我按原样运行下面的代码，那么答案就会出错（即在整数输出后附加“9”）。现在，如果我取消注释int random_integer = 0; 或 char random_character = 'M';，则输出将完全按预期工作。

• 错误的输出（留下那些随机变量的注释）：209
• 正确的输出（取消注释其中一个（或两个）随机变量）：20

奇怪的是，我注意到如果我改为char sum_to_str[3];，char sum_to_str[10];问题就完全消失了。

请让我知道您的想法，因为我对 C 还不太熟悉，并且有兴趣了解其中的细微差别。

代码

#include <stdio.h> // For Standard Input/Output
#include <stdlib.h> // For the atoi() function
#include <string.h> // For the strchr() and strlen() functions

// This value is the length plus one
#define MAX_INPUT_LENGTH 255

int main(void) {
    char user_input[MAX_INPUT_LENGTH];
    char *p;

    // Output CLI instructions
    printf("Welcome to the Credit Card Validator!!\n");
    printf("INSTRUCTIONS: At the prompt, please provide a CC number.\n");
    printf("NOTES ON LENGTH: Visa -> 13 || 16, AmEx -> 15 and MC -> 16\n");

    // Algorithm
    char example_card_num[] = "4003600000000014";

    // Check the length
    int card_num_length = strlen(example_card_num);

    int skip_flag = 0;
    int sum_of_values = 0;
    char value_at_index;
    char str_of_evens[20];
    for (int i = card_num_length - 1; i >= 0; i--) {
        char sum_to_str[3];
        switch (skip_flag) {
            case 0:
                // Add 'odd' values together
                value_at_index = example_card_num[i];
                sum_of_values = sum_of_values + atoi(&value_at_index);

                // Toggle flag
                skip_flag = 1;
                break;
            case 1:
                // Add 'even' values together (with multiplier)
                value_at_index = example_card_num[i];

                // 1. Convert each str to int
                // 2. Multiply by two
                // 3. Convert back to str in new variable
                sprintf(sum_to_str, "%d", (atoi(&value_at_index) *2));

                // Concatenate each substring to a new string
                strcat(str_of_evens, sum_to_str);
                 
                // Toggle flag
                skip_flag = 0;
                break;
        }
    }

    // int random_integer = 0;
    // char random_character = 'M';

    char value_at_index_two;
    for (int i = 0; i < strlen(str_of_evens); i++) {
        value_at_index_two = str_of_evens[i];
        sum_of_values = sum_of_values + atoi(&value_at_index_two);
    }

    printf("~~~~~~~~~~~\n");
    printf("Sum of Values 01: %d\n", sum_of_values);

    // Terminate the program
    return 0;
}

我尝试了以下操作：

• 注释/取消注释int random_integer = 0;然后重新编译
• 添加char random_character = 'M';然后将其切换为注释并重新编译
• 修改char sum_to_str[3];为char sum_to_str[3];

我还尝试稍微改变输入（即example_card_num[]），以确定是否有东西抛出了任意的“9”或附加的数字是否发生了变化，事实确实如此。

在学习宏的工作原理时，我尝试定义一个适用于不同数据类型的宏，而不必定义多种类型。我曾经_Generic让这项任务变得更容易。然而，在多次更改后，它仍然不起作用，于是我让 deepseek 来解决这个问题，最终我得到了这个：

#define FOO(var) _Generic((var), \
    int:    printf(#var " = %d\n", (int)(var)), \
    double: printf(#var " = %lf\n", (double)(var)), \
    long:   printf(#var " = %ld\n", (long)(var)), \
    char:   printf(#var " = '%c'\n", (char)(var)), \
    float:  printf(#var " = %f\n", (float)(var)), \
    default:printf(#var " = unknown type\n"))

int main(void) {
    int a = 3;
    FOO(a); // correctly prints "a = 3"
}

在 cpp-reference 和 SO 中的其他代码示例中，我从未见过有人必须进行类型转换才能使其工作。删除类型转换 (... int: printf(#var " = %d\n",(var)), \...) 会显示警告“格式指定类型 'long' 但参数类型为 'int'”，并给出编译警告（-Wall已启用）：

ue_05.c: In function ‘main’:
ue_05.c:47:14: warning: format ‘%lf’ expects argument of type ‘double’, but argument 2 has type ‘int’ [-Wformat=]
   47 |         FOO(a);
      |              ^
ue_05.c:27:25: note: in definition of macro ‘FOO’
   27 |         double: printf(#var " = %lf\n", (var)), \
      |                         ^~~
ue_05.c:47:14: warning: format ‘%ld’ expects argument of type ‘long int’, but argument 2 has type ‘int’ [-Wformat=]
   47 |         FOO(a);
      |              ^
ue_05.c:28:25: note: in definition of macro ‘FOO’
   28 |         long:   printf(#var " = %ld\n", (var)), \
      |                         ^~~
ue_05.c:47:14: warning: format ‘%f’ expects argument of type ‘double’, but argument 2 has type ‘int’ [-Wformat=]
   47 |         FOO(a);
      |              ^
ue_05.c:30:25: note: in definition of macro ‘FOO’
   30 |         float:  printf(#var " = %f\n", (var)), \

我一直没能找出为什么这里需要类型转换并且 deepseek 也没能解释清楚。

为什么这里需要类型转换以及它在哪里被记录下来？

在许多情况下，我们编译 C 程序并执行二进制文件时，无需担心原始源文件是否发生变化。不过，我很好奇：

正在运行的 C 程序是否可以检测其自身的.c源文件在编译后是否被修改？

需要考虑的一些限制：

• 程序应该检查其源文件中的修改，而不仅仅是二进制文件（a.out）
• 它不应该依赖于外部工具，例如md5sum或stat通过system()调用。
• 该解决方案应适用于常见的操作系统（Linux/Windows）
• 它应该纯粹用 C 来完成，使用标准或广泛可用的系统库。

这是否需要在运行时读取源文件并比较时间戳或哈希值，或者是否有更优雅的方法来实现这一点？