void exec( job_t *j ) { process_t *p; pid_t pid; int mypipe[2]; sigset_t chldset; int skip_fork; io_data_t pipe_read, pipe_write; io_data_t *tmp; io_data_t *io_buffer =0; /* Set to 1 if something goes wrong while exec:ing the job, in which case the cleanup code will kick in. */ int exec_error=0; int needs_keepalive = 0; process_t keepalive; CHECK( j, ); CHECK_BLOCK(); if( no_exec ) return; sigemptyset( &chldset ); sigaddset( &chldset, SIGCHLD ); debug( 4, L"Exec job '%ls' with id %d", j->command, j->job_id ); if( block_io ) { if( j->io ) { j->io = io_add( io_duplicate( j, block_io), j->io ); } else { j->io=io_duplicate( j, block_io); } } io_data_t *input_redirect; for( input_redirect = j->io; input_redirect; input_redirect = input_redirect->next ) { if( (input_redirect->io_mode == IO_BUFFER) && input_redirect->is_input ) { /* Input redirection - create a new gobetween process to take care of buffering */ process_t *fake = halloc( j, sizeof(process_t) ); fake->type = INTERNAL_BUFFER; fake->pipe_write_fd = 1; j->first_process->pipe_read_fd = input_redirect->fd; fake->next = j->first_process; j->first_process = fake; break; } } if( j->first_process->type==INTERNAL_EXEC ) { /* Do a regular launch - but without forking first... */ signal_block(); /* setup_child_process makes sure signals are properly set up. It will also call signal_unblock */ if( !setup_child_process( j, 0 ) ) { /* launch_process _never_ returns */ launch_process( j->first_process ); } else { job_set_flag( j, JOB_CONSTRUCTED, 1 ); j->first_process->completed=1; return; } } pipe_read.fd=0; pipe_write.fd=1; pipe_read.io_mode=IO_PIPE; pipe_read.param1.pipe_fd[0] = -1; pipe_read.param1.pipe_fd[1] = -1; pipe_read.is_input = 1; pipe_write.io_mode=IO_PIPE; pipe_write.is_input = 0; pipe_read.next=0; pipe_write.next=0; pipe_write.param1.pipe_fd[0]=pipe_write.param1.pipe_fd[1]=-1; j->io = io_add( j->io, &pipe_write ); signal_block(); /* See if we need to create a group keepalive process. This is a process that we create to make sure that the process group doesn't die accidentally, and is often needed when a builtin/block/function is inside a pipeline, since that usually means we have to wait for one program to exit before continuing in the pipeline, causing the group leader to exit. */ if( job_get_flag( j, JOB_CONTROL ) ) { for( p=j->first_process; p; p = p->next ) { if( p->type != EXTERNAL ) { if( p->next ) { needs_keepalive = 1; break; } if( p != j->first_process ) { needs_keepalive = 1; break; } } } } if( needs_keepalive ) { keepalive.pid = exec_fork(); if( keepalive.pid == 0 ) { keepalive.pid = getpid(); set_child_group( j, &keepalive, 1 ); pause(); exit(0); } else { set_child_group( j, &keepalive, 0 ); } } /* This loop loops over every process_t in the job, starting it as appropriate. This turns out to be rather complex, since a process_t can be one of many rather different things. The loop also has to handle pipelining between the jobs. */ for( p=j->first_process; p; p = p->next ) { mypipe[1]=-1; skip_fork=0; pipe_write.fd = p->pipe_write_fd; pipe_read.fd = p->pipe_read_fd; // debug( 0, L"Pipe created from fd %d to fd %d", pipe_write.fd, pipe_read.fd ); /* This call is used so the global environment variable array is regenerated, if needed, before the fork. That way, we avoid a lot of duplicate work where EVERY child would need to generate it, since that result would not get written back to the parent. This call could be safely removed, but it would result in slightly lower performance - at least on uniprocessor systems. */ if( p->type == EXTERNAL ) env_export_arr( 1 ); /* Set up fd:s that will be used in the pipe */ if( p == j->first_process->next ) { j->io = io_add( j->io, &pipe_read ); } if( p->next ) { // debug( 1, L"%ls|%ls" , p->argv[0], p->next->argv[0]); if( exec_pipe( mypipe ) == -1 ) { debug( 1, PIPE_ERROR ); wperror (L"pipe"); exec_error=1; break; } memcpy( pipe_write.param1.pipe_fd, mypipe, sizeof(int)*2); } else { /* This is the last element of the pipeline. Remove the io redirection for pipe output. */ j->io = io_remove( j->io, &pipe_write ); } switch( p->type ) { case INTERNAL_FUNCTION: { const wchar_t * orig_def; wchar_t * def=0; array_list_t *named_arguments; int shadows; /* Calls to function_get_definition might need to source a file as a part of autoloading, hence there must be no blocks. */ signal_unblock(); orig_def = function_get_definition( p->argv[0] ); named_arguments = function_get_named_arguments( p->argv[0] ); shadows = function_get_shadows( p->argv[0] ); signal_block(); if( orig_def ) { def = halloc_register( j, wcsdup(orig_def) ); } if( def == 0 ) { debug( 0, _( L"Unknown function '%ls'" ), p->argv[0] ); break; } parser_push_block( shadows?FUNCTION_CALL:FUNCTION_CALL_NO_SHADOW ); current_block->param2.function_call_process = p; current_block->param1.function_call_name = halloc_register( current_block, wcsdup( p->argv[0] ) ); /* set_argv might trigger an event handler, hence we need to unblock signals. */ signal_unblock(); parse_util_set_argv( p->argv+1, named_arguments ); signal_block(); parser_forbid_function( p->argv[0] ); if( p->next ) { io_buffer = io_buffer_create( 0 ); j->io = io_add( j->io, io_buffer ); } internal_exec_helper( def, TOP, j->io ); parser_allow_function(); parser_pop_block(); break; } case INTERNAL_BLOCK: { if( p->next ) { io_buffer = io_buffer_create( 0 ); j->io = io_add( j->io, io_buffer ); } internal_exec_helper( p->argv[0], TOP, j->io ); break; } case INTERNAL_BUILTIN: { int builtin_stdin=0; int fg; int close_stdin=0; /* If this is the first process, check the io redirections and see where we should be reading from. */ if( p == j->first_process ) { io_data_t *in = io_get( j->io, 0 ); if( in ) { switch( in->io_mode ) { case IO_FD: { builtin_stdin = in->param1.old_fd; break; } case IO_PIPE: { builtin_stdin = in->param1.pipe_fd[0]; break; } case IO_FILE: { builtin_stdin=wopen( in->param1.filename, in->param2.flags, OPEN_MASK ); if( builtin_stdin == -1 ) { debug( 1, FILE_ERROR, in->param1.filename ); wperror( L"open" ); } else { close_stdin = 1; } break; } case IO_CLOSE: { /* FIXME: When requesting that stdin be closed, we really don't do anything. How should this be handled? */ builtin_stdin = -1; break; } default: { builtin_stdin=-1; debug( 1, _( L"Unknown input redirection type %d" ), in->io_mode); break; } } } } else { builtin_stdin = pipe_read.param1.pipe_fd[0]; } if( builtin_stdin == -1 ) { exec_error=1; break; } else { int old_out = builtin_out_redirect; int old_err = builtin_err_redirect; /* Since this may be the foreground job, and since a builtin may execute another foreground job, we need to pretend to suspend this job while running the builtin, in order to avoid a situation where two jobs are running at once. The reason this is done here, and not by the relevant builtins, is that this way, the builtin does not need to know what job it is part of. It could probably figure that out by walking the job list, but it seems more robust to make exec handle things. */ builtin_push_io( builtin_stdin ); builtin_out_redirect = has_fd( j->io, 1 ); builtin_err_redirect = has_fd( j->io, 2 ); fg = job_get_flag( j, JOB_FOREGROUND ); job_set_flag( j, JOB_FOREGROUND, 0 ); signal_unblock(); p->status = builtin_run( p->argv, j->io ); builtin_out_redirect=old_out; builtin_err_redirect=old_err; signal_block(); /* Restore the fg flag, which is temporarily set to false during builtin execution so as not to confuse some job-handling builtins. */ job_set_flag( j, JOB_FOREGROUND, fg ); } /* If stdin has been redirected, close the redirection stream. */ if( close_stdin ) { exec_close( builtin_stdin ); } break; } } if( exec_error ) { break; } switch( p->type ) { case INTERNAL_BLOCK: case INTERNAL_FUNCTION: { int status = proc_get_last_status(); /* Handle output from a block or function. This usually means do nothing, but in the case of pipes, we have to buffer such io, since otherwise the internal pipe buffer might overflow. */ if( !io_buffer ) { /* No buffer, so we exit directly. This means we have to manually set the exit status. */ if( p->next == 0 ) { proc_set_last_status( job_get_flag( j, JOB_NEGATE )?(!status):status); } p->completed = 1; break; } j->io = io_remove( j->io, io_buffer ); io_buffer_read( io_buffer ); if( io_buffer->param2.out_buffer->used != 0 ) { pid = exec_fork(); if( pid == 0 ) { /* This is the child process. Write out the contents of the pipeline. */ p->pid = getpid(); setup_child_process( j, p ); exec_write_and_exit(io_buffer->fd, io_buffer->param2.out_buffer->buff, io_buffer->param2.out_buffer->used, status); } else { /* This is the parent process. Store away information on the child, and possibly give it control over the terminal. */ p->pid = pid; set_child_group( j, p, 0 ); } } else { if( p->next == 0 ) { proc_set_last_status( job_get_flag( j, JOB_NEGATE )?(!status):status); } p->completed = 1; } io_buffer_destroy( io_buffer ); io_buffer=0; break; } case INTERNAL_BUFFER: { pid = exec_fork(); if( pid == 0 ) { /* This is the child process. Write out the contents of the pipeline. */ p->pid = getpid(); setup_child_process( j, p ); exec_write_and_exit( 1, input_redirect->param2.out_buffer->buff, input_redirect->param2.out_buffer->used, 0); } else { /* This is the parent process. Store away information on the child, and possibly give it control over the terminal. */ p->pid = pid; set_child_group( j, p, 0 ); } break; } case INTERNAL_BUILTIN: { int skip_fork; /* Handle output from builtin commands. In the general case, this means forking of a worker process, that will write out the contents of the stdout and stderr buffers to the correct file descriptor. Since forking is expensive, fish tries to avoid it wehn possible. */ /* If a builtin didn't produce any output, and it is not inside a pipeline, there is no need to fork */ skip_fork = ( !sb_out->used ) && ( !sb_err->used ) && ( !p->next ); /* If the output of a builtin is to be sent to an internal buffer, there is no need to fork. This helps out the performance quite a bit in complex completion code. */ io_data_t *io = io_get( j->io, 1 ); int buffer_stdout = io && io->io_mode == IO_BUFFER; if( ( !sb_err->used ) && ( !p->next ) && ( sb_out->used ) && ( buffer_stdout ) ) { char *res = wcs2str( (wchar_t *)sb_out->buff ); b_append( io->param2.out_buffer, res, strlen( res ) ); skip_fork = 1; free( res ); } for( io = j->io; io; io=io->next ) { if( io->io_mode == IO_FILE && wcscmp(io->param1.filename, L"/dev/null" )) { skip_fork = 0; } } if( skip_fork ) { p->completed=1; if( p->next == 0 ) { debug( 3, L"Set status of %ls to %d using short circut", j->command, p->status ); int status = proc_format_status(p->status); proc_set_last_status( job_get_flag( j, JOB_NEGATE )?(!status):status ); } break; } /* Ok, unfortunatly, we have to do a real fork. Bummer. */ pid = exec_fork(); if( pid == 0 ) { /* This is the child process. Setup redirections, print correct output to stdout and stderr, and then exit. */ p->pid = getpid(); setup_child_process( j, p ); do_builtin_io( sb_out->used ? (wchar_t *)sb_out->buff : 0, sb_err->used ? (wchar_t *)sb_err->buff : 0 ); exit( p->status ); } else { /* This is the parent process. Store away information on the child, and possibly give it control over the terminal. */ p->pid = pid; set_child_group( j, p, 0 ); } break; } case EXTERNAL: { pid = exec_fork(); if( pid == 0 ) { /* This is the child process. */ p->pid = getpid(); setup_child_process( j, p ); launch_process( p ); /* launch_process _never_ returns... */ } else { /* This is the parent process. Store away information on the child, and possibly fice it control over the terminal. */ p->pid = pid; set_child_group( j, p, 0 ); } break; } } if( p->type == INTERNAL_BUILTIN ) builtin_pop_io(); /* Close the pipe the current process uses to read from the previous process_t */ if( pipe_read.param1.pipe_fd[0] >= 0 ) exec_close( pipe_read.param1.pipe_fd[0] ); /* Set up the pipe the next process uses to read from the current process_t */ if( p->next ) pipe_read.param1.pipe_fd[0] = mypipe[0]; /* If there is a next process in the pipeline, close the output end of the current pipe (the surrent child subprocess already has a copy of the pipe - this makes sure we don't leak file descriptors either in the shell or in the children). */ if( p->next ) { exec_close(mypipe[1]); } } /* The keepalive process is no longer needed, so we terminate it with extreme prejudice */ if( needs_keepalive ) { kill( keepalive.pid, SIGKILL ); } signal_unblock(); debug( 3, L"Job is constructed" ); j->io = io_remove( j->io, &pipe_read ); for( tmp = block_io; tmp; tmp=tmp->next ) j->io = io_remove( j->io, tmp ); job_set_flag( j, JOB_CONSTRUCTED, 1 ); if( !job_get_flag( j, JOB_FOREGROUND ) ) { proc_last_bg_pid = j->pgid; } if( !exec_error ) { job_continue (j, 0); } }
/// Execute an internal builtin. Given a parser, a job within that parser, and a process within that /// job corresponding to a builtin, execute the builtin with the given streams. If pipe_read is set, /// assign stdin to it; otherwise infer stdin from the IO chain. /// \return true on success, false if there is an exec error. static bool exec_internal_builtin_proc(parser_t &parser, job_t *j, process_t *p, const io_pipe_t *pipe_read, const io_chain_t &proc_io_chain, io_streams_t &streams) { assert(p->type == INTERNAL_BUILTIN && "Process must be a builtin"); int local_builtin_stdin = STDIN_FILENO; bool close_stdin = false; // If this is the first process, check the io redirections and see where we should // be reading from. if (pipe_read) { local_builtin_stdin = pipe_read->pipe_fd[0]; } else if (const auto in = proc_io_chain.get_io_for_fd(STDIN_FILENO)) { switch (in->io_mode) { case IO_FD: { const io_fd_t *in_fd = static_cast<const io_fd_t *>(in.get()); // Ignore user-supplied fd redirections from an fd other than the // standard ones. e.g. in source <&3 don't actually read from fd 3, // which is internal to fish. We still respect this redirection in // that we pass it on as a block IO to the code that source runs, // and therefore this is not an error. Non-user supplied fd // redirections come about through transmogrification, and we need // to respect those here. if (!in_fd->user_supplied || (in_fd->old_fd >= 0 && in_fd->old_fd < 3)) { local_builtin_stdin = in_fd->old_fd; } break; } case IO_PIPE: { const io_pipe_t *in_pipe = static_cast<const io_pipe_t *>(in.get()); local_builtin_stdin = in_pipe->pipe_fd[0]; break; } case IO_FILE: { // Do not set CLO_EXEC because child needs access. const io_file_t *in_file = static_cast<const io_file_t *>(in.get()); local_builtin_stdin = open(in_file->filename_cstr, in_file->flags, OPEN_MASK); if (local_builtin_stdin == -1) { debug(1, FILE_ERROR, in_file->filename_cstr); wperror(L"open"); } else { close_stdin = true; } break; } case IO_CLOSE: { // FIXME: When requesting that stdin be closed, we really don't do // anything. How should this be handled? local_builtin_stdin = -1; break; } default: { local_builtin_stdin = -1; debug(1, _(L"Unknown input redirection type %d"), in->io_mode); break; } } } if (local_builtin_stdin == -1) return false; // Determine if we have a "direct" redirection for stdin. bool stdin_is_directly_redirected; if (!p->is_first_in_job) { // We must have a pipe stdin_is_directly_redirected = true; } else { // We are not a pipe. Check if there is a redirection local to the process // that's not IO_CLOSE. const shared_ptr<const io_data_t> stdin_io = io_chain_get(p->io_chain(), STDIN_FILENO); stdin_is_directly_redirected = stdin_io && stdin_io->io_mode != IO_CLOSE; } streams.stdin_fd = local_builtin_stdin; streams.out_is_redirected = has_fd(proc_io_chain, STDOUT_FILENO); streams.err_is_redirected = has_fd(proc_io_chain, STDERR_FILENO); streams.stdin_is_directly_redirected = stdin_is_directly_redirected; streams.io_chain = &proc_io_chain; // Since this may be the foreground job, and since a builtin may execute another // foreground job, we need to pretend to suspend this job while running the // builtin, in order to avoid a situation where two jobs are running at once. // // The reason this is done here, and not by the relevant builtins, is that this // way, the builtin does not need to know what job it is part of. It could // probably figure that out by walking the job list, but it seems more robust to // make exec handle things. const int fg = j->is_foreground(); j->set_flag(job_flag_t::FOREGROUND, false); // Note this call may block for a long time, while the builtin performs I/O. p->status = builtin_run(parser, j->pgid, p->get_argv(), streams); // Restore the fg flag, which is temporarily set to false during builtin // execution so as not to confuse some job-handling builtins. j->set_flag(job_flag_t::FOREGROUND, fg); // If stdin has been redirected, close the redirection stream. if (close_stdin) { exec_close(local_builtin_stdin); } return true; // "success" }