argv、envp、argc（命令行参数）的最大汇总大小总是远离 ARG_MAX 限制

Question

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

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

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

问题：

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

计划

接下来是计数算法：

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

1. argv 是指向字符串的指针数组（指向char 的指针），因此循环该数组并将字符串的长度添加到结果中，记住每个字符串都以 NULL 字节结尾。然后将它们的指针添加到结果中 - 指针的大小为 8 字节。因此：the number of pointers * 8 + lengths of strings (each with a NULL byte)

2. envp 的情况几乎相同——字符串长度为 NULL 字节和指针。但是最后一个指针通过指向 NULL 字节来指示数组的末尾，因此将其添加到结果8 bytes + 1 bytes。

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（地址空间布局随机化）引起的，请参阅下面的更新部分[在我的原始答案之后]了解说明

---

正如圣骑士所说，这是系统特定的。比如freebsd，这个数字就少了很多。

[linux下]需要注意的几点...

ARG_MAX 定义为 131072 [即 32 个 4K 页]。

_SC_ARG_MAX 返回 2097152 [即 2MB]

bits/param.h 中的声明：

内核头文件定义 ARG_MAX。但是值是错误的。

但是，根据测量，它似乎是正确的。

根据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。

看起来“未使用”的空间是该放置和填充/对齐的函数。因此，该空间确实没有被使用（即可能可用）。

即使将相同的确切参数传递给孩子，地址也会随着 ASLR 的开启而改变。

我知道 ASLR，但不确定它是否适用于此处（在堆栈上）[起初]。

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

但是，在启用 ASLR 的情况下，如果我们多次运行子 [many ;-)] 次，即使两次或多次运行碰巧在某些相同的起始地址上匹配（例如最高堆栈address) 其他参数仍然可以独立变化。

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

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

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

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

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

查看代码中的 cmets 了解更多信息。

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