# /etc/nsswitch.conf 示例
$ cat /etc/nsswitch.conf

# 名称服务配置
passwd:    files systemd
group:     files systemd
shadow:    files

hosts:     files mdns4_minimal [NOTFOUND=return] dns myhostname
networks:  files

protocols: db files
services:  db files
ethers:    db files
rpc:       db files

# 密码和组查询
aliases:   files
automount: files

/* 使用 NSS 查询主机信息 */
#include <stdio.h>
#include <netdb.h>
#include <string.h>
#include <arpa/inet.h>

int main() {
    struct addrinfo hints, *res, *p;
    char ip[INET6_ADDRSTRLEN];

    memset(&hints, 0, sizeof(hints));
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;

    /* getaddrinfo 在 glibc 上通过 NSS 查询：
     * 1. /etc/hosts（nss_files）
     * 2. mDNS（nss_mdns4）— 如果配置了
     * 3. DNS（nss_dns）— 通过 /etc/resolv.conf
     * 4. 任何其他配置的后端
     *
     * 在 musl 上只查询 /etc/hosts 和 DNS
     */

    int status = getaddrinfo("myserver.local", "80", &hints, &res);
    if (status != 0) {
        printf("Error: %s\n", gai_strerror(status));
        return 1;
    }

    for (p = res; p != NULL; p = p->ai_next) {
        void *addr;
        if (p->ai_family == AF_INET) {
            addr = &((struct sockaddr_in *)p->ai_addr)->sin_addr;
        } else {
            addr = &((struct sockaddr_in6 *)p->ai_addr)->sin6_addr;
        }
        inet_ntop(p->ai_family, addr, ip, sizeof(ip));
        printf("Resolved: %s\n", ip);
    }

    freeaddrinfo(res);
    return 0;
}

/* glibc NPTL 独有的高级特性 */

#define _GNU_SOURCE
#include <pthread.h>
#include <stdio.h>
#include <sched.h>

int main() {
    pthread_t tid = pthread_self();

    /* 1. 设置线程名（两者都支持，但 glibc 信息更详细） */
    pthread_setname_np(tid, "main-thread");

    /* 2. 获取线程 CPU 亲和性 */
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    pthread_getaffinity_np(tid, sizeof(cpuset), &cpuset);
    printf("CPU affinity: ");
    for (int i = 0; i < CPU_SETSIZE; i++) {
        if (CPU_ISSET(i, &cpuset))
            printf("%d ", i);
    }
    printf("\n");

    /* 3. glibc 特有：robust mutex 列表 */
    /* 当持有 mutex 的线程终止时，mutex 会被标记为 EOWNERDEAD */
    pthread_mutex_t mutex;
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_setrobust(&attr, PTHREAD_MUTEX_ROBUST);
    pthread_mutex_init(&mutex, &attr);

    /* 4. 优先级继承互斥锁 */
    pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);

    pthread_mutexattr_destroy(&attr);
    pthread_mutex_destroy(&mutex);
    return 0;
}

# glibc malloc 环境变量

# 1. 设置 arena 数量（默认为 CPU 核心数 * 2 或 8）
export MALLOC_ARENA_MAX=4  # 限制 arena 数量，减少内存碎片

# 2. 启用 per-thread 缓存（glibc 2.26+）
export MALLOC_TCACHE_COUNT=1024  # 缓存桶数量
export MALLOC_TCACHE_MAX_SZ=1024 # 缓存对象最大大小

# 3. 使用 mmap 阈值
export MALLOC_MMAP_THRESHOLD_=131072  # 超过 128KB 使用 mmap

# 4. trim 阈值
export MALLOC_TRIM_THRESHOLD_=131072  # 可回收的空闲内存阈值

# 5. 检查内存错误（调试用）
export MALLOC_CHECK_=3  # 0=不检查, 1=打印错误, 2=abort, 3=打印并abort

