Максимальный суммарный размер argv, envp, argc (аргументов командной строки) всегда далек от предела ARG_MAX.

TL;DR Проблемы вызваны ASLR (рандомизация макета адресного пространства). Объяснение см. в разделе ОБНОВЛЕНИЕ ниже [после моего исходного ответа].

Как упомянул паладин, это зависит от системы. Например, для freebsd число намного меньше.

Несколько вещей, на которые стоит обратить внимание [в Linux] ...

ARG_MAX определяется как 131072 [что составляет 32 страницы по 4 КБ].

_SC_ARG_MAX возвращает 2097152 [что составляет 2 МБ]

Претензия в bits/param.h:

Заголовки ядра определяют ARG_MAX. Однако значение неверное.

Однако, судя по измерениям, это правильно.

Из кода в linux/fs/exec.c он проверяет [зашитое] значение ARG_MAX. Он также проверяет _STK_LIM [который составляет 8 МБ] и 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 использует метод системного вызова для вызова подпрограммы способом, подобным командному интерпретатору.

См.: https://askubuntu.com/questions/318315/how-can-i-temporari-disable-aslr-address-space-layout-randomization и Отключить рандомизацию адресов памяти

ASLR устанавливает случайные начальные позиции для начального/наибольшего адреса стека, envp, argv, и начальной позиции/кадра стека, присвоенного main.

То, что кажется неиспользуемым пространством, является функцией этого размещения и заполнения/выравнивания. Таким образом, пространство на самом деле не является неиспользуемым (т.е. потенциально пригодным для использования).

Даже с теми же точными аргументами, переданными дочернему элементу, адреса меняются при включенном ASLR.

Я знал о ASLR, но не был уверен, применимо ли оно здесь (в стеке) [сначала].

Прежде чем я понял связь, я расширил свою программу, чтобы посмотреть и сравнить некоторые из этих различных адресов и смещений между ними.

Однако при включенном ASLR, если мы запустим дочерний элемент несколько [много ;-)] раз, даже если два или более запусков совпадают по некоторым из одних и тех же начальных адресов (например, самый высокий адрес стека) другое параметры могут по-прежнему варьироваться независимо друг от друга.

Итак, я расширил программу, чтобы опционально отключить ASLR с помощью системного вызова personality, и, когда он отключен, каждый запуск имеет одно и то же размещение и смещения.

Моя рефакторинговая программа находится на пределе того, что можно разместить здесь в блоке кода, поэтому вот ссылка: https://pastebin.com/gYwRFvcv [Обычно я этого не делаю — см. раздел ниже, почему].

У этой программы есть много вариантов, так как я провел ряд экспериментов, прежде чем пришел к своим выводам.

Параметр -A отключит ASLR. Попробуйте запустить его с -x100000 -Ma@ [с/без] -A.

Еще одна хорошая комбинация — добавить -L к предыдущему. Это отменяет бинарный поиск в пользу единственной длины аргумента, которая находится в пределах разумного размера.

См. комментарии в коде для получения дополнительной информации.

При этом вы можете поэкспериментировать дальше, если это необходимо [или дать вам некоторые идеи], чтобы изменить свою собственную программу.