20 Aug
2019
20 Aug
'19
9:10 p.m.
This is probably the place to ask:
I understand why the shell builtin "exec" is the same as the syscall exec()
in the sense of "replace this process with that one." But why is it also
the way to redirect filehandles in the current shell? (That is, why isn't
the redirection named something else?)
Adam
20 Aug
20 Aug
10 p.m.
On Tue, Aug 20, 2019 at 02:10:55PM -0700, Adam Thornton wrote:
This is probably the place to ask:
I understand why the shell builtin "exec" is the same as the syscall
exec() in the sense of "replace this process with that one." But why
is it also the way to redirect filehandles in the current shell? (That
is, why isn't the redirection named something else?)
exec() doesn't do anything with file handles; it simply replaces the
executable code in the current process. Here's the pseudo-code for a
shell where redirection is done.
int pid; /* Holds the process-id of the child */
switch (pid = fork()) /* Call fork, and test what it returns */
{
case -1: printf("The fork failed\n"); return (-1);
case 0: /* The child is given a value of 0 from fork() */
/* Do special things like closing files etc. */
if (redirection required) {
close my standard output;
open the named output file as my standard output;
}
/* Replace ourselves with the real child */
/* Call execvp */
execlp(command, arg1, arg2, ..., NULL);
exit(1); /* Exec failed, indicate error */
default: /* The parent receives the new process-id from fork() */
wait(); /* Wait for child to exit */
}
So the child shell itself does the redirection after the fork(), but before
it replaces itself with the new executable code.
Cheers, Warren
21 Aug
21 Aug
12:38 a.m.
On 8/20/19 5:10 PM, Adam Thornton wrote:
This is probably the place to ask:
I understand why the shell builtin "exec" is the same as the syscall exec()
in the sense of "replace this process with that one." But why is it also
the way to redirect filehandles in the current shell? (That is, why isn't
the redirection named something else?)
It was probably a side effect that turned out to be useful. The `exec'
builtin performs redirections without a way to undo them, because why
bother, and executes its arguments as a command with arguments, as if it
were in a child process.
The original Bourne shell just performed the redirections and returned
if there weren't any arguments, leaving the non-undoable redirections
in place.
--
``The lyf so short, the craft so long to lerne.'' - Chaucer
``Ars longa, vita brevis'' - Hippocrates
Chet Ramey, UTech, CWRU chet(a)case.edu http://tiswww.cwru.edu/~chet/
1709
days inactive
1710
days old
2 comments
3 participants
participants (3)
-
Adam Thornton -
Chet Ramey -
Warren Toomey