如何释放申请的内存问题？

[zhang-chuanfeng]

如下代码实现fork执行exec程序代码：中间申请的buff如何释放掉？怎么感觉写起来没这么方便，应该有更好的实现方式吧？感觉比c写的代码要繁琐
比如下面的执行结果：

./process 
%% /usr/bin/ls ./
/usr/bin/ls
token.len=11, buff.len=12
token.len=11, buff.len=12
./
token.len=2, buff.len=3
token.len=2, buff.len=3
i=2
argv.len=3
Makefile  filetype.zig  process  process.o  process.zig
%%

const std = @import("std");

fn signalHandler(sig: i32) align(1) callconv(.C) void {
    std.debug.print("Received signal {}\n", .{sig});
    std.os.linux.exit(-1);
}

fn signal(sig: u6, handler_fun: std.os.linux.Sigaction.handler_fn) void {
    const sigAction = std.os.linux.sigaction;
    var action = std.os.linux.Sigaction{ .handler = undefined, .mask = std.os.linux.empty_sigset, .flags = 0 };
    action.handler.handler = handler_fun;
    _ = sigAction(sig, &action, null);
}

pub fn main() !void {
    signal(std.os.linux.SIG.INT, signalHandler);
    std.debug.print("%% ", .{});

    const allocator = std.heap.page_allocator;
    const stdin = std.io.getStdIn().reader();

    var pid: usize = undefined;
    var status: u32 = undefined;
    while (true) {
        const line = try stdin.readUntilDelimiterAlloc(allocator, '\n', 1024);
        pid = std.os.linux.fork();
        if (pid < 0) {
            std.debug.print("fork error", .{});
            std.os.linux.exit(-1);
        } else if (pid == 0) {
            // child
            var args: [:null]?[*:0]const u8 = undefined;
            const envp = [_:null]?[*:0]const u8{null};

            const argv_tmp = try std.heap.page_allocator.alloc(?[*:0]const u8, 10);
            defer std.heap.page_allocator.free(argv_tmp);

            var tokenIter = std.mem.tokenize(u8, line, " \t\n\r");
            var i: usize = 0;
            while (tokenIter.next()) |token| : (i += 1) {
                if (i >= 9) break;
                std.debug.print("{s}\n", .{token});
                var buff = try std.heap.page_allocator.alloc(u8, token.len + 1);
                // defer std.heap.page_allocator.free(buff);
                std.debug.print("token.len={d}, buff.len={d}\n", .{ token.len, buff.len });
                buff[token.len] = 0;
                std.debug.print("token.len={d}, buff.len={d}\n", .{ token.len, buff.len });
                buff.len = token.len;
                @memcpy(buff, token);
                buff.len = token.len + 1;
                argv_tmp[i] = buff[0..token.len :0];
            }
            defer {
                var j: usize = 0;
                while (j < argv_tmp.len) : (j += 1) {
                    if (argv_tmp[j] != null) {
                        // 如何释放上面 buff的内存
                        // std.heap.page_allocator.free(argv_tmp[j].?.*);
                    }
                }
            }
            const argv = try std.heap.page_allocator.alloc(?[*:0]const u8, i + 1);
            defer std.heap.page_allocator.free(argv);
            argv[i] = null;
            std.debug.print("i={d}\n", .{i});
            std.debug.print("argv.len={d}\n", .{argv.len});
            while (i > 0) : (i -= 1) {
                argv[argv.len - 1 - i] = argv_tmp[argv.len - 1 - i];
            }

            args = argv[0 .. argv.len - 1 :null];
            _ = std.os.linux.execve(argv[0].?, args.ptr, &envp);
            std.debug.panic("couldn't execute: {s}", .{line});
            std.os.linux.exit(127);
        }

        pid = std.os.linux.waitpid(@intCast(pid), &status, 0);
        if (pid < 0) {
            std.debug.panic("waitpid fail", .{});
        }
        std.debug.print("%% ", .{});
    }
    // test execve()
    // const args = [_:null]?[*:0]const u8{ "ls".ptr, "-l".ptr, "./".ptr, null };
    // const envp = [_:null]?[*:0]const u8{null};
    // _ = std.os.linux.execve("/usr/bin/ls".ptr, &args, &envp);
    // std.os.linux.fork()
    // std.time.sleep(100 * std.time.ns_per_hour);
}

c的代码实现

static void sig_int(int);

