c - argv、envp、argc(命令行参数)的最大汇总大小始终远离 ARG_MAX 限制

Question

我编写了一个程序来计算传递给 execve 系统调用的参数的总大小。

我已经用最大参数大小测试了这个程序，预计“Argument list too long”错误只会在超过 ARG_MAX 限制时发生。在我看来，命令行的最大总大小应尽可能接近 ARG_MAX 限制，即在不超过此限制的情况下不能添加额外的参数(文件名)。

但我看到另一种行为:“未使用”字节的数量以不可预测的方式波动，而环境和程序名称保持不变，只有参数数量在变化。

问题:

• 计数程序不正确并且缺少一些值？为什么“Argument list too long”发生的时间早于应有的时间？
• 这是正常行为，未使用的字节是内存填充/对齐/其他类型？那么在内核源代码中哪里提到了这种行为？我读过linux/fs/exec.c还没有看到可以回答我的问题的东西。

程序

接下来是计数算法:

argv 的大小 + envp 的大小 + argc 的大小

1. argv 是指向字符串的指针数组(指向 char 的指针)，因此遍历此数组并将字符串的长度添加到结果中，保持请记住，每个都以 NULL 字节结尾。然后将它们的指针添加到结果中——指针的大小为 8 字节。因此:指针的数量 * 8 + 字符串的长度(每个都有一个 NULL 字节)

2. 与 envp 几乎相同的故事 - 带有 NULL 字节和指针的字符串长度。但最后一个指针通过指向 NULL 字节向数组末尾发出信号，因此将其添加到结果 8 字节 + 1 字节。

3. argc 是简单的 int。

#include <stdio.h>
#include <string.h>
#include <unistd.h>

int main(int argc, char *argv[], char *envp[]) {
    size_t char_ptr_size = sizeof(char *);
    // The arguments array total size calculation
    size_t arg_strings_size = 0;
    size_t string_len = 0;
    for(int i = 0; i < argc; i++) {
        // Every string ends up with a nullbyte, so the 1 byte is added
        string_len = strlen(argv[i]) + 1;
        arg_strings_size += string_len;
//      printf("%zu:\t%s\n", string_len, argv[i]);
    }

    size_t argv_size = arg_strings_size + argc * char_ptr_size;

    printf( "arg strings size: %zu\n"
            "number of pointers to strings %i\n\n"
            "argv size:\t%zu + %i * %zu = %zu\n",
             arg_strings_size,
             argc,
             arg_strings_size,
             argc,
             char_ptr_size,
             argv_size
        );

    // The enviroment variables array total size calculation
    size_t env_size = 0;
    for (char **env = envp; *env != 0; env++) {
        char *thisEnv = *env;
        // Every string ends up with a nullbyte, so the 1 byte is added
        env_size += strlen(thisEnv) + 1 + char_ptr_size;
    }

    // The last element of "envp" is a pointer to the NULL byte, so size of pointer and 1 is added
    printf("envp size:\t%zu\n", env_size + char_ptr_size + 1);

    size_t overall = argv_size + env_size + sizeof(argc);

    printf( "\noverall (argv_size + env_size + sizeof(argc)):\t"
            "%zu + %zu + %zu = %zu\n",
             argv_size,
             env_size,
             sizeof(argc),
             overall);
    // Find ARG_MAX by system call
    long arg_max = sysconf(_SC_ARG_MAX);

    printf("ARG_MAX: %li\n\n", arg_max);
    printf("Number of \"unused bytes\": ARG_MAX - overall = %li\n\n", arg_max - (long) overall);

    return 0;
}

测试

1 字节文件名 - 975 字节未使用。

$ ./program $(yes A | head -n 209222) # 209223 will cause "Argument list too long"

arg strings size: 418454
number of pointers to strings 209223

argv size:  418454 + 209223 * 8 = 2092238
envp size:  3944

overall (argv_size + env_size + sizeof(argc)):  2092238 + 3935 + 4 = 2096177
ARG_MAX: 2097152

Number of "unused bytes": ARG_MAX - overall = 975

2 字节文件名 - 3206 字节未使用。

$ ./program $(yes AA | head -n 189999)

arg strings size: 570007
number of pointers to strings 190000

argv size:  570007 + 190000 * 8 = 2090007
envp size:  3944

overall (argv_size + env_size + sizeof(argc)):  2090007 + 3935 + 4 = 2093946
ARG_MAX: 2097152

Number of "unused bytes": ARG_MAX - overall = 3206

3 字节文件名 - 2279 字节未使用。

$ ./program $(yes AAA | head -n 174243)

arg strings size: 696982
number of pointers to strings 174244

