问题[c](coding)

我正在研究操作系统编程作业以了解管道。文本任务涉及使用正则表达式从 strace 输出中提取信息并统计系统调用执行时间。

但是，我遇到了时间计算不正确的问题。我怀疑 parse_strace_line 函数未能正确解析 strace 输出行，尤其是时间戳部分（例如 <0.000123>），导致统计信息中的时间值不正确或缺失。该函数可能无法正确处理行格式、行不完整等边缘情况，或者正则表达式模式可能无法准确捕获 strace 输出中的时间分量。

我的环境是在 WSL2 上运行的 Ubuntu。

以下是代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <regex.h>

#define MAX_SYSCALLS 1024  // Maximum distinct syscalls we can track
#define TOP_N 5            // Number of top results to display

/* Syscall tracking structure
 * name: syscall name (e.g., "open", "read")
 * time: accumulated time spent in this syscall (seconds)
 */
typedef struct {
    char name[64];
    double time;
} syscall_stat;

/* Main statistics container
 * stats: array of individual syscall metrics
 * count: number of unique syscalls tracked
 * total_time: sum of all syscall times for percentage calculation
 */
typedef struct {
    syscall_stat stats[MAX_SYSCALLS];
    int count;
    double total_time;
} syscall_stats;

/* Parse a line of strace output with timing information (-T option)
 * line: input string from strace output
 * syscall_name: output parameter for extracted syscall name
 * time: output parameter for extracted duration
 * Returns: 1 if successful, 0 if line doesn't contain timing info
 * 
 * Strace line format examples:
 * openat(AT_FDCWD, "/lib/libc.so.6", O_RDONLY|O_CLOEXEC) = 3 <0.000014>
 * read(0, "hello\n", 1024)               = 6 <0.000010>
 */
int parse_strace_line(char* line, char* syscall_name, double* time) {
    // Filter lines without timing information
    if (strstr(line, " = ") == NULL || strstr(line, "<") == NULL) {
        return 0;
    }

    // Regular expression pattern breakdown:
    // ^(\w+)       Capture group 1: syscall name at line start
    // \(.*?\)      Non-greedy match of arguments between parentheses
    // \s+=\s+.*?   Match return value portion
    // <(\d+\.?\d*)> Capture group 2: time value between <>
    regex_t regex;
    regcomp(&regex, "^(\\w+)\\(.*?\\)\\s+=\\s+.*?<(\\d+\\.?\\d*)>$", REG_EXTENDED);
    regmatch_t matches[3];  // Array for regex capture groups

    if (regexec(&regex, line, 3, matches, 0) != 0) {
        regfree(&regex);
        return 0;
    }

    // Extract syscall name from first capture group
    int name_len = matches[1].rm_eo - matches[1].rm_so;
    strncpy(syscall_name, line + matches[1].rm_so, name_len);
    syscall_name[name_len] = '\0';

    // Convert time string to double
    char* time_str = line + matches[2].rm_so;
    *time = atof(time_str);

    regfree(&regex);
    return 1;
}

/* Update statistics with new syscall data
 * stats: pointer to statistics container
 * name: syscall name to add/update
 * time: duration to accumulate
 * 
 * If the syscall already exists, we sum the time.
 * If new, we add it to the list (until MAX_SYSCALLS).
 */
void add_syscall(syscall_stats *stats, const char *name, double time) {
    // Safety check against array overflow
    if (stats->count >= MAX_SYSCALLS) {
        fprintf(stderr, "Warning: Reached maximum tracked syscalls (%d)\n", MAX_SYSCALLS);
        return;
    }

    // Check existing entries for duplicate syscall
    for (int i = 0; i < stats->count; i++) {
        if (strcmp(stats->stats[i].name, name) == 0) {
            stats->stats[i].time += time;
            stats->total_time += time;
            return;
        }
    }

    // Add new entry if space available
    if (stats->count < MAX_SYSCALLS) {
        strncpy(stats->stats[stats->count].name, name, sizeof(stats->stats[0].name));
        stats->stats[stats->count].time = time;
        stats->total_time += time;
        stats->count++;
    }
}

/* Display top N syscalls by accumulated time
 * stats: statistics container with all data
 * n: number of top results to show
 * 
 * Uses bubble sort for simplicity with small datasets.
 * Prints percentages relative to total tracked time.
 * Flushes output with nulls for clean pipe termination.
 */
