Question

Is there a max size for a char buffer? I have a program that is collecting strings for a char buffer and writing it to a proc file. After a certain point it appears to stop writing things – is there too much in there? What is that max size so I can work around this?

Here is code. This is an LKM – is limits.h available from kernel space?

Foremost:

const char* input = "hooloo\n";

Next:

int read_info( char *page, char **start, off_t off, int count, int *eof, void *data )
{

    unsigned int mem;
    char answer_buf[strlen(input) + 1 + 14];
    name_added = vmalloc(strlen(input) + 1 + 14);
    strcpy(name_added, input);
    strcat(name_added, extension);
    mem = sprintf(answer_buf, "%s\n", name_added);
    memcpy(page, answer_buf, mem);
    return strlen(answer_buf) + 1;
}

All in my code are things like this are things that remalloc the buffer and add to it. Also, that read_info is for the procfile. This issue is I keep adding to that buffer with the code above over and over and over – eventually I ca my procfile and the text cuts off – it doesn’t go on forever like i want )-=.

Answer 1

There’s no concrete maximum size “in C” specifically. Theoretical (or “potential”) maximum size of any object on a C platform is determined by the implementation and is usually derived from the properties of the underlying machine platform and OS.

On platforms with flat memory model it will typically be limited by the size of the address space in theory, and by the size of the available free memory (or that specific kind) in practice.

On platforms with segmented memory model it might be limited by the segment size, which is smaller than the address space size. Although implementations are free to breach that limit by “emulating” flat memory model in the code. For that reason on such platforms the maximum object size can also depend on compilation settings.