argv size:  696982 + 174244 * 8 = 2090934
envp size:  3944

overall (argv_size + env_size + sizeof(argc)):  2090934 + 3935 + 4 = 2094873
ARG_MAX: 2097152

Number of "unused bytes": ARG_MAX - overall = 2279

这个问题是我另一个问题的一部分:How calculate the number of files which can be passed as arguments to some command for batch processing?

Answer 1

TL;DR 这些问题是由 ASLR(地址空间布局随机化)引起的请参阅下面的UPDATE部分[在我的原始回答之后]求解释

---

正如 paladin 所提到的，这是系统特定的。例如，对于 freebsd，数量要少得多。

一些需要注意的事情 [在 linux 下] ...

ARG_MAX 定义为 131072 [这是 32 个 4K 页面]。

_SC_ARG_MAX 返回 2097152 [即 2MB]

bits/param.h 中的声明:

The kernel headers define ARG_MAX. The value is wrong, though.

然而，经过衡量，它似乎是正确的。

根据 linux/fs/exec.c 中的代码，它检查 ARG_MAX 的 [hardwired] 值。它还检查 _STK_LIM [这是 8MB] 和 rlimit(RLIMIT_STACK) [默认为 _STK_LIM]

获得实际限制的最佳方法是计算 argv 和 envp 的大小，您可以这样做。但是，您没有考虑每个末尾的 NULL 指针的大小。

---

我会对传递的数据量进行二进制搜索[检查 E2BIG]:

#define _GNU_SOURCE
#include <linux/limits.h>
long arg_lgx = ARG_MAX;

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

#include <sys/param.h>

#include <sys/wait.h>
#include <sys/resource.h>

int pgm_argc;
char **pgm_argv;
char **pgm_envp;

int opt_s;
char *opt_R;

size_t envlen;
size_t totlen;
long arg_max;
size_t lo;
size_t hi;

int status;

size_t
argvlen(char **argv)
{
    size_t totlen = 0;

    for (;  *argv != NULL;  ++argv) {
        size_t slen = strlen(*argv);

        totlen += slen;
        totlen += 1;

        totlen += sizeof(char *);
    }

    totlen += sizeof(char *);

    return totlen;
}

size_t
lenall(int argc,char **argv,char **envp)
{
    size_t totlen = 0;

    size_t avlen = argvlen(argv);
    avlen += sizeof(argv);
    totlen += avlen;

    size_t envlen = argvlen(envp);
    envlen += sizeof(envp);
    totlen += envlen;

    totlen += sizeof(argc);

    return totlen;
}

char *
strmake(size_t explen)
{
    char *bp;
    char *buf;

    explen -= sizeof(char *);
    explen -= 1;

    buf = malloc(explen + 1);

    for (bp = buf;  explen > 0;  --explen, ++bp)
        *bp = (explen % 26) + 'A';

    *bp = 0;

    return buf;
}

void
doexec(size_t totlen)
{
    size_t explen;
    int sverr;
    char *argv[4];

    explen = totlen;
    explen -= envlen;

    argv[0] = pgm_argv[0];
    argv[1] = "-s";
    argv[2] = strmake(explen);
    argv[3] = NULL;

    pid_t pid = fork();

    do {
        if (pid == 0) {
            printf("%zu %zu %zu\n",lo,totlen,hi);

            execvpe(argv[0],argv,pgm_envp);
            sverr = errno;

            status = sverr << 8;
            printf("%8.8X %d -- %s\n",status,sverr,strerror(sverr));

            exit(sverr);
            break;
        }

        waitpid(pid,&status,0);

        free(argv[2]);
    } while (0);
}