void print_top_syscalls(syscall_stats *stats, int n) {
    if (stats->count == 0 || stats->total_time == 0) {
        fprintf(stderr, "Error: No valid syscall data to display\n");
        return;
    }

    // Simple O(n²) sort acceptable for MAX_SYSCALLS=1024
    for (int i = 0; i < stats->count - 1; i++) {
        for (int j = i+1; j < stats->count; j++) {
            // Swap if later entry has higher time
            if (stats->stats[j].time > stats->stats[i].time) {
                syscall_stat temp = stats->stats[i];
                stats->stats[i] = stats->stats[j];
                stats->stats[j] = temp;
            }
        }
    }

    // Determine number of results to display
    n = stats->count < n ? stats->count : n;
    for (int i = 0; i < n; i++) {
        double ratio = (stats->stats[i].time / stats->total_time) * 100;
        printf("%s (%d%%)\n", stats->stats[i].name, (int)ratio);
    }

    /* Null-terminate output for clean pipe communication
     * Some programs may read fixed buffer sizes - this ensures
     * we flush the pipe completely and avoid hanging readers */
    for (int i = 0; i < 80; i++) putchar('\0');
    fflush(stdout);
}

/* Main execution flow:
 * 1. Validate command line arguments
 * 2. Set up parent/child process communication
 * 3. Child: execute strace with command
 * 4. Parent: process and analyze strace output
 */
int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "Usage: %s COMMAND [ARGS...]\n", argv[0]);
        fprintf(stderr, "Example: %s ls -l\n", argv[0]);
        return 1;
    }

    // Create pipe for inter-process communication
    int pipefd[2];
    if (pipe(pipefd) == -1) {
        perror("Failed to create pipe");
        return 1;
    }

    pid_t pid = fork();
    if (pid == -1) {
        perror("Process fork failed");
        return 1;
    }

    if (pid == 0) { // Child process - execute strace
        // Redirect stdout to pipe write end
        close(pipefd[0]);
        dup2(pipefd[1], STDOUT_FILENO);
        close(pipefd[1]);

        // Build strace argument array:
        // strace -T [user command] [args...]
        char* strace_argv[argc + 2];
        strace_argv[0] = "/usr/bin/strace";
        strace_argv[1] = "-T";  // Enable timing reports
        for (int i = 1; i < argc; i++) {
            strace_argv[i+1] = argv[i];
        }
        strace_argv[argc+1] = NULL;  // NULL-terminate array

        // Execute strace with clean environment
        execve("/usr/bin/strace", strace_argv, (char *[]){ "PATH=/bin:/usr/bin", NULL });
        perror("Failed to execute strace");
        return 1;
    } else { // Parent process - analyze output
        close(pipefd[1]);  // Close unused write end
        syscall_stats stats = {0};  // Initialize all fields to zero

        char buffer[1024];
        char* line_start = buffer;
        ssize_t bytes_read;

        // Read output in chunks until EOF
        while ((bytes_read = read(pipefd[0], 
               line_start, 
               sizeof(buffer) - (line_start - buffer))) > 0) {
            // Null-terminate the received data
            buffer[bytes_read + (line_start - buffer)] = '\0';
            line_start = buffer;

            // Process complete lines (delimited by newlines)
            char* line_end;
            while ((line_end = strchr(line_start, '\n')) != NULL) {
                *line_end = '\0';  // Temporarily terminate at newline

                char syscall_name[64];
                double time;
                if (parse_strace_line(line_start, syscall_name, &time)) {
                    add_syscall(&stats, syscall_name, time);
                }

                line_start = line_end + 1;  // Move to next line
            }

            // Handle partial line remaining in buffer
            if (line_start != buffer) {
                size_t remaining = buffer + sizeof(buffer) - line_start;
                // Move partial line to buffer start for next read
                memmove(buffer, line_start, remaining);
                line_start = buffer + remaining;
            }
        }

        // Cleanup and display results
        close(pipefd[0]);
        wait(NULL);  // Wait for strace to terminate completely
        print_top_syscalls(&stats, TOP_N);
    }

    return 0;
}

这是要测试的命令行：

root@DimLights:/mnt/f/WSL/Data/OperatingSystems/2025/os2025/sperf# gcc -g -o sperf sperf.c -lm -lrt
root@DimLights:/mnt/f/WSL/Data/OperatingSystems/2025/os2025/sperf# ./sperf echo "Hello WSL"

