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

Question

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

Min*_*Max 3 c linux bash linux-kernel execve

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

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

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

问题：

计数程序不正确并且缺少某些值？为什么“参数列表太长”发生得比它应该的早？
这是正常行为，未使用的字节是内存填充/对齐/什么类型的？那么在内核源代码中哪里提到了这种行为？我已经阅读了linux/fs/exec.c并且没有看到可以回答我的问题的内容。

程序

计数算法如下：

尺寸argv+ 尺寸envp+ 尺寸argc

的argv是一个指针阵列，以字符串（指针char），因此循环通过此阵列，并加入到一个结果字符串的长度，牢记每个由NULL字节结束。然后将它们的指针添加到结果 - 指针的大小为 8 字节。因此：the number of pointers * 8+lengths of strings (each with a NULL byte)
与envp- 字符串长度与 NULL 字节和指针几乎相同。但是最后一个指针通过指向 NULL 字节来表示数组的末尾，因此将其添加到 result 中8 bytes + 1 bytes。
该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;
}

Run Code Online (Sandbox Code Playgroud)

测试

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

Run Code Online (Sandbox Code Playgroud)

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

Run Code Online (Sandbox Code Playgroud)

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

Run Code Online (Sandbox Code Playgroud)

这个问题是我的另一个问题的一部分：如何计算可以作为参数传递给批处理命令的文件数量？

Answer 1

Cra*_*tey 6

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. 它还检查_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;
}

Run Code Online (Sandbox Code Playgroud)

这是程序输出：

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

Run Code Online (Sandbox Code Playgroud)

更新：

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

有几种方法可以禁用 ASLR：

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

请参阅：https : //askubuntu.com/questions/318315/how-can-i-temporously-disable-aslr-address-space-layout-randomization和禁用内存地址随机化

ASLR 为起始/最高堆栈地址设置随机起始位置，envp，argv，以及给定的起始堆栈位置/帧main。

看似“未使用”的空间是该放置和填充/对齐的函数。所以，空间真的没有被使用（即可能可用）。

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

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

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

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

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

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

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

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

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

有关更多信息，请参阅代码中的注释。

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

归档时间：	5 年，4 月前
查看次数：	424 次
最近记录：	5 年前