zig

commit 2dd7c6b268a838d4a130ac2eb88f4267598bb42e (tree)
parent e66190025ffab39527da601980b7e3211069b6f5
Author: Michael Dusan <michael.dusan@gmail.com>
Date:   Tue, 25 Jul 2023 21:44:11 -0400

linux: do not set stack size hard limit

At main startup, if the ELF auxiliary vector contains a stacksize value,
use it as a hint for the minimum stacksize required by the executable.

1. Never lower the hard-limit. Once a hard-limit is lowered, then it can
   never be increased (including child processes).

2. If hint exceeds hard-limit then clamp hint to hard-limit.

3. If soft-limit exceeds hint then do nothing.

Diffstat:
M
lib/std/start.zig
 | 
39
+++++++++++++++++++++++----------------

1 file changed, 23 insertions(+), 16 deletions(-)
diff --git a/lib/std/start.zig b/lib/std/start.zig
@@ -459,22 +459,29 @@ fn expandStackSize(phdrs: []elf.Phdr) void {
     for (phdrs) |*phdr| {
         switch (phdr.p_type) {
             elf.PT_GNU_STACK => {
-                const wanted_stack_size = phdr.p_memsz;
-                assert(wanted_stack_size % std.mem.page_size == 0);
-
-                std.os.setrlimit(.STACK, .{
-                    .cur = wanted_stack_size,
-                    .max = wanted_stack_size,
-                }) catch {
-                    // Because we could not increase the stack size to the upper bound,
-                    // depending on what happens at runtime, a stack overflow may occur.
-                    // However it would cause a segmentation fault, thanks to stack probing,
-                    // so we do not have a memory safety issue here.
-                    // This is intentional silent failure.
-                    // This logic should be revisited when the following issues are addressed:
-                    // https://github.com/ziglang/zig/issues/157
-                    // https://github.com/ziglang/zig/issues/1006
-                };
+                assert(phdr.p_memsz % std.mem.page_size == 0);
+
+                // Silently fail if we are unable to get limits.
+                const limits = std.os.getrlimit(.STACK) catch break;
+
+                // Clamp to limits.max .
+                const wanted_stack_size = @min(phdr.p_memsz, limits.max);
+
+                if (wanted_stack_size > limits.cur) {
+                    std.os.setrlimit(.STACK, .{
+                        .cur = wanted_stack_size,
+                        .max = limits.max,
+                    }) catch {
+                        // Because we could not increase the stack size to the upper bound,
+                        // depending on what happens at runtime, a stack overflow may occur.
+                        // However it would cause a segmentation fault, thanks to stack probing,
+                        // so we do not have a memory safety issue here.
+                        // This is intentional silent failure.
+                        // This logic should be revisited when the following issues are addressed:
+                        // https://github.com/ziglang/zig/issues/157
+                        // https://github.com/ziglang/zig/issues/1006
+                    };
+                }
                 break;
             },
             else => {},