execve("/bin/echo", ["echo", "Hello WSL"], 0x7ffe6258ee20 /* 1 var */) = 0 <0.000363>
brk(NULL)                               = 0x55d4dee1c000 <0.000104>
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f483b684000 <0.000137>
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory) <0.000115>
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3 <0.000133>
fstat(3, {st_mode=S_IFREG|0644, st_size=36191, ...}) = 0 <0.000115>
mmap(NULL, 36191, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f483b67b000 <0.000097>
close(3)                                = 0 <0.000079>
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3 <0.000108>
read(3, "\177ELF\2\1\1\3\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\220\243\2\0\0\0\0\0"..., 832) = 832 <0.000094>
pread64(3, "\6\0\0\0\4\0\0\0@\0\0\0\0\0\0\0@\0\0\0\0\0\0\0@\0\0\0\0\0\0\0"..., 784, 64) = 784 <0.000101>
fstat(3, {st_mode=S_IFREG|0755, st_size=2125328, ...}) = 0 <0.000096>
pread64(3, "\6\0\0\0\4\0\0\0@\0\0\0\0\0\0\0@\0\0\0\0\0\0\0@\0\0\0\0\0\0\0"..., 784, 64) = 784 <0.000088>
mmap(NULL, 2170256, PROT_READ, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7f483b469000 <0.000107>
mmap(0x7f483b491000, 1605632, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x28000) = 0x7f483b491000 <0.000117>
mmap(0x7f483b619000, 323584, PROT_READ, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1b0000) = 0x7f483b619000 <0.000099>
mmap(0x7f483b668000, 24576, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1fe000) = 0x7f483b668000 <0.000102>
mmap(0x7f483b66e000, 52624, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7f483b66e000 <0.000103>
close(3)                                = 0 <0.000104>
mmap(NULL, 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f483b466000 <0.000085>
arch_prctl(ARCH_SET_FS, 0x7f483b466740) = 0 <0.000049>
set_tid_address(0x7f483b466a10)         = 1543 <0.000319>
set_robust_list(0x7f483b466a20, 24)     = 0 <0.000098>
rseq(0x7f483b467060, 0x20, 0, 0x53053053) = 0 <0.000123>
mprotect(0x7f483b668000, 16384, PROT_READ) = 0 <0.000096>
mprotect(0x55d4de99a000, 4096, PROT_READ) = 0 <0.000093>
mprotect(0x7f483b6bc000, 8192, PROT_READ) = 0 <0.000103>
prlimit64(0, RLIMIT_STACK, NULL, {rlim_cur=8192*1024, rlim_max=RLIM64_INFINITY}) = 0 <0.000095>
munmap(0x7f483b67b000, 36191)           = 0 <0.000118>
getrandom("\xc0\x8d\xa3\xbc\x88\x59\xbb\xd3", 8, GRND_NONBLOCK) = 8 <0.000098>
brk(NULL)                               = 0x55d4dee1c000 <0.000113>
brk(0x55d4dee3d000)                     = 0x55d4dee3d000 <0.000097>
fstat(1, {st_mode=S_IFIFO|0600, st_size=0, ...}) = 0 <0.000092>
write(1, "Hello WSL\n", 10Received from pipe: Hello WSL
)             = 10 <0.000216>
close(1)                                = 0 <0.000165>
close(2)                                = 0 <0.000092>
exit_group(0)                           = ?
+++ exited with 0 +++
Total count is zero

以下是我尝试过的方法和预期结果：我使用 GDB 调试，发现 while ((line = strchr(line_start, '\n')) != NULL) 循环在测试命令时只运行了一次。我不明白为什么输出显示 +++ exited with 0 +++ 并且 Total count 为零。我还向 AI 寻求帮助，并修改了 parse_strace_line 函数和正则表达式模式的部分内容，但收效甚微。

实际发生的情况：统计数据仍然为空（总数为零），表明解析或数据提取失败。

我的期望：代码应该正确解析来自 strace 输出的系统调用时间戳，累积它们的时间，并计算每个调用的时间与总时间的比率。

作为一名学生，如果您能指出我的代码中的错误并解释如何正确读取系统调用时间并将其转换为比率，我将不胜感激。

我尝试PBS_MARQUEE在窗口中添加一个样式进度条，它确实在窗口中显示为一个正常的进度条，但当我尝试使用 使其移动时SendMessage（动画应该看起来像 Windows XP 启动屏幕上的进度条），它仍然像往常一样是一个灰色框。如果有人知道 WinAPI C 进度条的工作原理，能否请您说明如何为滚动进度条制作动画？

以下是正在创建的进度条的代码，并且可能使用以下动画SendMessage：

case WM_CREATE:
    INITCOMMONCONTROLSEX icc = {sizeof(INITCOMMONCONTROLSEX), ICC_PROGRESS_CLASS}
    InitCommonControlsEx(&icc);

    hwndPB = CreateWindowExA(0, PROGRESS_CLASS, NULL, 
        WS_CHILD | WS_VISIBLE | PBS_MARQUEE,
        50, 200, 400, 20, hwnd, NULL, 
        ((LPCREATESTRUCT)lParam)->hInstance, NULL);

    SendMessage(hwndPB, PBM_SETMARQUEE, 1, 1000);

    UpdateWindow(hwnd);
    break;

我有一个头文件，它引入了一个宏，该宏声明了一个 Stack 结构以及一些与该结构相关的函数。头文件 (Stack.h) 的内容如下所示：

#ifndef STACK_H
#define STACK_H

#include <stddef.h> // size_t
#include <malloc.h> // malloc(), calloc()

#define STACK_DEFAULT_GROWTH_FACTOR 2.0
#define STACK_REALLOC_FAIL -1

#define DECL_STACK(T, Id) \
  typedef struct Stack_##Id { \
    size_t capacity; \
    size_t size; \
    float growth_factor; \
    T *data; \
  } Stack_##Id; \
  \
  Stack_##Id* Stack_##Id##_New(size_t capacity) { \
    Stack_##Id *p = malloc(sizeof(Stack_##Id)); \
    if (!p) return NULL; \
    T *d = calloc(capacity, sizeof(T)); \
    if (!d) { \
      free(p); \
      return NULL; \
    } \
    p->capacity = capacity; \
    p->size = 0; \
    p->growth_factor = STACK_DEFAULT_GROWTH_FACTOR; \
    p->data = d; \
    return p; \
  } \
  \
  void Stack_##Id##_Free(Stack_##Id *stack) { \
    free(stack->data); \
    free(stack); \
  } \
  \
  void Stack_##Id##_Push(Stack_##Id *stack, const T item) { \
    if (stack->size >= stack->capacity) { \
      size_t new_capacity = (size_t)(stack->capacity * stack->growth_factor); \
      T *d = realloc(stack->data, new_capacity); \
      if (!d) { \
        free(stack); \
        exit(STACK_REALLOC_FAIL); \
        return; \
      } \
      stack->capacity = new_capacity; \
    } \
    stack->data[stack->size++] = item; \
  } \
  \
  T Stack_##Id##_Pop(Stack_##Id *stack) { \
    return stack->data[--(stack->size)]; \
  } \
  \
  T Stack_##Id##_Peek(const Stack_##Id *stack) { \
    return stack->data[stack->size - 1]; \
  }