/* 编程接口的 malloc 调优 */
#include <malloc.h>
#include <stdio.h>

int main() {
    /* 获取 malloc 统计信息 */
    struct mallinfo2 mi = mallinfo2();
    printf("Total allocated: %zu bytes\n", mi.uordblks);
    printf("Total free: %zu bytes\n", mi.fordblks);
    printf("Number of free chunks: %zu\n", mi.ordblks);

    /* 手动释放空闲内存给操作系统 */
    malloc_trim(0);

    /* 设置 malloc 行为 */
    mallopt(M_MMAP_THRESHOLD, 131072);  /* mmap 阈值 */
    mallopt(M_TOP_PAD, 64 * 1024);      /* sbrk 增长余量 */

    return 0;
}

# glibc x86_64 的 memcpy 变体选择
# 运行时根据 CPU 特性选择最优实现

$ ldd /lib/x86_64-linux-gnu/libc.so.6
# libc.so.6 本身不依赖其他库

# glibc 内部在初始化时检测 CPU 特性：
# - SSE2（最低要求）
# - SSSE3
# - SSE4.1/SSE4.2
# - AVX
# - AVX2
# - AVX-512
# - ERMS (Enhanced REP MOVSB/STOSB)
# 然后选择最优的 memcpy/strlen 等实现

/* 演示 glibc 字符串函数的性能优势 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

static void bench_strcpy(size_t size, int iterations) {
    char *src = malloc(size + 1);
    char *dst = malloc(size + 1);
    memset(src, 'A', size);
    src[size] = '\0';

    struct timespec start, end;
    clock_gettime(CLOCK_MONOTONIC, &start);

    for (int i = 0; i < iterations; i++) {
        strcpy(dst, src);
    }

    clock_gettime(CLOCK_MONOTONIC, &end);
    double elapsed = (end.tv_sec - start.tv_sec) +
                     (end.tv_nsec - start.tv_nsec) / 1e9;

    printf("strcpy %zu bytes x %d: %.3f sec (%.1f GB/s)\n",
           size, iterations, elapsed,
           (double)size * iterations / elapsed / 1e9);

    free(src);
    free(dst);
}

int main() {
    bench_strcpy(64, 10000000);       /* 小字符串 */
    bench_strcpy(4096, 1000000);      /* 中等字符串 */
    bench_strcpy(1048576, 10000);     /* 大字符串 (1MB) */
    return 0;
}

/* glibc 提供内置的 backtrace 支持 */
#include <execinfo.h>  /* glibc 专有 */
#include <stdio.h>
#include <stdlib.h>

void print_backtrace(void) {
    void *buffer[100];
    int nptrs = backtrace(buffer, 100);
    char **strings = backtrace_symbols(buffer, nptrs);

    printf("Backtrace (%d frames):\n", nptrs);
    for (int i = 0; i < nptrs; i++) {
        printf("  [%d] %s\n", i, strings[i]);
    }
    free(strings);
}

void func_c(void) { print_backtrace(); }
void func_b(void) { func_c(); }
void func_a(void) { func_b(); }

int main() {
    func_a();
    return 0;
}

/*
 * 输出示例：
 * Backtrace (6 frames):
 *   [0] ./backtrace(print_backtrace+0x1f) [0x401234]
 *   [1] ./backtrace(func_c+0x9) [0x401270]
 *   [2] ./backtrace(func_b+0x9) [0x401280]
 *   [3] ./backtrace(func_a+0x9) [0x401290]
 *   [4] ./backtrace(main+0x9) [0x4012a0]
 *   [5] /lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf3) [...]
 *
 * musl 不提供 <execinfo.h>，需要使用 libunwind 或 libbacktrace
 */

# glibc 独有的动态链接器调试功能
$ LD_DEBUG=libs ./program
# 显示库搜索过程

$ LD_DEBUG=symbols ./program
# 显示符号解析过程

