Process.execv I don't understand

Help
1

Hello, I don’t understand why “os.execv” cancels the program.

 const args : [2][]const u8= .{prog,cmd };
 const e = std.process.execv(utl.allocUtl, args[0..]);
 debeug(3486, std.fmt.allocPrint(utl.allocUtl," err e {any}",.{e}) catch unreachable);

In “C”, everything works fine.

thank you

2

execv system call replaces the current process with the executed image.
To keep the parent process you need to fork your process and then call execv in the child process.

5 Likes
3

you ave exemple please
“It works, thank you. I used fork.”
sorry

astuce / Tip

	/// callPgm  (pgm  , module)  ex: Gen TerminalVte   module ex: Exemple
	pub fn callPgm(pgm : [] const  u8, module : [] const u8) void {
 
		
		const prog  = std.fmt.allocPrint(utl.allocUtl,"./{s}",.{pgm}) catch unreachable;
		defer utl.allocUtl.free(prog);

		const cmd  = std.fmt.allocPrint(utl.allocUtl,"./{s}",.{module}) catch unreachable;
		defer utl.allocUtl.free(cmd);
		const i:usize = 0;
		const pid = os.fork()  catch unreachable;
		if (pid == i) {
			const allocator = std.heap.page_allocator;
			const args : [2][]const u8= .{prog,cmd };
			std.process.execv(allocator, args[0..]) catch unreachable;
		}
 	}
1 Like
4

Don’t be sorry. You are always welcome.

2 Likes
5

I am very happy because, so far, I have been able to translate my code generator (curse) written in “C” or “Nim” without having to use another language and while keeping it very simple. At the same time, it allows me to explore the ins and outs of the “Zig” language. :grinning: :grinning: :grinning:

2 Likes
6

For a higher-level (and more portable) API you can also use std.ChildProcess.spawn() instead of calling fork() and execv() yourself.

By the way, you should reconsider using catch unreachable to ignore errors. unreachable is intended to inform the compiler that a particular branch is, in fact, unreachable (which is not something the compiler can always infer on its own).

When the branch is in fact reachable, as is the case here, then it leads to undefined behavior in release mode. For example, it’s quite likely that if fork() succeeds but execv() fails then you will have two copies of your original process running, which probably isn’t good.

An easy way to handle errors is to propagate them up with try, but if you don’t want to do that and just terminate the program if an error occurs, then the reliable way to do that is with catch @panic("execv() failed"), which works the same in debug and release modes.

4 Likes
9

solution

	/// callPgm( pgm, module)  ex: APPTERM (libVte)   module ex: Exemple
	pub fn callPgm(pgm : [] const  u8, module : [] const u8) ErrForms ! void {


		const prog  = std.fmt.allocPrint(utl.allocUtl,"./{s}",.{pgm}) catch unreachable;
		defer utl.allocUtl.free(prog);

		const cmd  = std.fmt.allocPrint(utl.allocUtl,"./{s}",.{module}) catch unreachable;
		defer utl.allocUtl.free(cmd);

		// Retrieval of the working library.
		var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
		const cwd = std.os.getcwd(&buf) catch unreachable;

		// Initialization of the process (calling a program, and parameter).
		const allocChild = std.heap.page_allocator;
		const args : [2][]const u8= .{prog,cmd };
		var CallModule : std.ChildProcess = std.ChildProcess.init(args[0..], allocChild) ;

		//The set of modules is located in the manager's library, for example: (APPTERM).
		CallModule.cwd = cwd;

		// Execution and suspension of the caller.
		const childTerm = std.ChildProcess.spawnAndWait(&CallModule) catch unreachable;

		// Error handling is provided to the calling procedure.
		switch (childTerm) {
		.Exited => |code| { if (code != 0) return ErrForms.Module_Invalid ; },
		else => unreachable,
		}

	}
1 Like