#endif // STACK_H

我有一个 Main.c 文件，其中包含 Stack.h 和另一个名为 Some.h 的头文件。Some.h 还包含 Stack.h，以便使用上述宏来声明一个函数，该函数以某种方式利用已声明的堆栈结构。文件 Some.c 以最简单的形式提供了该函数的定义。我编译并尝试使用以下 makefile 链接该程序：

objects = Main.o Some.o
CC = gcc
flags = -Wall -Wextra

Some.o : Some.c Some.h Stack.h
    $(CC) $(flags) -c Some.c Some.h Stack.h 

Main.o : Main.c Some.h Stack.h
    $(CC) $(flags) -c Main.c Some.h Stack.h

Main : $(objects)
    $(CC) $(objects) -o Main

clean: Main
    rm $(objects)

以下是Main.c、Some.h和Some.c的内容：Main.c：

#include <stdio.h>
#include "Stack.h"
#include "Some.h"

#ifndef STACK_INT
#define STACK_INT
DECL_STACK(int, int);
#endif

int main() {
  Stack_int *stack = Stack_int_New(10);
  Stack_int_Push(stack, 100);
  printf("%d\n", Stack_int_Peek(stack));
  Stack_int_Pop(stack);
  Use_stack(stack);
  Stack_int_Free(stack);
  return 0;
}

一些.h：

#include "Stack.h"
#include <stdio.h>

#ifndef STACK_INT
#define STACK_INT
DECL_STACK(int, int);
#endif

int Use_stack(Stack_int *stack);

一些.c：

#include "Some.h"

int Use_stack(Stack_int *stack) {
  Stack_int_Push(stack, 1);
  printf("%d\n", Stack_int_Peek(stack));
  Stack_int_Push(stack, 2);
  printf("%d\n", Stack_int_Peek(stack));
  Stack_int_Pop(stack);
  return Stack_int_Pop(stack);
}