$ LD_DEBUG=bindings ./program
# 显示符号绑定

$ LD_DEBUG=versions ./program
# 显示符号版本解析

$ LD_DEBUG=help ./program
# 显示所有可用的调试选项

# 这些在 musl 上不支持（musl 动态链接器更简单）

/* glibc 的 mtrace 内存泄漏检测 */
#include <mtrace.h>  /* glibc 专有 */
#include <stdlib.h>
#include <stdio.h>

int main() {
    /* 启用内存跟踪 */
    mtrace();

    void *p1 = malloc(100);
    void *p2 = malloc(200);
    free(p1);
    /* p2 故意不释放 — 模拟内存泄漏 */

    muntrace();
    return 0;
}

/*
 * 使用方法：
 * $ export MALLOC_TRACE=/tmp/mtrace.log
 * $ gcc -o leak leak.c
 * $ ./leak
 * $ mtrace ./leak /tmp/mtrace.log
 *
 * 输出：
 * Memory not freed:
 *  Address     Size     Caller
 *  0x0x55...   0xc8     at 0x401152
 *
 * musl 不提供 mtrace，需要使用 Valgrind 或 AddressSanitizer
 */

/* glibc 独有的 argp 参数解析框架 */
#include <argp.h>  /* glibc 专有 */
#include <stdio.h>

static struct argp_option options[] = {
    {"verbose", 'v', 0, 0, "Produce verbose output"},
    {"output",  'o', "FILE", 0, "Output to FILE"},
    {0}
};

struct arguments {
    int verbose;
    char *output;
    char *input;
};

static error_t parse_opt(int key, char *arg, struct argp_state *state) {
    struct arguments *args = state->input;
    switch (key) {
        case 'v': args->verbose = 1; break;
        case 'o': args->output = arg; break;
        case ARGP_KEY_ARG: args->input = arg; break;
        default: return ARGP_ERR_UNKNOWN;
    }
    return 0;
}

static struct argp argp = {options, parse_opt, "INPUT", "My program description"};

int main(int argc, char *argv[]) {
    struct arguments args = {0};
    argp_parse(&argp, argc, argv, 0, 0, &args);
    printf("verbose=%d output=%s input=%s\n",
           args.verbose, args.output ?: "stdout", args.input ?: "stdin");
    return 0;
}

/*
 * musl 替代方案：
 * 1. 使用 getopt() / getopt_long()（POSIX 标准）
 * 2. 使用第三方库（如 CLI11 for C++, argparse for Python）
 * 3. 自行解析 argv[]
 */

/* glibc 的 error() 函数 */
#include <error.h>  /* glibc 专有 */
#include <errno.h>
#include <stdio.h>

int main(int argc, char *argv[]) {
    FILE *fp = fopen(argv[1], "r");
    if (!fp) {
        /* 打印程序名、文件名、错误信息，然后退出 */
        /* 输出: myprog: /nonexistent: No such file or directory */
        error(1, errno, "%s", argv[1]);
    }
    fclose(fp);
    return 0;
}

/*
 * musl 替代方案：
 * fprintf(stderr, "%s: %s: %s\n", program_invocation_short_name,
 *         filename, strerror(errno));
 * exit(1);
 *
 * 或者使用自定义宏：
 * #define ERROR(exitcode, fmt, ...) do { \
 *     fprintf(stderr, "%s: " fmt ": %s\n", \
 *             program_invocation_short_name, ##__VA_ARGS__, strerror(errno)); \
 *     exit(exitcode); \
 * } while(0)
 */

/* glibc 独有的 printf 扩展 */
#include <stdio.h>