int main(void) {
    char buf[MAXLINE];
    pid_t pid;
    int status;

    if (signal(SIGINT, sig_int) == SIG_ERR)
        err_sys("signal error");

    printf("%% ");
    while (fgets(buf, MAXLINE, stdin) != NULL) {
        if (buf[strlen(buf) - 1] == '\n')
            buf[strlen(buf) - 1] = 0;

        if ((pid = fork()) < 0) {
            err_sys("fork error");
        } else if (pid == 0) { /* child */
            execlp(buf, buf, (char *)0);
            err_ret("couldn't execute: %s", buf);
            exit(127);
        }

        // parent
        if ((pid = waitpid(pid, &status, 0)) < 0)
            err_sys("waitpid error");

        printf("%% ");
    }

    exit(0);
}

void sig_int(int signo) {
    printf("interrupt\n%% ");
    fflush(stdout);
}

[jiacai2050]

const std = @import("std");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer if (gpa.deinit() != .ok) @panic("leak");
    const allocator = gpa.allocator();

    const stdin = std.io.getStdIn();
    var rdr = stdin.reader();
    var list = std.ArrayList(u8).init(allocator);
    defer list.deinit();
    const wtr = list.writer();
    while (rdr.streamUntilDelimiter(wtr, '\n', null)) {
        if (std.mem.eql(u8, "exit", list.items)) {
            return;
        }
        defer list.clearRetainingCapacity();

        var iterator = std.mem.tokenizeAny(u8, list.items, "\t \r");
        var args = std.ArrayList([]const u8).init(allocator);
        defer args.deinit();
        while (iterator.next()) |arg| {
            try args.append(arg);
        }
        var cp = std.ChildProcess.init(args.items, allocator);
        const term = cp.spawnAndWait();
        std.debug.print("{any}\n", .{term});
    } else |e| {
        std.debug.print("Read stdin failed, err:{any}\n", .{e});
        std.posix.exit(1);
    }
}

尝试用纯 Zig 的方式来写，会简单不少，你现在的做法相当于完全 port C 的逻辑，很多 Zig 的特点没用上。

[zhang-chuanfeng]

ok 感谢。如何找这方面的资料，可能写的少看的少。

[jiacai2050]

https://ziglang.cc/
这里有些学习资料，此外，可以多看看 std 的源码，比社区其他项目的质量要好不少。

[zhang-chuanfeng]

参考后修改：

const std = @import("std");

fn signalHandler(sig: i32) align(1) callconv(.C) void {
    std.debug.print("Received signal {}\n", .{sig});
    std.os.linux.exit(-1);
}

fn signal(sig: u6, handler_fun: std.os.linux.Sigaction.handler_fn) void {
    const sigAction = std.os.linux.sigaction;
    var action = std.os.linux.Sigaction{ .handler = undefined, .mask = std.os.linux.empty_sigset, .flags = 0 };
    action.handler.handler = handler_fun;
    _ = sigAction(sig, &action, null);
}

pub fn main() !void {
    signal(std.os.linux.SIG.INT, signalHandler);
    std.debug.print("%% ", .{});

    const allocator = std.heap.page_allocator;
    const stdin = std.io.getStdIn().reader();

    var pid: usize = undefined;
    var status: u32 = undefined;
    while (true) {
        const line = try stdin.readUntilDelimiterAlloc(allocator, '\n', 1024);
        pid = std.os.linux.fork();
        if (pid < 0) {
            std.debug.print("fork error", .{});
            std.os.linux.exit(-1);
        } else if (pid == 0) {
            // child
            const envp = [_:null]?[*:0]const u8{ "PATH=/usr/bin:/bin".ptr, null };

            var tokenIter = std.mem.tokenize(u8, line, " \t\n\r");

            // 使用ArrayList自动增长
            var argvs = std.ArrayList([]const u8).init(allocator);
            defer argvs.deinit();
            while (tokenIter.next()) |token| {
                try argvs.append(token);
            }
            // 这里参考 std.ChildProcess.spawnPosix()
            // 使用allocSentinel 和  dupeZ
            const argv_buf = try std.heap.page_allocator.allocSentinel(?[*:0]const u8, argvs.items.len, null);
            defer std.heap.page_allocator.free(argv_buf);
            for (argvs.items, 0..) |arg, i| argv_buf[i] = (try allocator.dupeZ(u8, arg)).ptr;

            _ = std.os.linux.execve(argv_buf.ptr[0].?, argv_buf.ptr, &envp);
            std.debug.panic("couldn't execute: {s}", .{line});
            std.os.linux.exit(127);
        }

        pid = std.os.linux.waitpid(@intCast(pid), &status, 0);
        if (pid < 0) {
            std.debug.panic("waitpid fail", .{});
        }
        std.debug.print("%% ", .{});
    }
    // test execve()
    // const args = [_:null]?[*:0]const u8{ "ls".ptr, "-l".ptr, "./".ptr, null };
    // const envp = [_:null]?[*:0]const u8{null};
    // _ = std.os.linux.execve("/usr/bin/ls".ptr, &args, &envp);
    // std.os.linux.fork()
    // std.time.sleep(100 * std.time.ns_per_hour);
}