目标文件编译成功，但我在链接步骤中收到错误，指出函数 Stack_int_New()、Stack_int_Free() 等存在多个函数定义。只有函数存在多个定义，而结构 Stack_int 本身没有（这确实让我感到惊讶）。我期望在 DECL_STACK 宏周围插入的宏扩展保护将阻止多个宏扩展，从而阻止函数（和结构）重新定义。但这并没有发生。我尝试从 makefile 的编译配方中删除头文件，但没有帮助。无论有没有它们，命令都gcc Main.c/Some.c -E显示预处理器都会插入宏并将其扩展。如果我想在多个 .c 文件中包含我的 Stack.h 文件并使用相同的 Id 声明堆栈，即相同的结构和函数，但没有导致链接错误，我该如何防止多个宏扩展？

Open Group的文档中指出：

NAME
pthread_rwlock_wrlock, pthread_rwlock_trywrlock - lock a read-write lock object for writing

...

The pthread_rwlock_wrlock() and pthread_rwlock_trywrlock() functions may fail if:

...

[EDEADLK]
The current thread already owns the read-write lock for writing or reading.

但是，当我运行以下代码时：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>

int main()
{
    int error; 

    pthread_rwlock_t *mutex = (pthread_rwlock_t *)malloc(sizeof(pthread_rwlock_t));
    if (mutex == NULL) {
        perror("malloc");
        abort();
    }

    pthread_rwlockattr_t attr;

    error = pthread_rwlockattr_init(&attr);
    if (error != 0)
    {
        fprintf(stderr, "%s:%d: pthread_rwlockattr_init failed: %s", __FILE__, __LINE__, strerror(error));
        abort();
    }

    error = pthread_rwlock_init(mutex, &attr);
    if (error != 0)
    {
        fprintf(stderr, "%s:%d: pthread_rwlock_init failed: %s", __FILE__, __LINE__, strerror(error));
        abort();
    }
    
    error = pthread_rwlock_wrlock(mutex);
    if (error != 0)
    {
        fprintf(stderr, "%s:%d: pthread_rwlock_wrlock failed: %s", __FILE__, __LINE__, strerror(error));
        abort();
    }
    
    error = pthread_rwlock_rdlock(mutex);
    if (error != 0)
    {
        fprintf(stderr, "%s:%d: pthread_rwlock_rdlock failed: %s", __FILE__, __LINE__, strerror(error));
        abort();
    }

    return 0;
}

输出为：

main.c:53: pthread_rwlock_rdlock failed: Resource deadlock avoided

但是当我运行以下代码时：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>

int main()
{
    int error; 

    pthread_rwlock_t *mutex = (pthread_rwlock_t *)malloc(sizeof(pthread_rwlock_t));
    if (mutex == NULL) {
        perror("malloc");
        abort();
    }

    pthread_rwlockattr_t attr;

    error = pthread_rwlockattr_init(&attr);
    if (error != 0)
    {
        fprintf(stderr, "%s:%d: pthread_rwlockattr_init failed: %s", __FILE__, __LINE__, strerror(error));
        abort();
    }

    error = pthread_rwlock_init(mutex, &attr);
    if (error != 0)
    {
        fprintf(stderr, "%s:%d: pthread_rwlock_init failed: %s", __FILE__, __LINE__, strerror(error));
        abort();
    }
    
    error = pthread_rwlock_rdlock(mutex);
    if (error != 0)
    {
        fprintf(stderr, "%s:%d: pthread_rwlock_rdlock failed: %s", __FILE__, __LINE__, strerror(error));
        abort();
    }
    
    error = pthread_rwlock_wrlock(mutex);
    if (error != 0)
    {
        fprintf(stderr, "%s:%d: pthread_rwlock_wrlock failed: %s", __FILE__, __LINE__, strerror(error));
        abort();
    }
        
    return 0;
}

在这种情况下，pthread_rwlock_wrlock调用不会返回EDEADLK而是被阻塞。

Open Group 的解释有误吗？EDEADLK退货似乎更合理。这可能是什么问题？

我在 Linux 上使用 gcc 测试过，在安装了 WSL 的电脑上也测试过，还在 OnlineGDB 上测试过，但都无法正常工作。这似乎是一个常见的实现问题，而不是我的设置特有的问题。这种行为是故意的吗？

我正在学习 C 语言，很快遇到了本教程中的第一个问题。代码如下：

#include <stdio.h>
#include <stdbool.h>

static char buffer[10];

int main(int argc, char **argv) {
    puts("Lispy VERSION 0.0.0.0.1");
    puts("Press Ctrl+c to exit\n");

    while (true) {
        fputs("Lispy> ", stdout);

        fgets(buffer, 2048, stdin);

        printf("No you are a %s", buffer);
    }

    return 0;
}

在这段代码中，我想实验一下如果函数max_count的第二个参数fgets超过了 的大小会发生什么buffer。令我惊讶的是，程序运行完美，没有任何错误，编译器也没有给我任何关于潜在问题的警告。