int main() {
    /* 1. %m 格式 - 输出 strerror(errno)，无需传递 errno */
    FILE *fp = fopen("/nonexistent", "r");
    if (!fp) {
        /* glibc：输出 "No such file or directory" */
        /* musl：%m 不被识别，输出 "%m" 或类似内容 */
        printf("Open failed: %m\n");
    }

    /* 2. %a 格式 - 十六进制浮点输出 */
    printf("Pi = %a\n", 3.14159);
    /* glibc: 0x1.921f9f01b866ep+1 */
    /* musl: 同样支持（C99 标准） */

    /* 3. '  (空格) 标志 - 正数前加空格 */
    printf("Value: '% d'\n", 42);
    /* glibc: "Value: ' 42'" */
    /* musl: 同样支持（C 标准） */

    /* 4. 注册自定义 printf 修饰符（glibc 专有） */
    /* register_printf_function() - 高度不推荐使用 */

    return 0;
}

/* 运行时 CPU 特性检测 */
#define _GNU_SOURCE
#include <stdio.h>
#include <sys/auxv.h>
#include <asm/hwcap.h>

int main() {
    unsigned long hwcap = getauxval(AT_HWCAP);

    printf("CPU Features:\n");
    printf("  SSE2:    %s\n", (hwcap & HWCAP_X86_64_SSE2)    ? "yes" : "no");
    printf("  AVX:     %s\n", (hwcap & HWCAP_X86_64_AVX)     ? "yes" : "no");
    printf("  AVX2:    %s\n", (hwcap & HWCAP_X86_64_AVX2)    ? "yes" : "no");
    printf("  AVX-512: %s\n", (hwcap & HWCAP_X86_64_AVX512F) ? "yes" : "no");

    /* glibc 在启动时读取这些信息，然后选择最优的函数实现
     * 这叫做 IFUNC（GNU Indirect Function）机制 */
    return 0;
}

/* IFUNC（Indirect Function）机制允许在运行时选择最优函数实现 */
/* 这是 glibc 的核心优化机制 */

/* 简化的 IFUNC 解析器示例 */
#include <stdio.h>

/* glibc 内部使用 IFUNC 来选择最优的 memcpy 实现 */
/*
 * 在链接时，符号 "memcpy" 不直接指向某个函数
 * 而是指向一个 "resolver" 函数
 *
 * 程序第一次调用 memcpy 时：
 *   1. 调用 resolver 函数
 *   2. resolver 检测 CPU 特性
 *   3. 返回最优实现的函数指针
 *   4. 后续调用直接使用该函数指针
 *
 * musl 不使用 IFUNC，而是使用通用的 C 实现
 */

int main() {
    printf("IFUNC mechanism is used by glibc for:\n");
    printf("  - memcpy, memmove, memset\n");
    printf("  - strlen, strcmp, strcpy\n");
    printf("  - memcmp, memchr\n");
    printf("  - wcslen, wcscpy, wcscmp\n");
    printf("  - 等等\n");
    return 0;
}

/* glibc 特性测试宏 */
#define _GNU_SOURCE         /* 启用所有 GNU 扩展 */
#define _POSIX_C_SOURCE 200809L  /* 启用 POSIX.1-2008 */
#define _XOPEN_SOURCE 700   /* 启用 XSI 扩展 */
#define _DEFAULT_SOURCE     /* 启用传统的 BSD/SVID 定义 */
#define _BSD_SOURCE         /* 已废弃，使用 _DEFAULT_SOURCE */
#define _SVID_SOURCE        /* 已废弃，使用 _DEFAULT_SOURCE */

#include <stdio.h>
#include <features.h>

int main() {
#ifdef _GNU_SOURCE
    printf("GNU extensions enabled\n");
#endif

    /* 检查 glibc 版本 */
#ifdef __GLIBC__
    printf("glibc version: %d.%d\n", __GLIBC__, __GLIBC_MINOR__);
    /* glibc 2.39: __GLIBC__=2, __GLIBC_MINOR__=39 */
#endif

    /* 检查 glibc 版本是否满足最低要求 */
#if __GLIBC_PREREQ(2, 35)
    printf("glibc >= 2.35\n");
#endif

    return 0;
}