int
main(int argc,char **argv,char **envp)
{
    char *cp;
    size_t totlen;

    pgm_argc = argc;
    pgm_argv = argv;
    pgm_envp = envp;

    setlinebuf(stdout);

    envlen = argvlen(envp);

    arg_max = sysconf(_SC_ARG_MAX);

#if 0
    totlen = lenall(argc,argv,envp);
    printf("%zu\n",totlen);
#endif

    --argc;
    ++argv;

    //printf("main: '%s'\n",*argv);

    for (;  argc > 0;  --argc, ++argv) {
        cp = *argv;
        if (*cp != '-')
            break;

        cp += 2;
        switch (cp[-1]) {
        case 's':
            opt_s = 1;
            break;
        case 'R':
            opt_R = cp;
            break;
        }
    }

    // slave just exits
    if (opt_s)
        exit(0);

    if (opt_R != NULL) {
        size_t Rsize = strtol(opt_R,&cp,10);

        switch (*cp) {
        case 'K':
        case 'k':
            Rsize *= 1024;
            break;
        case 'M':
        case 'm':
            Rsize *= 1024;
            Rsize *= 1024;
            break;
        }

        printf("stksiz: %zu (ARG)\n",Rsize);

        struct rlimit rlim;
        getrlimit(RLIMIT_STACK,&rlim);
        printf("stksiz: %lu %lu (OLD)\n",rlim.rlim_cur,rlim.rlim_max);

        rlim.rlim_cur = Rsize;
        setrlimit(RLIMIT_STACK,&rlim);

        getrlimit(RLIMIT_STACK,&rlim);
        printf("stksiz: %lu %lu (NEW)\n",rlim.rlim_cur,rlim.rlim_max);
    }

    printf("arg_lgx: %zu\n",arg_lgx);
    printf("arg_max: %zu\n",arg_max);
    printf("envlen: %zu\n",envlen);

    lo = 32;
    hi = 100000000;

    while (lo < hi) {
        size_t mid = (lo + hi) / 2;

        doexec(mid);

        if (status == 0)
            lo = mid + 1;
        else
            hi = mid - 1;
    }

    return 0;
}

---

程序输出如下:

arg_lgx: 131072
arg_max: 2097152
envlen: 3929
32 50000016 100000000
00000700 7 -- Argument list too long
32 25000023 50000015
00000700 7 -- Argument list too long
32 12500027 25000022
00000700 7 -- Argument list too long
32 6250029 12500026
00000700 7 -- Argument list too long
32 3125030 6250028
00000700 7 -- Argument list too long
32 1562530 3125029
00000700 7 -- Argument list too long
32 781280 1562529
00000700 7 -- Argument list too long
32 390655 781279
00000700 7 -- Argument list too long
32 195343 390654
00000700 7 -- Argument list too long
32 97687 195342
97688 146515 195342
00000700 7 -- Argument list too long
97688 122101 146514
122102 134308 146514
134309 140411 146514
00000700 7 -- Argument list too long
134309 137359 140410
00000700 7 -- Argument list too long
134309 135833 137358
00000700 7 -- Argument list too long
134309 135070 135832
00000700 7 -- Argument list too long
134309 134689 135069
134690 134879 135069
134880 134974 135069
134975 135022 135069
00000700 7 -- Argument list too long
134975 134998 135021
134999 135010 135021
00000700 7 -- Argument list too long
134999 135004 135009
135005 135007 135009
135008 135008 135009

---

更新:

您看到的变化是由于 ASLR(地址空间布局随机化)造成的。它将程序/进程的各个部分的起始地址随机化，作为一种安全缓解措施。

有几种方法可以禁用 ASLR:

1. 通过更改 /proc/sys/kernel/randomize_va_space 系统范围
2. 程序可以使用 personality 系统调用为子进程执行此操作。
3. setarch 程序使用 syscall 方法以类似于 shell 的方式调用子程序。

参见:https://askubuntu.com/questions/318315/how-can-i-temporarily-disable-aslr-address-space-layout-randomization和 Disable randomization of memory addresses

ASLR 为起始/最高堆栈地址、envp、argv 和提供给 main 的起始堆栈位置/帧设置随机起始位置.

看似“未使用”的空间是该放置和填充/对齐的函数。因此，该空间确实并非未使用(即可能可用)。

即使传递给 child 的参数完全相同，地址也会随着 ASLR 的开启而改变。

我知道 ASLR，但不确定它是否适用于此处(在堆栈上)[一开始]。

在弄清楚连接之前，我增强了我的程序来查看和比较这些不同地址中的一些以及它们之间的偏移量。

然而，在 ASLR 开启的情况下，如果我们多次运行子进程 [许多 ;-)] 次，即使两次或多次运行恰好在某些相同的起始地址(例如最高堆栈)上匹配地址)其他参数仍然可以独立变化。

因此，我增强了程序，可以通过 personality 系统调用选择性地禁用 ASLR，并且在禁用时，每次运行都具有相同的位置和偏移量。

我的重构程序已达到可在此处代码块中发布的限制，因此这里有一个链接:https://pastebin.com/gYwRFvcv [我通常不这样做——请参阅下面的部分了解原因]。

这个程序有很多选项，因为我在得出结论之前进行了大量实验。

-A 选项将禁用 ASLR。考虑使用 -x100000 -Ma@ [带/不带] -A 运行它。

另一个好的组合是在上面添加-L。这会覆盖二进制搜索，支持在合理大小内的单个参数长度。

查看代码中的注释以获取更多信息。

有了它，您可以在必要时进一步试验 [或给您一些想法] 来修改您自己的程序。