我使用了编辑器中的调试功能，发现如果我输入一个像这样的字符串HELLLOOOOOOOOOOOOOOOOOOOOOOO，内存情况如下所示：

如上图所示，看起来整个输入字符串都正确地存储在内存中了！而且， 的大小似乎与buffer我指定的（10 字节）不完全一致。如果是 10 字节，该行printf("No you are a %s", buffer);应该只打印 10 字节，但它却打印了整个字符串“HELLLOOOOOOOOOOOOOOOOOOOOOOOOO”。

这是否意味着我实际上访问了超出分配大小的内存buffer？

在《C 语言指针》第 3 章第 23 个练习中：

假设您想在同一个源文件中编写两个函数x和y，它们使用以下变量：

但我认为不可能写出这样的a和b。有人能解释一下吗？

我正在制作一个需要 Web 界面的设备，以下是我设置 WiFi 的方式（受我的智能插头的启发）：

• 开放AP供设备连接
• 使其自身为 6.6.6.6，以便客户端可以向该 IP 发送请求
• 客户提出请求
• 设备尝试以 STA 身份连接 WiFi
• 设备响应客户端的请求

我遇到了一个问题，当 STA成功连接到 WiFi 时，连接会重置（httpd_txrx：httpd_sock_err：发送错误：113），如果没有，它会正常工作。有没有什么办法可以解决这个问题？用于存储和响应请求的代码：

esp_err_t connect_post_handler(httpd_req_t *req) 
{
    size_t size = req->content_len;
    if (size > 1024) {
        // too big
        const char* response = "Content too massive, but you know what else is massive?";
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, response);

        return ESP_OK;
    }

    char content[1024];

    int bytes_read = httpd_req_recv(req, content, size);
    if (bytes_read == 0) {
        // connection closed
        return ESP_ERR_HTTPD_INVALID_REQ;
    }

    cJSON* jsonData = cJSON_ParseWithLength(content, size);
    if (jsonData == NULL) {
        // json parsing failed, bad request
        const char* response = "Bad JSON format";
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, response);
        return ESP_OK;
    }
    char* ssid = cJSON_GetObjectItem(jsonData, "ssid")->valuestring;
    char* password = cJSON_GetObjectItem(jsonData, "password")->valuestring;
    reconnect_callback(ssid, password);
    httpd_req_async_handler_begin(req, &request); // <--- this!!!
    cJSON_Delete(jsonData);

    return ESP_OK;
}

void wifi_setup_handle_response(bool boolean, const char * response) 
{
    cJSON* response_data = cJSON_CreateObject();
    cJSON_AddBoolToObject(response_data, "success", boolean);
    cJSON_AddStringToObject(response_data, "message", response);
    

    char* response_string = cJSON_Print(response_data);

    printf(response_string);

    if (response_string == NULL) {
        // failed
        ESP_LOGE(LOG_TAG, "Could not write wifi connect response to string");
        httpd_resp_send_500(request);
        cJSON_Delete(response_data);
        return;
    }


    httpd_resp_send(request, response_string, strlen(response_string));
    httpd_req_async_handler_complete(request);

    free(response_string);
    cJSON_Delete(response_data);
}

httpd_req_t* request;

有没有办法解决这个问题，或者这是一种糟糕的设置或使用方式，我应该使用蓝牙来设置（和使用）而不是 WiFi？

背景：我一直在编写一个大量使用原子的多线程程序。我注意到这些原子非常慢，尤其是在 ARM 上，因为编译器插入了太多的栅栏，有时甚至在循环内。所以我想使用内存顺序消除不必要的栅栏。

我偶然遇到过这种情况，但我不确定使用放松负载是否安全。以这个简单的参数读取示例为例：

typedef struct {
    big_struct Data;
    _Atomic bool bDataReadDone;
} worker_thread_parameter;

static int WorkerThreadFunction(void* Parameter) {
    // Read Data
    worker_thread_parameter* pWorkerParameter = Parameter;
    big_struct Data = pWorkerParameter->Data;

    // Notify that reading Data is done
    // Use release store to ensure Data is read before this.
    atomic_store_explicit(&pWorkerParameter->bDataReadDone, true, memory_order_release);
        
    // Do something with Data
}

int main() {
    thrd_t aWorkerThread[8];
    for (size_t i = 0; i < 8; ++i) {
        worker_thread_parameter WorkerParameter = { /* Data = something */, false };
        thrd_create(&aWorkerThread[i], WorkerThreadFunction, &WorkerParameter);

        // Wait for Data to be read
        // Use relaxed load because this thread doesn't read Data anymore,
        // so we don't need to synchronize with the flag.
        while (!atomic_load_explicit(&WorkerParameter.bDataReadDone, memory_order_relaxed));
    }
}

