WFrame | A font-end frame base on gulp | Frontend Framework library

I'm not familiar with the code base, so I don't see any obvious variables that would be taking large amounts of stack space. However, I notice that the functions (including the always_inlined) are quite long. Typically, in debug builds, every variable and temporary expression result is assigned a unique space in the stack frame, regardless of scope. So even if 2 variables' lifetimes do not overlap (e.g. one is declared in the if block, and another in the else block) they will be allocated separate spaces in memory. So this can add up even if there are a lot of small short-lived variables and temporary values.

You are probably best off disabling always_inline attributes in all functions called by this function in debug builds, as this avoids pre-allocating memory for all possible branches of execution even if they are never taken, or if they are declared in a function that's not involved in the recursion.

If your kernel module is including the header from /usr/include/linux, something is indeed going wrong there: the files in /usr/include/linux are for use by userland applications (see What's the difference between /usr/include/linux and the include folder in linux kernel source?), not kernel modules.

Instead, your module should be including the header file in the kernel source.

For what it's worth, that seems to be the default on my system. If I compile this not-a-kernel-module:

You need to use printk, not printf. Its definition is in linux/printk.h, not stdio.h.

Please include these details in your question the next time you ask.

The reason your build is not able to find stdio.h is because it's not available in the kernel sources, and you're compiling with -nostdinc. -nostdinc causes all the default search paths to be ignored.

1. The compiler will generate code that calls functions in libgcc in order to perform certain operations. In this case, they are being called to perform the regular division (/) and modulo (%) operations on 64-bit quantities.

2. Correct, the kernel doesn't use libgcc. Kernel code needs to be written to prevent the compiler making calls to functions in libgcc (in this case for division and module operations on 64-bit quantities).

3. Any code that does division or modulo operations on 64-bit quantities (apart from the native signed and unsigned long types on 64-bit architectures) needs to be rewritten to use special 64-bit division functions and macros provided by the Linux kernel instead of the regular / and % operators.

   In the old days, this was done by calling the do_div(n,base) macro defined by #include , but that has an unusual, non-functionlike interface in that it modifies the caller's n parameter in place to become the dividend n / base in addition to returning the remainder n % base.

   For new code, it is better to avoid the old do_div(n,base) macro and make use of the functions declared by #include . There are various functions defined there for signed and unsigned arguments and for both 32-bit and 64-bit remainders. You need to pick the most appropriate function to match the requirements of your code.

Properties on source files like COMPILE_DEFINITIONS and COMPILE_FLAGS may only add a compile option. Using these properties it is impossible to overwrite (delete) compile options for the target. (And options added by ADD_COMPILE_OPTIONS are eventually assigned for the target).

You may create an OBJECT library from thrift-generated sources. For that library you may set (that is, clear) COMPILE_OPTIONS property. Resulted object files can be used then in your main library:

OK, I finnally found a solution : I had a pretty old version of guest addition (4.1.4) so i downloaded a newer version (4.2.38) here (guest addition.iso) and it worked fine !

The stack size is well documented and the above is not the right way to test, in particular in older kernels which used hugepages to back the stack the aforementioned code would jump over to the next stack.

The func __crash_stack_init with prink commented out is a leaf function - it does not call anything, so the compiler knows exactly what happens with local vars. In particular in this code it sees the full array is not needed and thus its not being allocated. However, the call to printk passes arr in. The compiler does not know what the func is going to do with it, thus it has to reserve 1024 * sizeof(long) on the stack which results in the warning.

Stacks got bumped to 16KB years ago, you can start reading here https://lwn.net/Articles/600644/