[jiacai2050]

上面代码 argv_buf 还是有内存泄漏（它本身释放了，但是它里面的每一项元素没有），std 使用 arena 来规避这个问题的：https://github.com/ziglang/zig/blob/6a65561e3e5f82f126ec4795e5cd9c07392b457b/lib/std/child_process.zig#L567

[zhang-chuanfeng]

哦哦 dupeZ里面alloc了

const std = @import("std");

fn signalHandler(sig: i32) align(1) callconv(.C) void {
    std.debug.print("Received signal {}\n", .{sig});
    std.os.linux.exit(-1);
}

fn signal(sig: u6, handler_fun: std.os.linux.Sigaction.handler_fn) void {
    const sigAction = std.os.linux.sigaction;
    var action = std.os.linux.Sigaction{ .handler = undefined, .mask = std.os.linux.empty_sigset, .flags = 0 };
    action.handler.handler = handler_fun;
    _ = sigAction(sig, &action, null);
}

// 可以参考std.ChildProcess

pub fn main() !void {
    signal(std.os.linux.SIG.INT, signalHandler);
    std.debug.print("%% ", .{});

    const allocator = std.heap.page_allocator;
    const stdin = std.io.getStdIn().reader();

    var pid: usize = undefined;
    var status: u32 = undefined;
    while (true) {
        const line = try stdin.readUntilDelimiterAlloc(allocator, '\n', 1024);
        pid = std.os.linux.fork();
        if (pid < 0) {
            std.debug.print("fork error", .{});
            std.os.linux.exit(-1);
        } else if (pid == 0) {
            // child
            const envp = [_:null]?[*:0]const u8{ "PATH=/usr/bin:/bin".ptr, null };
            // const envp = @as([*:null]const ?[*:0]const u8, @ptrCast(std.os.environ.ptr));
            // const envp = std.c.environ;

            var tokenIter = std.mem.tokenize(u8, line, " \t\n\r");

            // 使用ArrayList自动增长
            var argvs = std.ArrayList([]const u8).init(allocator);
            defer argvs.deinit();
            while (tokenIter.next()) |token| {
                try argvs.append(token);
            }
            // 这里参考 std.ChildProcess.spawnPosix()
            // 使用allocSentinel 和  dupeZ
            const argv_buf = try std.heap.page_allocator.allocSentinel(?[*:0]const u8, argvs.items.len, null);
            defer std.heap.page_allocator.free(argv_buf);
            var arena_allocator = std.heap.ArenaAllocator.init(allocator);
            defer arena_allocator.deinit();
            const arena = arena_allocator.allocator();
            for (argvs.items, 0..) |arg, i| argv_buf[i] = (try arena.dupeZ(u8, arg)).ptr;

            // 第一个参数需要使用绝对路径 std.ChildProcess使用的是searchPath
            _ = std.os.linux.execve(argv_buf.ptr[0].?, argv_buf.ptr, &envp);
            std.debug.panic("couldn't execute: {s}", .{line});
            std.os.linux.exit(127);
        }

        pid = std.os.linux.waitpid(@intCast(pid), &status, 0);
        if (pid < 0) {
            std.debug.panic("waitpid fail", .{});
        }
        std.debug.print("%% ", .{});
    }
    // test execve()
    // const args = [_:null]?[*:0]const u8{ "ls".ptr, "-l".ptr, "./".ptr, null };
    // const envp = [_:null]?[*:0]const u8{null};
    // _ = std.os.linux.execve("/usr/bin/ls".ptr, &args, &envp);
    // std.os.linux.fork()
    // std.time.sleep(100 * std.time.ns_per_hour);
}