或者这个例子：

// Initialized before the threads are started
_Atomic bool bUsingData = true;
big_struct* pData = malloc(sizeof(*pData));

static int WorkerThread() {
    Use(pData);

    // Notify the cleaner thread to free Data
    // Use release store to ensure Data is used before this.
    atomic_store_explicit(&bUsingData, false, memory_order_release);
}

static int CleanerThread() {
    // Use relaxed load because this thread doesn't read Data anymore,
    // so we don't need to synchronize with the flag.
    while (atomic_load_explicit(bUsingData, memory_order_relaxed));
    free(pData);
}

这个例子：

_Atomic int X = 0;
_Atomic int Y = 0;

// Thread 1

atomic_store_explicit(&X, 99, memory_order_relaxed);
atomic_store_explicit(&Y, 1, memory_order_release);

// Thread 2

if (atomic_load_explicit(&Y, memory_order_relaxed)) {
    atomic_store_explicit(&X, 100, memory_order_relaxed);
    printf("%i", atomic_load_explicit(&X, memory_order_relaxed));
}

// Does thread 2 always prints 100?

这个问题源于试图理解“C 哲学”，而不是源于任何“真正的问题”。

假设在 C 程序中我使用 sin(x)：

#include <stdio.h>

int main() {
  char s[20] = "aha";
  printf("%f", sin(s));
  return 0;
}

我故意犯了两个错误：

1. 我没有#includeed math.h（或者提供任何关于 sin 的声明）。
2. 我将其制成了s类型char *（只是一些无法有意义地转换为的东西double）。

我使用带有-lm标志的 GCC 进行编译。

正如预期的那样，我收到一个警告和一个错误。

当然，还有函数隐式声明的警告等等：

bad.c: In function ‘main’:

bad.c:5:15: warning: implicit declaration of function ‘sin’ [-Wimplicit-function-declaration]
    5 |   printf("%f", sin(s));
      |                ^~~
bad.c:5:16: warning: incompatible implicit declaration of built-in function ‘sin’
bad.c:2:1: note: include ‘<math.h>’ or provide a declaration of ‘sin’
    1 | #include <stdio.h>
  +++ |+#include <math.h>

一些研究似乎表明，如果一个函数事先没有声明，那么 C 会假定一个“默认声明”（所谓的“隐式声明”），就像int undeclaredfunction(void)。

但我也收到以下错误：

    2 |
bad.c:5:19: error: incompatible type for argument 1 of ‘sin’
    5 |   printf("%f", sin(s));
      |                    ^
      |                    |
      |                    char *
bad.c:5:20: note: expected ‘double’ but argument is of type ‘char *’

这表明“隐式声明”需要一个类型的参数double。

1. 似乎 C 维护着“标准函数”的正确“隐式声明”列表。在哪里可以找到给定编译器（例如gcc或clang）的正确隐式声明的完整列表？
2. 如果 C 已经内置了标准数学函数的正确声明，那么为什么它还要求程序员这样做呢#include<math.h>？ 只是因为传统？ 还是为了简洁？

我寻找的答案是关于编译器使用的确切规则，而不是关于“良好编程实践”的主观评论。

我正在尝试将 HTTP 请求存储为全局变量。我的软件是关于连接 WiFi 的，我使用的 WiFi 库是基于事件的，这意味着我必须将 HTTP 请求存储在某个地方并等待事件回调。 问题：我再次尝试访问它后，程序崩溃了。日志：

