snow/somake
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
somake/bin/parallel.cc
Georg Sauthoff 6804ba69d6 import Sun's dmake from illumos 
Source:

svn export https://github.com/illumos/illumos-gate/trunk/usr/src/cmd/make/

Yes, github also has a Subversion compatible interface - which seems to
be useful when one is only interested in a set of files.

The Github Subversion server printed: Exported revision 15816.

This corresponds to:
67c3092ccd/usr/src/cmd/make
2016-08-21 23:34:14 +02:00

1893 lines
44 KiB
C++
Raw Blame History

/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* parallel.cc
*
* Deal with the parallel processing
*/
/*
* Included files
*/
#include <errno.h> /* errno */
#include <fcntl.h>
#include <mk/defs.h>
#include <mksh/dosys.h> /* redirect_io() */
#include <mksh/macro.h> /* expand_value() */
#include <mksh/misc.h> /* getmem() */
#include <sys/signal.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/utsname.h>
#include <sys/wait.h>
#include <unistd.h>
#include <netdb.h>
#include <libintl.h>
/*
* Defined macros
*/
#define MAXRULES 100
/*
* This const should be in avo_dms/include/AvoDmakeCommand.h
*/
const int local_host_mask = 0x20;
/*
* typedefs & structs
*/
/*
* Static variables
*/
static Boolean just_did_subtree = false;
static char local_host[MAXNAMELEN] = "";
static char user_name[MAXNAMELEN] = "";
static int pmake_max_jobs = 0;
static pid_t process_running = -1;
static Running *running_tail = &running_list;
static Name subtree_conflict;
static Name subtree_conflict2;
/*
* File table of contents
*/
static void delete_running_struct(Running rp);
static Boolean dependency_conflict(Name target);
static Doname distribute_process(char **commands, Property line);
static void doname_subtree(Name target, Boolean do_get, Boolean implicit);
static void dump_out_file(char *filename, Boolean err);
static void finish_doname(Running rp);
static void maybe_reread_make_state(void);
static void process_next(void);
static void reset_conditionals(int cnt, Name *targets, Property *locals);
static pid_t run_rule_commands(char *host, char **commands);
static Property *set_conditionals(int cnt, Name *targets);
static void store_conditionals(Running rp);
/*
* execute_parallel(line, waitflg)
*
* DMake 2.x:
* parallel mode: spawns a parallel process to execute the command group.
*
* Return value:
* The result of the execution
*
* Parameters:
* line The command group to execute
*/
Doname
execute_parallel(Property line, Boolean waitflg, Boolean local)
{
int argcnt;
int cmd_options = 0;
char *commands[MAXRULES + 5];
char *cp;
Name dmake_name;
Name dmake_value;
int ignore;
Name make_machines_name;
char **p;
Property prop;
Doname result = build_ok;
Cmd_line rule;
Boolean silent_flag;
Name target = line->body.line.target;
Boolean wrote_state_file = false;
if ((pmake_max_jobs == 0) &&
(dmake_mode_type == parallel_mode)) {
if (local_host[0] == '\0') {
(void) gethostname(local_host, MAXNAMELEN);
}
MBSTOWCS(wcs_buffer, "DMAKE_MAX_JOBS");
dmake_name = GETNAME(wcs_buffer, FIND_LENGTH);
if (((prop = get_prop(dmake_name->prop, macro_prop)) != NULL) &&
((dmake_value = prop->body.macro.value) != NULL)) {
pmake_max_jobs = atoi(dmake_value->string_mb);
if (pmake_max_jobs <= 0) {
warning(gettext("DMAKE_MAX_JOBS cannot be less than or equal to zero."));
warning(gettext("setting DMAKE_MAX_JOBS to %d."), PMAKE_DEF_MAX_JOBS);
pmake_max_jobs = PMAKE_DEF_MAX_JOBS;
}
} else {
/*
* For backwards compatibility w/ PMake 1.x, when
* DMake 2.x is being run in parallel mode, DMake
* should parse the PMake startup file
* $(HOME)/.make.machines to get the pmake_max_jobs.
*/
MBSTOWCS(wcs_buffer, "PMAKE_MACHINESFILE");
dmake_name = GETNAME(wcs_buffer, FIND_LENGTH);
if (((prop = get_prop(dmake_name->prop, macro_prop)) != NULL) &&
((dmake_value = prop->body.macro.value) != NULL)) {
make_machines_name = dmake_value;
} else {
make_machines_name = NULL;
}
if ((pmake_max_jobs = read_make_machines(make_machines_name)) <= 0) {
pmake_max_jobs = PMAKE_DEF_MAX_JOBS;
}
}
}
if ((dmake_mode_type == serial_mode) ||
((dmake_mode_type == parallel_mode) && (waitflg))) {
return (execute_serial(line));
}
{
p = commands;
}
argcnt = 0;
for (rule = line->body.line.command_used;
rule != NULL;
rule = rule->next) {
if (posix && (touch || quest) && !rule->always_exec) {
continue;
}
if (vpath_defined) {
rule->command_line =
vpath_translation(rule->command_line);
}
silent_flag = false;
ignore = 0;
if (rule->command_line->hash.length > 0) {
if (++argcnt == MAXRULES) {
return build_serial;
}
{
if (rule->silent && !silent) {
silent_flag = true;
}
if (rule->ignore_error) {
ignore++;
}
/* XXX - need to add support for + prefix */
if (silent_flag || ignore) {
*p = getmem((silent_flag ? 1 : 0) +
ignore +
(strlen(rule->
command_line->
string_mb)) +
1);
cp = *p++;
if (silent_flag) {
*cp++ = (int) at_char;
}
if (ignore) {
*cp++ = (int) hyphen_char;
}
(void) strcpy(cp, rule->command_line->string_mb);
} else {
*p++ = rule->command_line->string_mb;
}
}
}
}
if ((argcnt == 0) ||
(report_dependencies_level > 0)) {
return build_ok;
}
{
*p = NULL;
Doname res = distribute_process(commands, line);
if (res == build_running) {
parallel_process_cnt++;
}
/*
* Return only those memory that were specially allocated
* for part of commands.
*/
for (int i = 0; commands[i] != NULL; i++) {
if ((commands[i][0] == (int) at_char) ||
(commands[i][0] == (int) hyphen_char)) {
retmem_mb(commands[i]);
}
}
return res;
}
}
#include <unistd.h> /* sysconf(_SC_NPROCESSORS_ONLN) */
#include <sys/ipc.h> /* ftok() */
#include <sys/shm.h> /* shmget(), shmat(), shmdt(), shmctl() */
#include <semaphore.h> /* sem_init(), sem_trywait(), sem_post(), sem_destroy() */
#include <sys/loadavg.h> /* getloadavg() */
/*
* adjust_pmake_max_jobs (int pmake_max_jobs)
*
* Parameters:
* pmake_max_jobs - max jobs limit set by user
*
* External functions used:
* sysconf()
* getloadavg()
*/
static int
adjust_pmake_max_jobs (int pmake_max_jobs)
{
static int ncpu = 0;
double loadavg[3];
int adjustment;
int adjusted_max_jobs;
if (ncpu <= 0) {
if ((ncpu = sysconf(_SC_NPROCESSORS_ONLN)) <= 0) {
ncpu = 1;
}
}
if (getloadavg(loadavg, 3) != 3) return(pmake_max_jobs);
adjustment = ((int)loadavg[LOADAVG_1MIN]);
if (adjustment < 2) return(pmake_max_jobs);
if (ncpu > 1) {
adjustment = adjustment / ncpu;
}
adjusted_max_jobs = pmake_max_jobs - adjustment;
if (adjusted_max_jobs < 1) adjusted_max_jobs = 1;
return(adjusted_max_jobs);
}
/*
* M2 adjust mode data and functions
*
* m2_init() - initializes M2 shared semaphore
* m2_acquire_job() - decrements M2 semaphore counter
* m2_release_job() - increments M2 semaphore counter
* m2_fini() - destroys M2 semaphore and shared memory*
*
* Environment variables:
* __DMAKE_M2_FILE__
*
* External functions:
* ftok(), shmget(), shmat(), shmdt(), shmctl()
* sem_init(), sem_trywait(), sem_post(), sem_destroy()
* creat(), close(), unlink()
* getenv(), putenv()
*
* Static variables:
* m2_file - tmp file name to create ipc key for shared memory
* m2_shm_id - shared memory id
* m2_shm_sem - shared memory semaphore
*/
static char m2_file[MAXPATHLEN];
static int m2_shm_id = -1;
static sem_t* m2_shm_sem = 0;
static int
m2_init() {
char *var;
key_t key;
if ((var = getenv("__DMAKE_M2_FILE__")) == 0) {
/* compose tmp file name */
sprintf(m2_file, "%s/dmake.m2.%d.XXXXXX", tmpdir, getpid());
/* create tmp file */
int fd = mkstemp(m2_file);
if (fd < 0) {
return -1;
} else {
close(fd);
}
} else {
/* using existing semaphore */
strcpy(m2_file, var);
}
/* combine IPC key */
if ((key = ftok(m2_file, 38)) == (key_t) -1) {
return -1;
}
/* create shared memory */
if ((m2_shm_id = shmget(key, sizeof(*m2_shm_sem), 0666 | (var ? 0 : IPC_CREAT|IPC_EXCL))) == -1) {
return -1;
}
/* attach shared memory */
if ((m2_shm_sem = (sem_t*) shmat(m2_shm_id, 0, 0666)) == (sem_t*)-1) {
return -1;
}
/* root process */
if (var == 0) {
/* initialize semaphore */
if (sem_init(m2_shm_sem, 1, pmake_max_jobs)) {
return -1;
}
/* alloc memory for env variable */
if ((var = (char*) malloc(MAXPATHLEN)) == 0) {
return -1;
}
/* put key to env */
sprintf(var, "__DMAKE_M2_FILE__=%s", m2_file);
if (putenv(var)) {
return -1;
}
}
return 0;
}
static void
m2_fini() {
if (m2_shm_id >= 0) {
struct shmid_ds stat;
/* determine the number of attached processes */
if (shmctl(m2_shm_id, IPC_STAT, &stat) == 0) {
if (stat.shm_nattch <= 1) {
/* destroy semaphore */
if (m2_shm_sem != 0) {
(void) sem_destroy(m2_shm_sem);
}
/* destroy shared memory */
(void) shmctl(m2_shm_id, IPC_RMID, &stat);
/* remove tmp file created for the key */
(void) unlink(m2_file);
} else {
/* detach shared memory */
if (m2_shm_sem != 0) {
(void) shmdt((char*) m2_shm_sem);
}
}
}
m2_shm_id = -1;
m2_shm_sem = 0;
}
}
static int
m2_acquire_job() {
if ((m2_shm_id >= 0) && (m2_shm_sem != 0)) {
if (sem_trywait(m2_shm_sem) == 0) {
return 1;
}
if (errno == EAGAIN) {
return 0;
}
}
return -1;
}
static int
m2_release_job() {
if ((m2_shm_id >= 0) && (m2_shm_sem != 0)) {
if (sem_post(m2_shm_sem) == 0) {
return 0;
}
}
return -1;
}
/*
* job adjust mode
*
* Possible values:
* ADJUST_M1 - adjustment by system load (default)
* ADJUST_M2 - fixed limit of jobs for the group of nested dmakes
* ADJUST_NONE - no adjustment - fixed limit of jobs for the current dmake
*/
static enum {
ADJUST_UNKNOWN,
ADJUST_M1,
ADJUST_M2,
ADJUST_NONE
} job_adjust_mode = ADJUST_UNKNOWN;
/*
* void job_adjust_fini()
*
* Description:
* Cleans up job adjust data.
*
* Static variables:
* job_adjust_mode Current job adjust mode
*/
void
job_adjust_fini() {
if (job_adjust_mode == ADJUST_M2) {
m2_fini();
}
}
/*
* void job_adjust_error()
*
* Description:
* Prints warning message, cleans up job adjust data, and disables job adjustment
*
* Environment:
* DMAKE_ADJUST_MAX_JOBS
*
* External functions:
* putenv()
*
* Static variables:
* job_adjust_mode Current job adjust mode
*/
static void
job_adjust_error() {
if (job_adjust_mode != ADJUST_NONE) {
/* cleanup internals */
job_adjust_fini();
/* warning message for the user */
warning(gettext("Encountered max jobs auto adjustment error - disabling auto adjustment."));
/* switch off job adjustment for the children */
putenv(strdup("DMAKE_ADJUST_MAX_JOBS=NO"));
/* and for this dmake */
job_adjust_mode = ADJUST_NONE;
}
}
/*
* void job_adjust_init()
*
* Description:
* Parses DMAKE_ADJUST_MAX_JOBS env variable
* and performs appropriate initializations.
*
* Environment:
* DMAKE_ADJUST_MAX_JOBS
* DMAKE_ADJUST_MAX_JOBS == "NO" - no adjustment
* DMAKE_ADJUST_MAX_JOBS == "M2" - M2 adjust mode
* other - M1 adjust mode
*
* External functions:
* getenv()
*
* Static variables:
* job_adjust_mode Current job adjust mode
*/
static void
job_adjust_init() {
if (job_adjust_mode == ADJUST_UNKNOWN) {
/* default mode */
job_adjust_mode = ADJUST_M1;
/* determine adjust mode */
if (char *var = getenv("DMAKE_ADJUST_MAX_JOBS")) {
if (strcasecmp(var, "NO") == 0) {
job_adjust_mode = ADJUST_NONE;
} else if (strcasecmp(var, "M2") == 0) {
job_adjust_mode = ADJUST_M2;
}
}
/* M2 specific initialization */
if (job_adjust_mode == ADJUST_M2) {
if (m2_init()) {
job_adjust_error();
}
}
}
}
/*
* distribute_process(char **commands, Property line)
*
* Parameters:
* commands argv vector of commands to execute
*
* Return value:
* The result of the execution
*
* Static variables used:
* process_running Set to the pid of the process set running
* job_adjust_mode Current job adjust mode
*/
static Doname
distribute_process(char **commands, Property line)
{
static unsigned file_number = 0;
wchar_t string[MAXPATHLEN];
char mbstring[MAXPATHLEN];
int filed;
int res;
int tmp_index;
char *tmp_index_str_ptr;
/* initialize adjust mode, if not initialized */
if (job_adjust_mode == ADJUST_UNKNOWN) {
job_adjust_init();
}
/* actions depend on adjust mode */
switch (job_adjust_mode) {
case ADJUST_M1:
while (parallel_process_cnt >= adjust_pmake_max_jobs (pmake_max_jobs)) {
await_parallel(false);
finish_children(true);
}
break;
case ADJUST_M2:
if ((res = m2_acquire_job()) == 0) {
if (parallel_process_cnt > 0) {
await_parallel(false);
finish_children(true);
if ((res = m2_acquire_job()) == 0) {
return build_serial;
}
} else {
return build_serial;
}
}
if (res < 0) {
/* job adjustment error */
job_adjust_error();
/* no adjustment */
while (parallel_process_cnt >= pmake_max_jobs) {
await_parallel(false);
finish_children(true);
}
}
break;
default:
while (parallel_process_cnt >= pmake_max_jobs) {
await_parallel(false);
finish_children(true);
}
}
setvar_envvar();
/*
* Tell the user what DMake is doing.
*/
if (!silent && output_mode != txt2_mode) {
/*
* Print local_host --> x job(s).
*/
(void) fprintf(stdout,
gettext("%s --> %d %s\n"),
local_host,
parallel_process_cnt + 1,
(parallel_process_cnt == 0) ? gettext("job") : gettext("jobs"));
/* Print command line(s). */
tmp_index = 0;
while (commands[tmp_index] != NULL) {
/* No @ char. */
/* XXX - need to add [2] when + prefix is added */
if ((commands[tmp_index][0] != (int) at_char) &&
(commands[tmp_index][1] != (int) at_char)) {
tmp_index_str_ptr = commands[tmp_index];
if (*tmp_index_str_ptr == (int) hyphen_char) {
tmp_index_str_ptr++;
}
(void) fprintf(stdout, "%s\n", tmp_index_str_ptr);
}
tmp_index++;
}
(void) fflush(stdout);
}
(void) sprintf(mbstring,
"%s/dmake.stdout.%d.%d.XXXXXX",
tmpdir,
getpid(),
file_number++);
mktemp(mbstring);
stdout_file = strdup(mbstring);
stderr_file = NULL;
if (!out_err_same) {
(void) sprintf(mbstring,
"%s/dmake.stderr.%d.%d.XXXXXX",
tmpdir,
getpid(),
file_number++);
mktemp(mbstring);
stderr_file = strdup(mbstring);
}
process_running = run_rule_commands(local_host, commands);
return build_running;
}
/*
* doname_parallel(target, do_get, implicit)
*
* Processes the given target and finishes up any parallel
* processes left running.
*
* Return value:
* Result of target build
*
* Parameters:
* target Target to build
* do_get True if sccs get to be done
* implicit True if this is an implicit target
*/
Doname
doname_parallel(Name target, Boolean do_get, Boolean implicit)
{
Doname result;
result = doname_check(target, do_get, implicit, false);
if (result == build_ok || result == build_failed) {
return result;
}
finish_running();
return (Doname) target->state;
}
/*
* doname_subtree(target, do_get, implicit)
*
* Completely computes an object and its dependents for a
* serial subtree build.
*
* Parameters:
* target Target to build
* do_get True if sccs get to be done
* implicit True if this is an implicit target
*
* Static variables used:
* running_tail Tail of the list of running processes
*
* Global variables used:
* running_list The list of running processes
*/
static void
doname_subtree(Name target, Boolean do_get, Boolean implicit)
{
Running save_running_list;
Running *save_running_tail;
save_running_list = running_list;
save_running_tail = running_tail;
running_list = NULL;
running_tail = &running_list;
target->state = build_subtree;
target->checking_subtree = true;
while(doname_check(target, do_get, implicit, false) == build_running) {
target->checking_subtree = false;
finish_running();
target->state = build_subtree;
}
target->checking_subtree = false;
running_list = save_running_list;
running_tail = save_running_tail;
}
/*
* finish_running()
*
* Keeps processing until the running_list is emptied out.
*
* Parameters:
*
* Global variables used:
* running_list The list of running processes
*/
void
finish_running(void)
{
while (running_list != NULL) {
{
await_parallel(false);
finish_children(true);
}
if (running_list != NULL) {
process_next();
}
}
}
/*
* process_next()
*
* Searches the running list for any targets which can start processing.
* This can be a pending target, a serial target, or a subtree target.
*
* Parameters:
*
* Static variables used:
* running_tail The end of the list of running procs
* subtree_conflict A target which conflicts with a subtree
* subtree_conflict2 The other target which conflicts
*
* Global variables used:
* commands_done True if commands executed
* debug_level Controls debug output
* parallel_process_cnt Number of parallel process running
* recursion_level Indentation for debug output
* running_list List of running processes
*/
static void
process_next(void)
{
Running rp;
Running *rp_prev;
Property line;
Chain target_group;
Dependency dep;
Boolean quiescent = true;
Running *subtree_target;
Boolean saved_commands_done;
Property *conditionals;
subtree_target = NULL;
subtree_conflict = NULL;
subtree_conflict2 = NULL;
/*
* If nothing currently running, build a serial target, if any.
*/
start_loop_1:
for (rp_prev = &running_list, rp = running_list;
rp != NULL && parallel_process_cnt == 0;
rp = rp->next) {
if (rp->state == build_serial) {
*rp_prev = rp->next;
if (rp->next == NULL) {
running_tail = rp_prev;
}
recursion_level = rp->recursion_level;
rp->target->state = build_pending;
(void) doname_check(rp->target,
rp->do_get,
rp->implicit,
false);
quiescent = false;
delete_running_struct(rp);
goto start_loop_1;
} else {
rp_prev = &rp->next;
}
}
/*
* Find a target to build. The target must be pending, have all
* its dependencies built, and not be in a target group with a target
* currently building.
*/
start_loop_2:
for (rp_prev = &running_list, rp = running_list;
rp != NULL;
rp = rp->next) {
if (!(rp->state == build_pending ||
rp->state == build_subtree)) {
quiescent = false;
rp_prev = &rp->next;
} else if (rp->state == build_pending) {
line = get_prop(rp->target->prop, line_prop);
for (dep = line->body.line.dependencies;
dep != NULL;
dep = dep->next) {
if (dep->name->state == build_running ||
dep->name->state == build_pending ||
dep->name->state == build_serial) {
break;
}
}
if (dep == NULL) {
for (target_group = line->body.line.target_group;
target_group != NULL;
target_group = target_group->next) {
if (is_running(target_group->name)) {
break;
}
}
if (target_group == NULL) {
*rp_prev = rp->next;
if (rp->next == NULL) {
running_tail = rp_prev;
}
recursion_level = rp->recursion_level;
rp->target->state = rp->redo ?
build_dont_know : build_pending;
saved_commands_done = commands_done;
conditionals =
set_conditionals
(rp->conditional_cnt,
rp->conditional_targets);
rp->target->dont_activate_cond_values = true;
if ((doname_check(rp->target,
rp->do_get,
rp->implicit,
rp->target->has_target_prop ? true : false) !=
build_running) &&
!commands_done) {
commands_done =
saved_commands_done;
}
rp->target->dont_activate_cond_values = false;
reset_conditionals
(rp->conditional_cnt,
rp->conditional_targets,
conditionals);
quiescent = false;
delete_running_struct(rp);
goto start_loop_2;
} else {
rp_prev = &rp->next;
}
} else {
rp_prev = &rp->next;
}
} else {
rp_prev = &rp->next;
}
}
/*
* If nothing has been found to build and there exists a subtree
* target with no dependency conflicts, build it.
*/
if (quiescent) {
start_loop_3:
for (rp_prev = &running_list, rp = running_list;
rp != NULL;
rp = rp->next) {
if (rp->state == build_subtree) {
if (!dependency_conflict(rp->target)) {
*rp_prev = rp->next;
if (rp->next == NULL) {
running_tail = rp_prev;
}
recursion_level = rp->recursion_level;
doname_subtree(rp->target,
rp->do_get,
rp->implicit);
quiescent = false;
delete_running_struct(rp);
goto start_loop_3;
} else {
subtree_target = rp_prev;
rp_prev = &rp->next;
}
} else {
rp_prev = &rp->next;
}
}
}
/*
* If still nothing found to build, we either have a deadlock
* or a subtree with a dependency conflict with something waiting
* to build.
*/
if (quiescent) {
if (subtree_target == NULL) {
fatal(gettext("Internal error: deadlock detected in process_next"));
} else {
rp = *subtree_target;
if (debug_level > 0) {
warning(gettext("Conditional macro conflict encountered for %s between %s and %s"),
subtree_conflict2->string_mb,
rp->target->string_mb,
subtree_conflict->string_mb);
}
*subtree_target = (*subtree_target)->next;
if (rp->next == NULL) {
running_tail = subtree_target;
}
recursion_level = rp->recursion_level;
doname_subtree(rp->target, rp->do_get, rp->implicit);
delete_running_struct(rp);
}
}
}
/*
* set_conditionals(cnt, targets)
*
* Sets the conditional macros for the targets given in the array of
* targets. The old macro values are returned in an array of
* Properties for later resetting.
*
* Return value:
* Array of conditional macro settings
*
* Parameters:
* cnt Number of targets
* targets Array of targets
*/
static Property *
set_conditionals(int cnt, Name *targets)
{
Property *locals, *lp;
Name *tp;
locals = (Property *) getmem(cnt * sizeof(Property));
for (lp = locals, tp = targets;
cnt > 0;
cnt--, lp++, tp++) {
*lp = (Property) getmem((*tp)->conditional_cnt *
sizeof(struct _Property));
set_locals(*tp, *lp);
}
return locals;
}
/*
* reset_conditionals(cnt, targets, locals)
*
* Resets the conditional macros as saved in the given array of
* Properties. The resets are done in reverse order. Afterwards the
* data structures are freed.
*
* Parameters:
* cnt Number of targets
* targets Array of targets
* locals Array of dependency macro settings
*/
static void
reset_conditionals(int cnt, Name *targets, Property *locals)
{
Name *tp;
Property *lp;
for (tp = targets + (cnt - 1), lp = locals + (cnt - 1);
cnt > 0;
cnt--, tp--, lp--) {
reset_locals(*tp,
*lp,
get_prop((*tp)->prop, conditional_prop),
0);
retmem_mb((caddr_t) *lp);
}
retmem_mb((caddr_t) locals);
}
/*
* dependency_conflict(target)
*
* Returns true if there is an intersection between
* the subtree of the target and any dependents of the pending targets.
*
* Return value:
* True if conflict found
*
* Parameters:
* target Subtree target to check
*
* Static variables used:
* subtree_conflict Target conflict found
* subtree_conflict2 Second conflict found
*
* Global variables used:
* running_list List of running processes
* wait_name .WAIT, not a real dependency
*/
static Boolean
dependency_conflict(Name target)
{
Property line;
Property pending_line;
Dependency dp;
Dependency pending_dp;
Running rp;
/* Return if we are already checking this target */
if (target->checking_subtree) {
return false;
}
target->checking_subtree = true;
line = get_prop(target->prop, line_prop);
if (line == NULL) {
target->checking_subtree = false;
return false;
}
/* Check each dependency of the target for conflicts */
for (dp = line->body.line.dependencies; dp != NULL; dp = dp->next) {
/* Ignore .WAIT dependency */
if (dp->name == wait_name) {
continue;
}
/*
* For each pending target, look for a dependency which
* is the same as a dependency of the subtree target. Since
* we can't build the subtree until all pending targets have
* finished which depend on the same dependency, this is
* a conflict.
*/
for (rp = running_list; rp != NULL; rp = rp->next) {
if (rp->state == build_pending) {
pending_line = get_prop(rp->target->prop,
line_prop);
if (pending_line == NULL) {
continue;
}
for(pending_dp = pending_line->
body.line.dependencies;
pending_dp != NULL;
pending_dp = pending_dp->next) {
if (dp->name == pending_dp->name) {
target->checking_subtree
= false;
subtree_conflict = rp->target;
subtree_conflict2 = dp->name;
return true;
}
}
}
}
if (dependency_conflict(dp->name)) {
target->checking_subtree = false;
return true;
}
}
target->checking_subtree = false;
return false;
}
/*
* await_parallel(waitflg)
*
* Waits for parallel children to exit and finishes their processing.
* If waitflg is false, the function returns after update_delay.
*
* Parameters:
* waitflg dwight
*/
void
await_parallel(Boolean waitflg)
{
Boolean nohang;
pid_t pid;
int status;
Running rp;
int waiterr;
nohang = false;
for ( ; ; ) {
if (!nohang) {
(void) alarm((int) update_delay);
}
pid = waitpid((pid_t)-1,
&status,
nohang ? WNOHANG : 0);
waiterr = errno;
if (!nohang) {
(void) alarm(0);
}
if (pid <= 0) {
if (waiterr == EINTR) {
if (waitflg) {
continue;
} else {
return;
}
} else {
return;
}
}
for (rp = running_list;
(rp != NULL) && (rp->pid != pid);
rp = rp->next) {
;
}
if (rp == NULL) {
fatal(gettext("Internal error: returned child pid not in running_list"));
} else {
rp->state = (WIFEXITED(status) && WEXITSTATUS(status) == 0) ? build_ok : build_failed;
}
nohang = true;
parallel_process_cnt--;
if (job_adjust_mode == ADJUST_M2) {
if (m2_release_job()) {
job_adjust_error();
}
}
}
}
/*
* finish_children(docheck)
*
* Finishes the processing for all targets which were running
* and have now completed.
*
* Parameters:
* docheck Completely check the finished target
*
* Static variables used:
* running_tail The tail of the running list
*
* Global variables used:
* continue_after_error -k flag
* fatal_in_progress True if we are finishing up after fatal err
* running_list List of running processes
*/
void
finish_children(Boolean docheck)
{
int cmds_length;
Property line;
Property line2;
struct stat out_buf;
Running rp;
Running *rp_prev;
Cmd_line rule;
Boolean silent_flag;
for (rp_prev = &running_list, rp = running_list;
rp != NULL;
rp = rp->next) {
bypass_for_loop_inc_4:
/*
* If the state is ok or failed, then this target has
* finished building.
* In parallel_mode, output the accumulated stdout/stderr.
* Read the auto dependency stuff, handle a failed build,
* update the target, then finish the doname process for
* that target.
*/
if (rp->state == build_ok || rp->state == build_failed) {
*rp_prev = rp->next;
if (rp->next == NULL) {
running_tail = rp_prev;
}
if ((line2 = rp->command) == NULL) {
line2 = get_prop(rp->target->prop, line_prop);
}
/*
* Check if there were any job output
* from the parallel build.
*/
if (rp->stdout_file != NULL) {
if (stat(rp->stdout_file, &out_buf) < 0) {
fatal(gettext("stat of %s failed: %s"),
rp->stdout_file,
errmsg(errno));
}
if ((line2 != NULL) &&
(out_buf.st_size > 0)) {
cmds_length = 0;
for (rule = line2->body.line.command_used,
silent_flag = silent;
rule != NULL;
rule = rule->next) {
cmds_length += rule->command_line->hash.length + 1;
silent_flag = BOOLEAN(silent_flag || rule->silent);
}
if (out_buf.st_size != cmds_length || silent_flag ||
output_mode == txt2_mode) {
dump_out_file(rp->stdout_file, false);
}
}
(void) unlink(rp->stdout_file);
retmem_mb(rp->stdout_file);
rp->stdout_file = NULL;
}
if (!out_err_same && (rp->stderr_file != NULL)) {
if (stat(rp->stderr_file, &out_buf) < 0) {
fatal(gettext("stat of %s failed: %s"),
rp->stderr_file,
errmsg(errno));
}
if ((line2 != NULL) &&
(out_buf.st_size > 0)) {
dump_out_file(rp->stderr_file, true);
}
(void) unlink(rp->stderr_file);
retmem_mb(rp->stderr_file);
rp->stderr_file = NULL;
}
check_state(rp->temp_file);
if (rp->temp_file != NULL) {
free_name(rp->temp_file);
}
rp->temp_file = NULL;
if (rp->state == build_failed) {
line = get_prop(rp->target->prop, line_prop);
if (line != NULL) {
line->body.line.command_used = NULL;
}
if (continue_after_error ||
fatal_in_progress ||
!docheck) {
warning(gettext("Command failed for target `%s'"),
rp->command ? line2->body.line.target->string_mb : rp->target->string_mb);
build_failed_seen = true;
} else {
/*
* XXX??? - DMake needs to exit(),
* but shouldn't call fatal().
*/
#ifdef PRINT_EXIT_STATUS
warning("I'm in finish_children. rp->state == build_failed.");
#endif
fatal(gettext("Command failed for target `%s'"),
rp->command ? line2->body.line.target->string_mb : rp->target->string_mb);
}
}
if (!docheck) {
delete_running_struct(rp);
rp = *rp_prev;
if (rp == NULL) {
break;
} else {
goto bypass_for_loop_inc_4;
}
}
update_target(get_prop(rp->target->prop, line_prop),
rp->state);
finish_doname(rp);
delete_running_struct(rp);
rp = *rp_prev;
if (rp == NULL) {
break;
} else {
goto bypass_for_loop_inc_4;
}
} else {
rp_prev = &rp->next;
}
}
}
/*
* dump_out_file(filename, err)
*
* Write the contents of the file to stdout, then unlink the file.
*
* Parameters:
* filename Name of temp file containing output
*
* Global variables used:
*/
static void
dump_out_file(char *filename, Boolean err)
{
int chars_read;
char copybuf[BUFSIZ];
int fd;
int out_fd = (err ? 2 : 1);
if ((fd = open(filename, O_RDONLY)) < 0) {
fatal(gettext("open failed for output file %s: %s"),
filename,
errmsg(errno));
}
if (!silent && output_mode != txt2_mode) {
(void) fprintf(err ? stderr : stdout,
err ?
gettext("%s --> Job errors\n") :
gettext("%s --> Job output\n"),
local_host);
(void) fflush(err ? stderr : stdout);
}
for (chars_read = read(fd, copybuf, BUFSIZ);
chars_read > 0;
chars_read = read(fd, copybuf, BUFSIZ)) {
/*
* Read buffers from the source file until end or error.
*/
if (write(out_fd, copybuf, chars_read) < 0) {
fatal(gettext("write failed for output file %s: %s"),
filename,
errmsg(errno));
}
}
(void) close(fd);
(void) unlink(filename);
}
/*
* finish_doname(rp)
*
* Completes the processing for a target which was left running.
*
* Parameters:
* rp Running list entry for target
*
* Global variables used:
* debug_level Debug flag
* recursion_level Indentation for debug output
*/
static void
finish_doname(Running rp)
{
int auto_count = rp->auto_count;
Name *automatics = rp->automatics;
Doname result = rp->state;
Name target = rp->target;
Name true_target = rp->true_target;
Property *conditionals;
recursion_level = rp->recursion_level;
if (result == build_ok) {
if (true_target == NULL) {
(void) printf("Target = %s\n", target->string_mb);
(void) printf(" State = %d\n", result);
fatal("Internal error: NULL true_target in finish_doname");
}
/* If all went OK, set a nice timestamp */
if (true_target->stat.time == file_doesnt_exist) {
true_target->stat.time = file_max_time;
}
}
target->state = result;
if (target->is_member) {
Property member;
/* Propagate the timestamp from the member file to the member */
if ((target->stat.time != file_max_time) &&
((member = get_prop(target->prop, member_prop)) != NULL) &&
(exists(member->body.member.member) > file_doesnt_exist)) {
target->stat.time =
/*
exists(member->body.member.member);
*/
member->body.member.member->stat.time;
}
}
/*
* Check if we found any new auto dependencies when we
* built the target.
*/
if ((result == build_ok) && check_auto_dependencies(target,
auto_count,
automatics)) {
if (debug_level > 0) {
(void) printf(gettext("%*sTarget `%s' acquired new dependencies from build, checking all dependencies\n"),
recursion_level,
"",
true_target->string_mb);
}
target->rechecking_target = true;
target->state = build_running;
/* [tolik, Tue Mar 25 1997]
* Fix for bug 4038824:
* command line options set by conditional macros get dropped
* rp->conditional_cnt and rp->conditional_targets must be copied
* to new 'rp' during add_pending(). Set_conditionals() stores
* rp->conditional_targets to the global variable 'conditional_targets'
* Add_pending() will use this variable to set up 'rp'.
*/
conditionals = set_conditionals(rp->conditional_cnt, rp->conditional_targets);
add_pending(target,
recursion_level,
rp->do_get,
rp->implicit,
true);
reset_conditionals(rp->conditional_cnt, rp->conditional_targets, conditionals);
}
}
/*
* new_running_struct()
*
* Constructor for Running struct. Creates a structure and initializes
* its fields.
*
*/
static Running new_running_struct()
{
Running rp;
rp = ALLOC(Running);
rp->target = NULL;
rp->true_target = NULL;
rp->command = NULL;
rp->sprodep_value = NULL;
rp->sprodep_env = NULL;
rp->auto_count = 0;
rp->automatics = NULL;
rp->pid = -1;
rp->job_msg_id = -1;
rp->stdout_file = NULL;
rp->stderr_file = NULL;
rp->temp_file = NULL;
rp->next = NULL;
return rp;
}
/*
* add_running(target, true_target, command, recursion_level, auto_count,
* automatics, do_get, implicit)
*
* Adds a record on the running list for this target, which
* was just spawned and is running.
*
* Parameters:
* target Target being built
* true_target True target for target
* command Running command.
* recursion_level Debug indentation level
* auto_count Count of automatic dependencies
* automatics List of automatic dependencies
* do_get Sccs get flag
* implicit Implicit flag
*
* Static variables used:
* running_tail Tail of running list
* process_running PID of process
*
* Global variables used:
* current_line Current line for target
* current_target Current target being built
* stderr_file Temporary file for stdout
* stdout_file Temporary file for stdout
* temp_file_name Temporary file for auto dependencies
*/
void
add_running(Name target, Name true_target, Property command, int recursion_level, int auto_count, Name *automatics, Boolean do_get, Boolean implicit)
{
Running rp;
Name *p;
rp = new_running_struct();
rp->state = build_running;
rp->target = target;
rp->true_target = true_target;
rp->command = command;
rp->recursion_level = recursion_level;
rp->do_get = do_get;
rp->implicit = implicit;
rp->auto_count = auto_count;
if (auto_count > 0) {
rp->automatics = (Name *) getmem(auto_count * sizeof (Name));
for (p = rp->automatics; auto_count > 0; auto_count--) {
*p++ = *automatics++;
}
} else {
rp->automatics = NULL;
}
{
rp->pid = process_running;
process_running = -1;
childPid = -1;
}
rp->job_msg_id = job_msg_id;
rp->stdout_file = stdout_file;
rp->stderr_file = stderr_file;
rp->temp_file = temp_file_name;
rp->redo = false;
rp->next = NULL;
store_conditionals(rp);
stdout_file = NULL;
stderr_file = NULL;
temp_file_name = NULL;
current_target = NULL;
current_line = NULL;
*running_tail = rp;
running_tail = &rp->next;
}
/*
* add_pending(target, recursion_level, do_get, implicit, redo)
*
* Adds a record on the running list for a pending target
* (waiting for its dependents to finish running).
*
* Parameters:
* target Target being built
* recursion_level Debug indentation level
* do_get Sccs get flag
* implicit Implicit flag
* redo True if this target is being redone
*
* Static variables used:
* running_tail Tail of running list
*/
void
add_pending(Name target, int recursion_level, Boolean do_get, Boolean implicit, Boolean redo)
{
Running rp;
rp = new_running_struct();
rp->state = build_pending;
rp->target = target;
rp->recursion_level = recursion_level;
rp->do_get = do_get;
rp->implicit = implicit;
rp->redo = redo;
store_conditionals(rp);
*running_tail = rp;
running_tail = &rp->next;
}
/*
* add_serial(target, recursion_level, do_get, implicit)
*
* Adds a record on the running list for a target which must be
* executed in serial after others have finished.
*
* Parameters:
* target Target being built
* recursion_level Debug indentation level
* do_get Sccs get flag
* implicit Implicit flag
*
* Static variables used:
* running_tail Tail of running list
*/
void
add_serial(Name target, int recursion_level, Boolean do_get, Boolean implicit)
{
Running rp;
rp = new_running_struct();
rp->target = target;
rp->recursion_level = recursion_level;
rp->do_get = do_get;
rp->implicit = implicit;
rp->state = build_serial;
rp->redo = false;
store_conditionals(rp);
*running_tail = rp;
running_tail = &rp->next;
}
/*
* add_subtree(target, recursion_level, do_get, implicit)
*
* Adds a record on the running list for a target which must be
* executed in isolation after others have finished.
*
* Parameters:
* target Target being built
* recursion_level Debug indentation level
* do_get Sccs get flag
* implicit Implicit flag
*
* Static variables used:
* running_tail Tail of running list
*/
void
add_subtree(Name target, int recursion_level, Boolean do_get, Boolean implicit)
{
Running rp;
rp = new_running_struct();
rp->target = target;
rp->recursion_level = recursion_level;
rp->do_get = do_get;
rp->implicit = implicit;
rp->state = build_subtree;
rp->redo = false;
store_conditionals(rp);
*running_tail = rp;
running_tail = &rp->next;
}
/*
* store_conditionals(rp)
*
* Creates an array of the currently active targets with conditional
* macros (found in the chain conditional_targets) and puts that
* array in the Running struct.
*
* Parameters:
* rp Running struct for storing chain
*
* Global variables used:
* conditional_targets Chain of current dynamic conditionals
*/
static void
store_conditionals(Running rp)
{
int cnt;
Chain cond_name;
if (conditional_targets == NULL) {
rp->conditional_cnt = 0;
rp->conditional_targets = NULL;
return;
}
cnt = 0;
for (cond_name = conditional_targets;
cond_name != NULL;
cond_name = cond_name->next) {
cnt++;
}
rp->conditional_cnt = cnt;
rp->conditional_targets = (Name *) getmem(cnt * sizeof(Name));
for (cond_name = conditional_targets;
cond_name != NULL;
cond_name = cond_name->next) {
rp->conditional_targets[--cnt] = cond_name->name;
}
}
/*
* parallel_ok(target, line_prop_must_exists)
*
* Returns true if the target can be run in parallel
*
* Return value:
* True if can run in parallel
*
* Parameters:
* target Target being tested
*
* Global variables used:
* all_parallel True if all targets default to parallel
* only_parallel True if no targets default to parallel
*/
Boolean
parallel_ok(Name target, Boolean line_prop_must_exists)
{
Boolean assign;
Boolean make_refd;
Property line;
Cmd_line rule;
assign = make_refd = false;
if (((line = get_prop(target->prop, line_prop)) == NULL) &&
line_prop_must_exists) {
return false;
}
if (line != NULL) {
for (rule = line->body.line.command_used;
rule != NULL;
rule = rule->next) {
if (rule->assign) {
assign = true;
} else if (rule->make_refd) {
make_refd = true;
}
}
}
if (assign) {
return false;
} else if (target->parallel) {
return true;
} else if (target->no_parallel) {
return false;
} else if (all_parallel) {
return true;
} else if (only_parallel) {
return false;
} else if (make_refd) {
return false;
} else {
return true;
}
}
/*
* is_running(target)
*
* Returns true if the target is running.
*
* Return value:
* True if target is running
*
* Parameters:
* target Target to check
*
* Global variables used:
* running_list List of running processes
*/
Boolean
is_running(Name target)
{
Running rp;
if (target->state != build_running) {
return false;
}
for (rp = running_list;
rp != NULL && target != rp->target;
rp = rp->next);
if (rp == NULL) {
return false;
} else {
return (rp->state == build_running) ? true : false;
}
}
/*
* This function replaces the makesh binary.
*/
static pid_t
run_rule_commands(char *host, char **commands)
{
Boolean always_exec;
Name command;
Boolean ignore;
int length;
Doname result;
Boolean silent_flag;
wchar_t *tmp_wcs_buffer;
childPid = fork();
switch (childPid) {
case -1: /* Error */
fatal(gettext("Could not fork child process for dmake job: %s"),
errmsg(errno));
break;
case 0: /* Child */
/* To control the processed targets list is not the child's business */
running_list = NULL;
if(out_err_same) {
redirect_io(stdout_file, (char*)NULL);
} else {
redirect_io(stdout_file, stderr_file);
}
for (commands = commands;
(*commands != (char *)NULL);
commands++) {
silent_flag = silent;
ignore = false;
always_exec = false;
while ((**commands == (int) at_char) ||
(**commands == (int) hyphen_char) ||
(**commands == (int) plus_char)) {
if (**commands == (int) at_char) {
silent_flag = true;
}
if (**commands == (int) hyphen_char) {
ignore = true;
}
if (**commands == (int) plus_char) {
always_exec = true;
}
(*commands)++;
}
if ((length = strlen(*commands)) >= MAXPATHLEN) {
tmp_wcs_buffer = ALLOC_WC(length + 1);
(void) mbstowcs(tmp_wcs_buffer, *commands, length + 1);
command = GETNAME(tmp_wcs_buffer, FIND_LENGTH);
retmem(tmp_wcs_buffer);
} else {
MBSTOWCS(wcs_buffer, *commands);
command = GETNAME(wcs_buffer, FIND_LENGTH);
}
if ((command->hash.length > 0) &&
!silent_flag) {
(void) printf("%s\n", command->string_mb);
}
result = dosys(command,
ignore,
false,
false, /* bugs #4085164 & #4990057 */
/* BOOLEAN(silent_flag && ignore), */
always_exec,
(Name) NULL);
if (result == build_failed) {
if (silent_flag) {
(void) printf(gettext("The following command caused the error:\n%s\n"), command->string_mb);
}
if (!ignore) {
_exit(1);
}
}
}
_exit(0);
break;
default:
break;
}
return childPid;
}
static void
maybe_reread_make_state(void)
{
/* Copying dosys()... */
if (report_dependencies_level == 0) {
make_state->stat.time = file_no_time;
(void) exists(make_state);
if (make_state_before == make_state->stat.time) {
return;
}
makefile_type = reading_statefile;
if (read_trace_level > 1) {
trace_reader = true;
}
temp_file_number++;
(void) read_simple_file(make_state,
false,
false,
false,
false,
false,
true);
trace_reader = false;
}
}
static void
delete_running_struct(Running rp)
{
if ((rp->conditional_cnt > 0) &&
(rp->conditional_targets != NULL)) {
retmem_mb((char *) rp->conditional_targets);
}
/**/
if ((rp->auto_count > 0) &&
(rp->automatics != NULL)) {
retmem_mb((char *) rp->automatics);
}
/**/
if(rp->sprodep_value) {
free_name(rp->sprodep_value);
}
if(rp->sprodep_env) {
retmem_mb(rp->sprodep_env);
}
retmem_mb((char *) rp);
}
Reference in a new issue View git blame Copy permalink