> Guru Meditation Error: Core  0 panic'ed (StoreProhibited). Exception
> was unhandled.
> 
> Core  0 register dump: PC      : 0x400ff5e5  PS      : 0x00060430  A0 
> : 0x800d79a1  A1      : 0x3ffbdf90
> --- 0x400ff5e5: httpd_resp_send at F:/Espressif/frameworks/esp-idf-v5.2.5/components/esp_http_server/src/httpd_txrx.c:248
> 
> A2      : 0x3ffc93c8  A3      : 0x3f4038ec  A4      : 0x00000003  A5  
> : 0x00000000 A6      : 0x00000000  A7      : 0x3ffc93c8  A8      :
> 0x00000000  A9      : 0x3ffbdf30 A10     : 0x000001f4  A11     :
> 0x3ffbdf30  A12     : 0x3ffbde44  A13     : 0x3ffbde0c A14     :
> 0x3ffbde20  A15     : 0x3ffbdff0  SAR     : 0x00000004  EXCCAUSE:
> 0x0000001d EXCVADDR: 0x00000218  LBEG    : 0x400014fd  LEND    :
> 0x4000150d  LCOUNT  : 0xffffffff
> --- 0x400014fd: strlen in ROM
> --- 0x4000150d: strlen in ROM
> 
> 
> 
> Backtrace: 0x400ff5e2:0x3ffbdf90 0x400d799e:0x3ffbdfd0
> 0x400d773b:0x3ffbdff0 0x400d7ad1:0x3ffbe020 0x4016387d:0x3ffbe050
> 0x401633c6:0x3ffbe080 0x401634a1:0x3ffbe0c0 0x4008a129:0x3ffbe0e0
> --- 0x400ff5e2: httpd_resp_send at F:/Espressif/frameworks/esp-idf-v5.2.5/components/esp_http_server/src/httpd_txrx.c:248
> --- 0x400d799e: wifi_setup_handle_response at F:/Documents/dashboardfordevice/device-software/main/wifi_setup_webpage.c:44
> --- 0x400d773b: disconnect_handler at F:/Documents/dashboardfordevice/device-software/main/wifi_manager.c:20
> --- 0x400d7ad1: run_on_event at F:/Documents/dashboardfordevice/device-software/main/wifi.c:32
> --- 0x4016387d: handler_execute at F:/Espressif/frameworks/esp-idf-v5.2.5/components/esp_event/esp_event.c:137
> --- 0x401633c6: esp_event_loop_run at F:/Espressif/frameworks/esp-idf-v5.2.5/components/esp_event/esp_event.c:593
> --- 0x401634a1: esp_event_loop_run_task at F:/Espressif/frameworks/esp-idf-v5.2.5/components/esp_event/esp_event.c:107
> --- 0x4008a129: vPortTaskWrapper at F:/Espressif/frameworks/esp-idf-v5.2.5/components/freertos/FreeRTOS-Kernel/portable/xtensa/port.c:13

据我了解，这首先是由空字符串引起的，但这是 wifi_setup_webpage.c 中的第 44 行，httpd_resp_send(request, "200", 3);据我所知，这不可能是问题所在，因为执行同样事情的其他处理程序不会崩溃，唯一的区别是它们指向请求的指针是“新鲜的”。

我使用全局变量存储请求：httpd_req_t* request;然后使用request = req; 该方法的完整代码对其进行分配：

esp_err_t connect_post_handler(httpd_req_t *req) 
{
    size_t size = req->content_len;
    if (size > 1024) {
        // too big
        const char* response = "Content too massive, but you know what else is massive?";
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, response);

        return ESP_OK;
    }

    char content[1024];

    int bytes_read = httpd_req_recv(req, content, size);
    if (bytes_read == 0) {
        // connection closed
        return ESP_ERR_HTTPD_INVALID_REQ;
    }

    cJSON* jsonData = cJSON_ParseWithLength(content, size);
    if (jsonData == NULL) {
        // json parsing failed, bad request
        const char* response = "Bad JSON format";
        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, response);
        return ESP_OK;
    }
    char* ssid = cJSON_GetObjectItem(jsonData, "ssid")->valuestring;
    char* password = cJSON_GetObjectItem(jsonData, "password")->valuestring;

    cJSON_Delete(jsonData);

    request = req;

    reconnect_callback(ssid, password);

    return ESP_OK;
}

以及发送请求的方法的完整代码：

void wifi_setup_handle_response(bool boolean, const char * response) 
{
    // cJSON* response_data = cJSON_CreateObject();
    // cJSON_AddBoolToObject(response_data, "success", boolean);
    // cJSON_AddStringToObject(response_data, "message", response);
    

    // char* response_string = cJSON_Print(response_data);

    // ESP_LOGI(LOG_TAG, "Raw Response: %s", response_string);

    // if (response_string == NULL) {
    //     // failed
    //     ESP_LOGE(LOG_TAG, "Could not write wifi connect response to string");
    //     httpd_resp_send_500(request);
    //     cJSON_Delete(response_data);
    //     return;
    // }

    if (request == NULL) {
        ESP_LOGE(LOG_TAG, "request is null, aha!");
        return;
    }

    httpd_resp_send(request, "200", 3);
    

    // free(response_string);
    // cJSON_Delete(response_data);
}

仅供参考：这两个函数之间有大约 3 秒的间隔。顺序：connect_post_handler 然后 void wifi_setup_handle_response。我认为这是因为与堆栈内存相关的某些东西被破坏了，然后指向它的指针不再有效，但我不知道如何处理它，因为请求 typedef 有很多指向其他内容的奇特指针。