~ubuntu-branches/ubuntu/trusty/bmake/trusty-proposed : revision 1

1

/* $NetBSD: job.c,v 1.176 2013/08/04 16:48:15 sjg Exp $ */

2

3

/*

4

5

6

*

7

* This code is derived from software contributed to Berkeley by

8

* Adam de Boor.

9

*

10

* Redistribution and use in source and binary forms, with or without

11

* modification, are permitted provided that the following conditions

12

* are met:

13

* 1. Redistributions of source code must retain the above copyright

14

* notice, this list of conditions and the following disclaimer.

15

* 2. Redistributions in binary form must reproduce the above copyright

16

* notice, this list of conditions and the following disclaimer in the

17

* documentation and/or other materials provided with the distribution.

18

* 3. Neither the name of the University nor the names of its contributors

19

* may be used to endorse or promote products derived from this software

20

* without specific prior written permission.

21

*

22

* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

23

* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

24

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

25

* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

26

* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

27

* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

28

* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

29

* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

30

* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

31

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

32

* SUCH DAMAGE.

33

*/

34

35

/*

36

37

38

39

*

40

* This code is derived from software contributed to Berkeley by

41

* Adam de Boor.

42

*

43

* Redistribution and use in source and binary forms, with or without

44

* modification, are permitted provided that the following conditions

45

* are met:

46

* 1. Redistributions of source code must retain the above copyright

47

* notice, this list of conditions and the following disclaimer.

48

* 2. Redistributions in binary form must reproduce the above copyright

49

* notice, this list of conditions and the following disclaimer in the

50

* documentation and/or other materials provided with the distribution.

51

* 3. All advertising materials mentioning features or use of this software

52

* must display the following acknowledgement:

53

* This product includes software developed by the University of

54

* California, Berkeley and its contributors.

55

* 4. Neither the name of the University nor the names of its contributors

56

* may be used to endorse or promote products derived from this software

57

* without specific prior written permission.

58

*

59

* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

60

* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

61

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

62

* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

63

* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

64

* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

65

* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

66

* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

67

* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

68

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

69

* SUCH DAMAGE.

70

*/

71

72

#ifndef MAKE_NATIVE

73

static char rcsid[] = "$NetBSD: job.c,v 1.176 2013/08/04 16:48:15 sjg Exp $";

74

#else

75

#include <sys/cdefs.h>

76

#ifndef lint

77

#if 0

78

static char sccsid[] = "@(#)job.c 8.2 (Berkeley) 3/19/94";

79

#else

80

__RCSID("$NetBSD: job.c,v 1.176 2013/08/04 16:48:15 sjg Exp $");

81

#endif

82

#endif /* not lint */

83

#endif

84

85

/*-

86

* job.c --

87

* handle the creation etc. of our child processes.

88

*

89

* Interface:

90

* Job_Make Start the creation of the given target.

91

*

92

* Job_CatchChildren Check for and handle the termination of any

93

* children. This must be called reasonably

94

* frequently to keep the whole make going at

95

* a decent clip, since job table entries aren't

96

* removed until their process is caught this way.

97

*

98

* Job_CatchOutput Print any output our children have produced.

99

* Should also be called fairly frequently to

100

* keep the user informed of what's going on.

101

* If no output is waiting, it will block for

102

* a time given by the SEL_* constants, below,

103

* or until output is ready.

104

*

105

* Job_Init Called to intialize this module. in addition,

106

* any commands attached to the .BEGIN target

107

* are executed before this function returns.

108

* Hence, the makefile must have been parsed

109

* before this function is called.

110

*

111

* Job_End Cleanup any memory used.

112

*

113

* Job_ParseShell Given the line following a .SHELL target, parse

114

* the line as a shell specification. Returns

115

* FAILURE if the spec was incorrect.

116

*

117

* Job_Finish Perform any final processing which needs doing.

118

* This includes the execution of any commands

119

* which have been/were attached to the .END

120

* target. It should only be called when the

121

* job table is empty.

122

*

123

* Job_AbortAll Abort all currently running jobs. It doesn't

124

* handle output or do anything for the jobs,

125

* just kills them. It should only be called in

126

* an emergency, as it were.

127

*

128

* Job_CheckCommands Verify that the commands for a target are

129

* ok. Provide them if necessary and possible.

130

*

131

* Job_Touch Update a target without really updating it.

132

*

133

* Job_Wait Wait for all currently-running jobs to finish.

134

*/

135

136

#ifdef HAVE_CONFIG_H

137

# include "config.h"

138

#endif

139

#include <sys/types.h>

140

#include <sys/stat.h>

141

#include <sys/file.h>

142

#include <sys/time.h>

143

#include "wait.h"

144

145

#include <assert.h>

146

#include <errno.h>

147

#include <fcntl.h>

148

#if !defined(USE_SELECT) && defined(HAVE_POLL_H)

149

#include <poll.h>

150

#else

151

#ifndef USE_SELECT /* no poll.h */

152

# define USE_SELECT

153

#endif

154

#if defined(HAVE_SYS_SELECT_H)

155

# include <sys/select.h>

156

#endif

157

#endif

158

#include <signal.h>

159

#include <stdio.h>

160

#include <string.h>

161

#include <utime.h>

162

#if defined(HAVE_SYS_SOCKET_H)

163

# include <sys/socket.h>

164

#endif

165

166

#include "make.h"

167

#include "hash.h"

168

#include "dir.h"

169

#include "job.h"

170

#include "pathnames.h"

171

#include "trace.h"

172

# define STATIC static

173

174

/*

175

* error handling variables

176

*/

177

static int errors = 0; /* number of errors reported */

178

static int aborting = 0; /* why is the make aborting? */

179

#define ABORT_ERROR 1 /* Because of an error */

180

#define ABORT_INTERRUPT 2 /* Because it was interrupted */

181

#define ABORT_WAIT 3 /* Waiting for jobs to finish */

182

#define JOB_TOKENS "+EI+" /* Token to requeue for each abort state */

183

184

/*

185

* this tracks the number of tokens currently "out" to build jobs.

186

*/

187

int jobTokensRunning = 0;

188

int not_parallel = 0; /* set if .NOT_PARALLEL */

189

190

/*

191

* XXX: Avoid SunOS bug... FILENO() is fp->_file, and file

192

* is a char! So when we go above 127 we turn negative!

193

*/

194

#define FILENO(a) ((unsigned) fileno(a))

195

196

/*

197

* post-make command processing. The node postCommands is really just the

198

* .END target but we keep it around to avoid having to search for it

199

* all the time.

200

*/

201

static GNode *postCommands = NULL;

202

/* node containing commands to execute when

203

* everything else is done */

204

static int numCommands; /* The number of commands actually printed

205

* for a target. Should this number be

206

* 0, no shell will be executed. */

207

208

/*

209

* Return values from JobStart.

210

*/

211

#define JOB_RUNNING 0 /* Job is running */

212

#define JOB_ERROR 1 /* Error in starting the job */

213

#define JOB_FINISHED 2 /* The job is already finished */

214

215

/*

216

* Descriptions for various shells.

217

*

218

* The build environment may set DEFSHELL_INDEX to one of

219

* DEFSHELL_INDEX_SH, DEFSHELL_INDEX_KSH, or DEFSHELL_INDEX_CSH, to

220

* select one of the prefedined shells as the default shell.

221

*

222

* Alternatively, the build environment may set DEFSHELL_CUSTOM to the

223

* name or the full path of a sh-compatible shell, which will be used as

224

* the default shell.

225

*

226

* ".SHELL" lines in Makefiles can choose the default shell from the

227

# set defined here, or add additional shells.

228

*/

229

230

#ifdef DEFSHELL_CUSTOM

231

#define DEFSHELL_INDEX_CUSTOM 0

232

#define DEFSHELL_INDEX_SH 1

233

#define DEFSHELL_INDEX_KSH 2

234

#define DEFSHELL_INDEX_CSH 3

235

#else /* !DEFSHELL_CUSTOM */

236

#define DEFSHELL_INDEX_SH 0

237

#define DEFSHELL_INDEX_KSH 1

238

#define DEFSHELL_INDEX_CSH 2

239

#endif /* !DEFSHELL_CUSTOM */

240

241

#ifndef DEFSHELL_INDEX

242

#define DEFSHELL_INDEX 0 /* DEFSHELL_INDEX_CUSTOM or DEFSHELL_INDEX_SH */

243

#endif /* !DEFSHELL_INDEX */

244

245

static Shell shells[] = {

246

#ifdef DEFSHELL_CUSTOM

247

/*

248

* An sh-compatible shell with a non-standard name.

249

*

250

* Keep this in sync with the "sh" description below, but avoid

251

* non-portable features that might not be supplied by all

252

* sh-compatible shells.

253

*/

254

{

255

DEFSHELL_CUSTOM,

256

FALSE, "", "", "", 0,

257

FALSE, "echo \"%s\"\n", "%s\n", "{ %s \n} || exit $?\n", "'\n'", '#',

258

"",

259

"",

260

},

261

#endif /* DEFSHELL_CUSTOM */

262

/*

263

* SH description. Echo control is also possible and, under

264

* sun UNIX anyway, one can even control error checking.

265

*/

266

{

267

"sh",

268

FALSE, "", "", "", 0,

269

FALSE, "echo \"%s\"\n", "%s\n", "{ %s \n} || exit $?\n", "'\n'", '#',

270

#if defined(MAKE_NATIVE) && defined(__NetBSD__)

271

"q",

272

#else

273

"",

274

#endif

275

"",

276

},

277

/*

278

* KSH description.

279

*/

280

{

281

"ksh",

282

TRUE, "set +v", "set -v", "set +v", 6,

283

FALSE, "echo \"%s\"\n", "%s\n", "{ %s \n} || exit $?\n", "'\n'", '#',

284

"v",

285

"",

286

},

287

/*

288

* CSH description. The csh can do echo control by playing

289

* with the setting of the 'echo' shell variable. Sadly,

290

* however, it is unable to do error control nicely.

291

*/

292

{

293

"csh",

294

TRUE, "unset verbose", "set verbose", "unset verbose", 10,

295

FALSE, "echo \"%s\"\n", "csh -c \"%s || exit 0\"\n", "", "'\\\n'", '#',

296

"v", "e",

297

},

298

/*

299

* UNKNOWN.

300

*/

301

{

302

NULL,

303

FALSE, NULL, NULL, NULL, 0,

304

FALSE, NULL, NULL, NULL, NULL, 0,

305

NULL, NULL,

306

}

307

};

308

static Shell *commandShell = &shells[DEFSHELL_INDEX]; /* this is the shell to

309

* which we pass all

310

* commands in the Makefile.

311

* It is set by the

312

* Job_ParseShell function */

313

const char *shellPath = NULL, /* full pathname of

314

* executable image */

315

*shellName = NULL; /* last component of shell */

316

char *shellErrFlag = NULL;

317

static const char *shellArgv = NULL; /* Custom shell args */

318

319

320

STATIC Job *job_table; /* The structures that describe them */

321

STATIC Job *job_table_end; /* job_table + maxJobs */

322

static int wantToken; /* we want a token */

323

static int lurking_children = 0;

324

static int make_suspended = 0; /* non-zero if we've seen a SIGTSTP (etc) */

325

326

/*

327

* Set of descriptors of pipes connected to

328

* the output channels of children

329

*/

330

static struct pollfd *fds = NULL;

331

static Job **jobfds = NULL;

332

static int nfds = 0;

333

static void watchfd(Job *);

334

static void clearfd(Job *);

335

static int readyfd(Job *);

336

337

STATIC GNode *lastNode; /* The node for which output was most recently

338

* produced. */

339

static char *targPrefix = NULL; /* What we print at the start of TARG_FMT */

340

static Job tokenWaitJob; /* token wait pseudo-job */

341

342

static Job childExitJob; /* child exit pseudo-job */

343

#define CHILD_EXIT "."

344

#define DO_JOB_RESUME "R"

345

346

#define TARG_FMT "%s %s ---\n" /* Default format */

347

#define MESSAGE(fp, gn) \

348

if (maxJobs != 1 && targPrefix && *targPrefix) \

349

(void)fprintf(fp, TARG_FMT, targPrefix, gn->name)

350

351

static sigset_t caught_signals; /* Set of signals we handle */

352

#if defined(SYSV)

353

#define KILLPG(pid, sig) kill(-(pid), (sig))

354

#else

355

#define KILLPG(pid, sig) killpg((pid), (sig))

356

#endif

357

358

static void JobChildSig(int);

359

static void JobContinueSig(int);

360

static Job *JobFindPid(int, int, Boolean);

361

static int JobPrintCommand(void *, void *);

362

static int JobSaveCommand(void *, void *);

363

static void JobClose(Job *);

364

static void JobExec(Job *, char **);

365

static void JobMakeArgv(Job *, char **);

366

static int JobStart(GNode *, int);

367

static char *JobOutput(Job *, char *, char *, int);

368

static void JobDoOutput(Job *, Boolean);

369

static Shell *JobMatchShell(const char *);

370

static void JobInterrupt(int, int) MAKE_ATTR_DEAD;

371

static void JobRestartJobs(void);

372

static void JobTokenAdd(void);

373

static void JobSigLock(sigset_t *);

374

static void JobSigUnlock(sigset_t *);

375

static void JobSigReset(void);

376

377

const char *malloc_options="A";

378

379

static void

380

job_table_dump(const char *where)

381

{

382

Job *job;

383

384

fprintf(debug_file, "job table @ %s\n", where);

385

for (job = job_table; job < job_table_end; job++) {

386

fprintf(debug_file, "job %d, status %d, flags %d, pid %d\n",

387

(int)(job - job_table), job->job_state, job->flags, job->pid);

388

}

389

}

390

391

/*

392

* JobSigLock/JobSigUnlock

393

*

394

* Signal lock routines to get exclusive access. Currently used to

395

* protect `jobs' and `stoppedJobs' list manipulations.

396

*/

397

static void JobSigLock(sigset_t *omaskp)

398

{

399

if (sigprocmask(SIG_BLOCK, &caught_signals, omaskp) != 0) {

400

Punt("JobSigLock: sigprocmask: %s", strerror(errno));

401

sigemptyset(omaskp);

402

}

403

}

404

405

static void JobSigUnlock(sigset_t *omaskp)

406

{

407

(void)sigprocmask(SIG_SETMASK, omaskp, NULL);

408

}

409

410

static void

411

JobCreatePipe(Job *job, int minfd)

412

{

413

int i, fd;

414

415

if (pipe(job->jobPipe) == -1)

416

Punt("Cannot create pipe: %s", strerror(errno));

417

418

for (i = 0; i < 2; i++) {

419

/* Avoid using low numbered fds */

420

fd = fcntl(job->jobPipe[i], F_DUPFD, minfd);

421

if (fd != -1) {

422

close(job->jobPipe[i]);

423

job->jobPipe[i] = fd;

424

}

425

}

426

427

/* Set close-on-exec flag for both */

428

(void)fcntl(job->jobPipe[0], F_SETFD, 1);

429

(void)fcntl(job->jobPipe[1], F_SETFD, 1);

430

431

/*

432

* We mark the input side of the pipe non-blocking; we poll(2) the

433

* pipe when we're waiting for a job token, but we might lose the

434

* race for the token when a new one becomes available, so the read

435

* from the pipe should not block.

436

*/

437

fcntl(job->jobPipe[0], F_SETFL,

438

fcntl(job->jobPipe[0], F_GETFL, 0) | O_NONBLOCK);

439

}

440

441

/*-

442

*-----------------------------------------------------------------------

443

* JobCondPassSig --

444

* Pass a signal to a job

445

*

446

* Input:

447

* signop Signal to send it

448

*

449

* Side Effects:

450

* None, except the job may bite it.

451

*

452

*-----------------------------------------------------------------------

453

*/

454

static void

455

JobCondPassSig(int signo)

456

{

457

Job *job;

458

459

if (DEBUG(JOB)) {

460

(void)fprintf(debug_file, "JobCondPassSig(%d) called.\n", signo);

461

}

462

463

for (job = job_table; job < job_table_end; job++) {

464

if (job->job_state != JOB_ST_RUNNING)

465

continue;

466

if (DEBUG(JOB)) {

467

(void)fprintf(debug_file,

468

"JobCondPassSig passing signal %d to child %d.\n",

469

signo, job->pid);

470

}

471

KILLPG(job->pid, signo);

472

}

473

}

474

475

/*-

476

*-----------------------------------------------------------------------

477

* JobChldSig --

478

* SIGCHLD handler.

479

*

480

* Input:

481

* signo The signal number we've received

482

*

483

* Results:

484

* None.

485

*

486

* Side Effects:

487

* Sends a token on the child exit pipe to wake us up from

488

* select()/poll().

489

*

490

*-----------------------------------------------------------------------

491

*/

492

static void

493

JobChildSig(int signo MAKE_ATTR_UNUSED)

494

{

495

while (write(childExitJob.outPipe, CHILD_EXIT, 1) == -1 && errno == EAGAIN)

496

continue;

497

}

498

499

500

/*-

501

*-----------------------------------------------------------------------

502

* JobContinueSig --

503

* Resume all stopped jobs.

504

*

505

* Input:

506

* signo The signal number we've received

507

*

508

* Results:

509

* None.

510

*

511

* Side Effects:

512

* Jobs start running again.

513

*

514

*-----------------------------------------------------------------------

515

*/

516

static void

517

JobContinueSig(int signo MAKE_ATTR_UNUSED)

518

{

519

/*

520

* Defer sending to SIGCONT to our stopped children until we return

521

* from the signal handler.

522

*/

523

while (write(childExitJob.outPipe, DO_JOB_RESUME, 1) == -1 &&

524

errno == EAGAIN)

525

continue;

526

}

527

528

/*-

529

*-----------------------------------------------------------------------

530

* JobPassSig --

531

* Pass a signal on to all jobs, then resend to ourselves.

532

*

533

* Input:

534

* signo The signal number we've received

535

*

536

* Results:

537

* None.

538

*

539

* Side Effects:

540

* We die by the same signal.

541

*

542

*-----------------------------------------------------------------------

543

*/

544

MAKE_ATTR_DEAD static void

545

JobPassSig_int(int signo)

546

{

547

/* Run .INTERRUPT target then exit */

548

JobInterrupt(TRUE, signo);

549

}

550

551

MAKE_ATTR_DEAD static void

552

JobPassSig_term(int signo)

553

{

554

/* Dont run .INTERRUPT target then exit */

555

JobInterrupt(FALSE, signo);

556

}

557

558

static void

559

JobPassSig_suspend(int signo)

560

{

561

sigset_t nmask, omask;

562

struct sigaction act;

563

564

/* Suppress job started/continued messages */

565

make_suspended = 1;

566

567

/* Pass the signal onto every job */

568

JobCondPassSig(signo);

569

570

/*

571

* Send ourselves the signal now we've given the message to everyone else.

572

* Note we block everything else possible while we're getting the signal.

573

* This ensures that all our jobs get continued when we wake up before

574

* we take any other signal.

575

*/

576

sigfillset(&nmask);

577

sigdelset(&nmask, signo);

578

(void)sigprocmask(SIG_SETMASK, &nmask, &omask);

579

580

act.sa_handler = SIG_DFL;

581

sigemptyset(&act.sa_mask);

582

act.sa_flags = 0;

583

(void)sigaction(signo, &act, NULL);

584

585

if (DEBUG(JOB)) {

586

(void)fprintf(debug_file,

587

"JobPassSig passing signal %d to self.\n", signo);

588

}

589

590

(void)kill(getpid(), signo);

591

592

/*

593

* We've been continued.

594

*

595

* A whole host of signals continue to happen!

596

* SIGCHLD for any processes that actually suspended themselves.

597

* SIGCHLD for any processes that exited while we were alseep.

598

* The SIGCONT that actually caused us to wakeup.

599

*

600

* Since we defer passing the SIGCONT on to our children until

601

* the main processing loop, we can be sure that all the SIGCHLD

602

* events will have happened by then - and that the waitpid() will

603

* collect the child 'suspended' events.

604

* For correct sequencing we just need to ensure we process the

605

* waitpid() before passign on the SIGCONT.

606

*

607

* In any case nothing else is needed here.

608

*/

609

610

/* Restore handler and signal mask */

611

act.sa_handler = JobPassSig_suspend;

612

(void)sigaction(signo, &act, NULL);

613

(void)sigprocmask(SIG_SETMASK, &omask, NULL);

614

}

615

616

/*-

617

*-----------------------------------------------------------------------

618

* JobFindPid --

619

* Compare the pid of the job with the given pid and return 0 if they

620

* are equal. This function is called from Job_CatchChildren

621

* to find the job descriptor of the finished job.

622

*

623

* Input:

624

* job job to examine

625

* pid process id desired

626

*

627

* Results:

628

* Job with matching pid

629

*

630

* Side Effects:

631

* None

632

*-----------------------------------------------------------------------

633

*/

634

static Job *

635

JobFindPid(int pid, int status, Boolean isJobs)

636

{

637

Job *job;

638

639

for (job = job_table; job < job_table_end; job++) {

640

if ((job->job_state == status) && job->pid == pid)

641

return job;

642

}

643

if (DEBUG(JOB) && isJobs)

644

job_table_dump("no pid");

645

return NULL;

646

}

647

648

/*-

649

*-----------------------------------------------------------------------

650

* JobPrintCommand --

651

* Put out another command for the given job. If the command starts

652

* with an @ or a - we process it specially. In the former case,

653

* so long as the -s and -n flags weren't given to make, we stick

654

* a shell-specific echoOff command in the script. In the latter,

655

* we ignore errors for the entire job, unless the shell has error

656

* control.

657

* If the command is just "..." we take all future commands for this

658

* job to be commands to be executed once the entire graph has been

659

* made and return non-zero to signal that the end of the commands

660

* was reached. These commands are later attached to the postCommands

661

* node and executed by Job_End when all things are done.

662

* This function is called from JobStart via Lst_ForEach.

663

*

664

* Input:

665

* cmdp command string to print

666

* jobp job for which to print it

667

*

668

* Results:

669

* Always 0, unless the command was "..."

670

*

671

* Side Effects:

672

* If the command begins with a '-' and the shell has no error control,

673

* the JOB_IGNERR flag is set in the job descriptor.

674

* If the command is "..." and we're not ignoring such things,

675

* tailCmds is set to the successor node of the cmd.

676

* numCommands is incremented if the command is actually printed.

677

*-----------------------------------------------------------------------

678

*/

679

static int

680

JobPrintCommand(void *cmdp, void *jobp)

681

{

682

Boolean noSpecials; /* true if we shouldn't worry about

683

* inserting special commands into

684

* the input stream. */

685

Boolean shutUp = FALSE; /* true if we put a no echo command

686

* into the command file */

687

Boolean errOff = FALSE; /* true if we turned error checking

688

* off before printing the command

689

* and need to turn it back on */

690

const char *cmdTemplate; /* Template to use when printing the

691

* command */

692

char *cmdStart; /* Start of expanded command */

693

char *escCmd = NULL; /* Command with quotes/backticks escaped */

694

char *cmd = (char *)cmdp;

695

Job *job = (Job *)jobp;

696

int i, j;

697

698

noSpecials = NoExecute(job->node);

699

700

if (strcmp(cmd, "...") == 0) {

701

job->node->type |= OP_SAVE_CMDS;

702

if ((job->flags & JOB_IGNDOTS) == 0) {

703

job->tailCmds = Lst_Succ(Lst_Member(job->node->commands,

704

cmd));

705

return 1;

706

}

707

return 0;

708

}

709

710

#define DBPRINTF(fmt, arg) if (DEBUG(JOB)) { \

711

(void)fprintf(debug_file, fmt, arg); \

712

} \

713

(void)fprintf(job->cmdFILE, fmt, arg); \

714

(void)fflush(job->cmdFILE);

715

716

numCommands += 1;

717

718

cmdStart = cmd = Var_Subst(NULL, cmd, job->node, FALSE);

719

720

cmdTemplate = "%s\n";

721

722

/*

723

* Check for leading @' and -'s to control echoing and error checking.

724

*/

725

while (*cmd == '@' || *cmd == '-' || (*cmd == '+')) {

726

switch (*cmd) {

727

case '@':

728

shutUp = DEBUG(LOUD) ? FALSE : TRUE;

729

break;

730

case '-':

731

job->flags |= JOB_IGNERR;

732

errOff = TRUE;

733

break;

734

case '+':

735

if (noSpecials) {

736

/*

737

* We're not actually executing anything...

738

* but this one needs to be - use compat mode just for it.

739

*/

740

CompatRunCommand(cmdp, job->node);

741

return 0;

742

}

743

break;

744

}

745

cmd++;

746

}

747

748

while (isspace((unsigned char) *cmd))

749

cmd++;

750

751

/*

752

* If the shell doesn't have error control the alternate echo'ing will

753

* be done (to avoid showing additional error checking code)

754

* and this will need the characters '$ ` \ "' escaped

755

*/

756

757

if (!commandShell->hasErrCtl) {

758

/* Worst that could happen is every char needs escaping. */

759

escCmd = bmake_malloc((strlen(cmd) * 2) + 1);

760

for (i = 0, j= 0; cmd[i] != '\0'; i++, j++) {

761

if (cmd[i] == '$' || cmd[i] == '`' || cmd[i] == '\\' ||

762

cmd[i] == '"')

763

escCmd[j++] = '\\';

764

escCmd[j] = cmd[i];

765

}

766

escCmd[j] = 0;

767

}

768

769

if (shutUp) {

770

if (!(job->flags & JOB_SILENT) && !noSpecials &&

771

commandShell->hasEchoCtl) {

772

DBPRINTF("%s\n", commandShell->echoOff);

773

} else {

774

if (commandShell->hasErrCtl)

775

shutUp = FALSE;

776

}

777

}

778

779

if (errOff) {

780

if (!noSpecials) {

781

if (commandShell->hasErrCtl) {

782

/*

783

* we don't want the error-control commands showing

784

* up either, so we turn off echoing while executing

785

* them. We could put another field in the shell

786

* structure to tell JobDoOutput to look for this

787

* string too, but why make it any more complex than

788

* it already is?

789

*/

790

if (!(job->flags & JOB_SILENT) && !shutUp &&

791

commandShell->hasEchoCtl) {

792

DBPRINTF("%s\n", commandShell->echoOff);

793

DBPRINTF("%s\n", commandShell->ignErr);

794

DBPRINTF("%s\n", commandShell->echoOn);

795

} else {

796

DBPRINTF("%s\n", commandShell->ignErr);

797

}

798

} else if (commandShell->ignErr &&

799

(*commandShell->ignErr != '\0'))

800

{

801

/*

802

* The shell has no error control, so we need to be

803

* weird to get it to ignore any errors from the command.

804

* If echoing is turned on, we turn it off and use the

805

* errCheck template to echo the command. Leave echoing

806

* off so the user doesn't see the weirdness we go through

807

* to ignore errors. Set cmdTemplate to use the weirdness

808

* instead of the simple "%s\n" template.

809

*/

810

if (!(job->flags & JOB_SILENT) && !shutUp) {

811

if (commandShell->hasEchoCtl) {

812

DBPRINTF("%s\n", commandShell->echoOff);

813

}

814

DBPRINTF(commandShell->errCheck, escCmd);

815

shutUp = TRUE;

816

} else {

817

if (!shutUp) {

818

DBPRINTF(commandShell->errCheck, escCmd);

819

}

820

}

821

cmdTemplate = commandShell->ignErr;

822

/*

823

* The error ignoration (hee hee) is already taken care

824

* of by the ignErr template, so pretend error checking

825

* is still on.

826

*/

827

errOff = FALSE;

828

} else {

829

errOff = FALSE;

830

}

831

} else {

832

errOff = FALSE;

833

}

834

} else {

835

836

/*

837

* If errors are being checked and the shell doesn't have error control

838

* but does supply an errOut template, then setup commands to run

839

* through it.

840

*/

841

842

if (!commandShell->hasErrCtl && commandShell->errOut &&

843

(*commandShell->errOut != '\0')) {

844

if (!(job->flags & JOB_SILENT) && !shutUp) {

845

if (commandShell->hasEchoCtl) {

846

DBPRINTF("%s\n", commandShell->echoOff);

847

}

848

DBPRINTF(commandShell->errCheck, escCmd);

849

shutUp = TRUE;

850

}

851

/* If it's a comment line or blank, treat as an ignored error */

852

if ((escCmd[0] == commandShell->commentChar) ||

853

(escCmd[0] == 0))

854

cmdTemplate = commandShell->ignErr;

855

else

856

cmdTemplate = commandShell->errOut;

857

errOff = FALSE;

858

}

859

}

860

861

if (DEBUG(SHELL) && strcmp(shellName, "sh") == 0 &&

862

(job->flags & JOB_TRACED) == 0) {

863

DBPRINTF("set -%s\n", "x");

864

job->flags |= JOB_TRACED;

865

}

866

867

DBPRINTF(cmdTemplate, cmd);

868

free(cmdStart);

869

if (escCmd)

870

free(escCmd);

871

if (errOff) {

872

/*

873

* If echoing is already off, there's no point in issuing the

874

* echoOff command. Otherwise we issue it and pretend it was on

875

* for the whole command...

876

*/

877

if (!shutUp && !(job->flags & JOB_SILENT) && commandShell->hasEchoCtl){

878

DBPRINTF("%s\n", commandShell->echoOff);

879

shutUp = TRUE;

880

}

881

DBPRINTF("%s\n", commandShell->errCheck);

882

}

883

if (shutUp && commandShell->hasEchoCtl) {

884

DBPRINTF("%s\n", commandShell->echoOn);

885

}

886

return 0;

887

}

888

889

/*-

890

*-----------------------------------------------------------------------

891

* JobSaveCommand --

892

* Save a command to be executed when everything else is done.

893

* Callback function for JobFinish...

894

*

895

* Results:

896

* Always returns 0

897

*

898

* Side Effects:

899

* The command is tacked onto the end of postCommands's commands list.

900

*

901

*-----------------------------------------------------------------------

902

*/

903

static int

904

JobSaveCommand(void *cmd, void *gn)

905

{

906

cmd = Var_Subst(NULL, (char *)cmd, (GNode *)gn, FALSE);

907

(void)Lst_AtEnd(postCommands->commands, cmd);

908

return(0);

909

}

910

911

912

/*-

913

*-----------------------------------------------------------------------

914

* JobClose --

915

* Called to close both input and output pipes when a job is finished.

916

*

917

* Results:

918

* Nada

919

*

920

* Side Effects:

921

* The file descriptors associated with the job are closed.

922

*

923

*-----------------------------------------------------------------------

924

*/

925

static void

926

JobClose(Job *job)

927

{

928

clearfd(job);

929

(void)close(job->outPipe);

930

job->outPipe = -1;

931

932

JobDoOutput(job, TRUE);

933

(void)close(job->inPipe);

934

job->inPipe = -1;

935

}

936

937

/*-

938

*-----------------------------------------------------------------------

939

* JobFinish --

940

* Do final processing for the given job including updating

941

* parents and starting new jobs as available/necessary. Note

942

* that we pay no attention to the JOB_IGNERR flag here.

943

* This is because when we're called because of a noexecute flag

944

* or something, jstat.w_status is 0 and when called from

945

* Job_CatchChildren, the status is zeroed if it s/b ignored.

946

*

947

* Input:

948

* job job to finish

949

* status sub-why job went away

950

*

951

* Results:

952

* None

953

*

954

* Side Effects:

955

* Final commands for the job are placed on postCommands.

956

*

957

* If we got an error and are aborting (aborting == ABORT_ERROR) and

958

* the job list is now empty, we are done for the day.

959

* If we recognized an error (errors !=0), we set the aborting flag

960

* to ABORT_ERROR so no more jobs will be started.

961

*-----------------------------------------------------------------------

962

*/

963

/*ARGSUSED*/

964

static void

965

JobFinish (Job *job, WAIT_T status)

966

{

967

Boolean done, return_job_token;

968

969

if (DEBUG(JOB)) {

970

fprintf(debug_file, "Jobfinish: %d [%s], status %d\n",

971

job->pid, job->node->name, status);

972

}

973

974

if ((WIFEXITED(status) &&

975

(((WEXITSTATUS(status) != 0) && !(job->flags & JOB_IGNERR)))) ||

976

WIFSIGNALED(status))

977

{

978

/*

979

* If it exited non-zero and either we're doing things our

980

* way or we're not ignoring errors, the job is finished.

981

* Similarly, if the shell died because of a signal

982

* the job is also finished. In these

983

* cases, finish out the job's output before printing the exit

984

* status...

985

*/

986

JobClose(job);

987

if (job->cmdFILE != NULL && job->cmdFILE != stdout) {

988

(void)fclose(job->cmdFILE);

989

job->cmdFILE = NULL;

990

}

991

done = TRUE;

992

} else if (WIFEXITED(status)) {

993

/*

994

* Deal with ignored errors in -B mode. We need to print a message

995

* telling of the ignored error as well as setting status.w_status

996

* to 0 so the next command gets run. To do this, we set done to be

997

* TRUE if in -B mode and the job exited non-zero.

998

*/

999

done = WEXITSTATUS(status) != 0;

1000

/*

1001

* Old comment said: "Note we don't

1002

* want to close down any of the streams until we know we're at the

1003

* end."

1004

* But we do. Otherwise when are we going to print the rest of the

1005

* stuff?

1006

*/

1007

JobClose(job);

1008

} else {

1009

/*

1010

* No need to close things down or anything.

1011

*/

1012

done = FALSE;

1013

}

1014

1015

if (done) {

1016

if (WIFEXITED(status)) {

1017

if (DEBUG(JOB)) {

1018

(void)fprintf(debug_file, "Process %d [%s] exited.\n",

1019

job->pid, job->node->name);

1020

}

1021

if (WEXITSTATUS(status) != 0) {

1022

if (job->node != lastNode) {

1023

MESSAGE(stdout, job->node);

1024

lastNode = job->node;

1025

}

1026

#ifdef USE_META

1027

if (useMeta) {

1028

meta_job_error(job, job->node, job->flags, WEXITSTATUS(status));

1029

}

1030

#endif

1031

(void)printf("*** [%s] Error code %d%s\n",

1032

job->node->name,

1033

WEXITSTATUS(status),

1034

(job->flags & JOB_IGNERR) ? " (ignored)" : "");

1035

if (job->flags & JOB_IGNERR) {

1036

WAIT_STATUS(status) = 0;

1037

} else {

1038

PrintOnError(job->node, NULL);

1039

}

1040

} else if (DEBUG(JOB)) {

1041

if (job->node != lastNode) {

1042

MESSAGE(stdout, job->node);

1043

lastNode = job->node;

1044

}

1045

(void)printf("*** [%s] Completed successfully\n",

1046

job->node->name);

1047

}

1048

} else {

1049

if (job->node != lastNode) {

1050

MESSAGE(stdout, job->node);

1051

lastNode = job->node;

1052

}

1053

(void)printf("*** [%s] Signal %d\n",

1054

job->node->name, WTERMSIG(status));

1055

}

1056

(void)fflush(stdout);

1057

}

1058

1059

#ifdef USE_META

1060

if (useMeta) {

1061

meta_job_finish(job);

1062

}

1063

#endif

1064

1065

return_job_token = FALSE;

1066

1067

Trace_Log(JOBEND, job);

1068

if (!(job->flags & JOB_SPECIAL)) {

1069

if ((WAIT_STATUS(status) != 0) ||

1070

(aborting == ABORT_ERROR) ||

1071

(aborting == ABORT_INTERRUPT))

1072

return_job_token = TRUE;

1073

}

1074

1075

if ((aborting != ABORT_ERROR) && (aborting != ABORT_INTERRUPT) &&

1076

(WAIT_STATUS(status) == 0)) {

1077

/*

1078

* As long as we aren't aborting and the job didn't return a non-zero

1079

* status that we shouldn't ignore, we call Make_Update to update

1080

* the parents. In addition, any saved commands for the node are placed

1081

* on the .END target.

1082

*/

1083

if (job->tailCmds != NULL) {

1084

Lst_ForEachFrom(job->node->commands, job->tailCmds,

1085

JobSaveCommand,

1086

job->node);

1087

}

1088

job->node->made = MADE;

1089

if (!(job->flags & JOB_SPECIAL))

1090

return_job_token = TRUE;

1091

Make_Update(job->node);

1092

job->job_state = JOB_ST_FREE;

1093

} else if (WAIT_STATUS(status)) {

1094

errors += 1;

1095

job->job_state = JOB_ST_FREE;

1096

}

1097

1098

/*

1099

* Set aborting if any error.

1100

*/

1101

if (errors && !keepgoing && (aborting != ABORT_INTERRUPT)) {

1102

/*

1103

* If we found any errors in this batch of children and the -k flag

1104

* wasn't given, we set the aborting flag so no more jobs get

1105

* started.

1106

*/

1107

aborting = ABORT_ERROR;

1108

}

1109

1110

if (return_job_token)

1111

Job_TokenReturn();

1112

1113

if (aborting == ABORT_ERROR && jobTokensRunning == 0) {

1114

/*

1115

* If we are aborting and the job table is now empty, we finish.

1116

*/

1117

Finish(errors);

1118

}

1119

}

1120

1121

/*-

1122

*-----------------------------------------------------------------------

1123

* Job_Touch --

1124

* Touch the given target. Called by JobStart when the -t flag was

1125

* given

1126

*

1127

* Input:

1128

* gn the node of the file to touch

1129

* silent TRUE if should not print message

1130

*

1131

* Results:

1132

* None

1133

*

1134

* Side Effects:

1135

* The data modification of the file is changed. In addition, if the

1136

* file did not exist, it is created.

1137

*-----------------------------------------------------------------------

1138

*/

1139

void

1140

Job_Touch(GNode *gn, Boolean silent)

1141

{

1142

int streamID; /* ID of stream opened to do the touch */

1143

struct utimbuf times; /* Times for utime() call */

1144

1145

1146

OP_SPECIAL|OP_PHONY)) {

1147

/*

1148

* .JOIN, .USE, .ZEROTIME and .OPTIONAL targets are "virtual" targets

1149

* and, as such, shouldn't really be created.

1150

*/

1151

return;

1152

}

1153

1154

if (!silent || NoExecute(gn)) {

1155

(void)fprintf(stdout, "touch %s\n", gn->name);

1156

(void)fflush(stdout);

1157

}

1158

1159

if (NoExecute(gn)) {

1160

return;

1161

}

1162

1163

if (gn->type & OP_ARCHV) {

1164

Arch_Touch(gn);

1165

} else if (gn->type & OP_LIB) {

1166

Arch_TouchLib(gn);

1167

} else {

1168

char *file = gn->path ? gn->path : gn->name;

1169

1170

times.actime = times.modtime = now;

1171

if (utime(file, &times) < 0){

1172

streamID = open(file, O_RDWR | O_CREAT, 0666);

1173

1174

if (streamID >= 0) {

1175

char c;

1176

1177

/*

1178

* Read and write a byte to the file to change the

1179

* modification time, then close the file.

1180

*/

1181

if (read(streamID, &c, 1) == 1) {

1182

(void)lseek(streamID, (off_t)0, SEEK_SET);

1183

while (write(streamID, &c, 1) == -1 && errno == EAGAIN)

1184

continue;

1185

}

1186

1187

(void)close(streamID);

1188

} else {

1189

(void)fprintf(stdout, "*** couldn't touch %s: %s",

1190

file, strerror(errno));

1191

(void)fflush(stdout);

1192

}

1193

}

1194

}

1195

}

1196

1197

/*-

1198

*-----------------------------------------------------------------------

1199

* Job_CheckCommands --

1200

* Make sure the given node has all the commands it needs.

1201

*

1202

* Input:

1203

* gn The target whose commands need verifying

1204

* abortProc Function to abort with message

1205

*

1206

* Results:

1207

* TRUE if the commands list is/was ok.

1208

*

1209

* Side Effects:

1210

* The node will have commands from the .DEFAULT rule added to it

1211

* if it needs them.

1212

*-----------------------------------------------------------------------

1213

*/

1214

Boolean

1215

Job_CheckCommands(GNode *gn, void (*abortProc)(const char *, ...))

1216

{

1217

if (OP_NOP(gn->type) && Lst_IsEmpty(gn->commands) &&

1218

((gn->type & OP_LIB) == 0 || Lst_IsEmpty(gn->children))) {

1219

/*

1220

* No commands. Look for .DEFAULT rule from which we might infer

1221

* commands

1222

*/

1223

if ((DEFAULT != NULL) && !Lst_IsEmpty(DEFAULT->commands) &&

1224

(gn->type & OP_SPECIAL) == 0) {

1225

char *p1;

1226

/*

1227

* Make only looks for a .DEFAULT if the node was never the

1228

* target of an operator, so that's what we do too. If

1229

* a .DEFAULT was given, we substitute its commands for gn's

1230

* commands and set the IMPSRC variable to be the target's name

1231

* The DEFAULT node acts like a transformation rule, in that

1232

* gn also inherits any attributes or sources attached to

1233

* .DEFAULT itself.

1234

*/

1235

Make_HandleUse(DEFAULT, gn);

1236

Var_Set(IMPSRC, Var_Value(TARGET, gn, &p1), gn, 0);

1237

if (p1)

1238

free(p1);

1239

} else if (Dir_MTime(gn, 0) == 0 && (gn->type & OP_SPECIAL) == 0) {

1240

/*

1241

* The node wasn't the target of an operator we have no .DEFAULT

1242

* rule to go on and the target doesn't already exist. There's

1243

* nothing more we can do for this branch. If the -k flag wasn't

1244

* given, we stop in our tracks, otherwise we just don't update

1245

* this node's parents so they never get examined.

1246

*/

1247

static const char msg[] = ": don't know how to make";

1248

1249

if (gn->flags & FROM_DEPEND) {

1250

if (!Job_RunTarget(".STALE", gn->fname))

1251

fprintf(stdout, "%s: %s, %d: ignoring stale %s for %s\n",

1252

progname, gn->fname, gn->lineno, makeDependfile,

1253

gn->name);

1254

return TRUE;

1255

}

1256

1257

if (gn->type & OP_OPTIONAL) {

1258

(void)fprintf(stdout, "%s%s %s (ignored)\n", progname,

1259

msg, gn->name);

1260

(void)fflush(stdout);

1261

} else if (keepgoing) {

1262

(void)fprintf(stdout, "%s%s %s (continuing)\n", progname,

1263

msg, gn->name);

1264

(void)fflush(stdout);

1265

return FALSE;

1266

} else {

1267

(*abortProc)("%s%s %s. Stop", progname, msg, gn->name);

1268

return FALSE;

1269

}

1270

}

1271

}

1272

return TRUE;

1273

}

1274

1275

/*-

1276

*-----------------------------------------------------------------------

1277

* JobExec --

1278

* Execute the shell for the given job. Called from JobStart

1279

*

1280

* Input:

1281

* job Job to execute

1282

*

1283

* Results:

1284

* None.

1285

*

1286

* Side Effects:

1287

* A shell is executed, outputs is altered and the Job structure added

1288

* to the job table.

1289

*

1290

*-----------------------------------------------------------------------

1291

*/

1292

static void

1293

JobExec(Job *job, char **argv)

1294

{

1295

int cpid; /* ID of new child */

1296

sigset_t mask;

1297

1298

job->flags &= ~JOB_TRACED;

1299

1300

if (DEBUG(JOB)) {

1301

int i;

1302

1303

(void)fprintf(debug_file, "Running %s %sly\n", job->node->name, "local");

1304

(void)fprintf(debug_file, "\tCommand: ");

1305

for (i = 0; argv[i] != NULL; i++) {

1306

(void)fprintf(debug_file, "%s ", argv[i]);

1307

}

1308

(void)fprintf(debug_file, "\n");

1309

}

1310

1311

/*

1312

* Some jobs produce no output and it's disconcerting to have

1313

* no feedback of their running (since they produce no output, the

1314

* banner with their name in it never appears). This is an attempt to

1315

* provide that feedback, even if nothing follows it.

1316

*/

1317

if ((lastNode != job->node) && !(job->flags & JOB_SILENT)) {

1318

MESSAGE(stdout, job->node);

1319

lastNode = job->node;

1320

}

1321

1322

/* No interruptions until this job is on the `jobs' list */

1323

JobSigLock(&mask);

1324

1325

/* Pre-emptively mark job running, pid still zero though */

1326

job->job_state = JOB_ST_RUNNING;

1327

1328

cpid = vFork();

1329

if (cpid == -1)

1330

Punt("Cannot vfork: %s", strerror(errno));

1331

1332

if (cpid == 0) {

1333

/* Child */

1334

sigset_t tmask;

1335

1336

#ifdef USE_META

1337

if (useMeta) {

1338

meta_job_child(job);

1339

}

1340

#endif

1341

/*

1342

* Reset all signal handlers; this is necessary because we also

1343

* need to unblock signals before we exec(2).

1344

*/

1345

JobSigReset();

1346

1347

/* Now unblock signals */

1348

sigemptyset(&tmask);

1349

JobSigUnlock(&tmask);

1350

1351

/*

1352

* Must duplicate the input stream down to the child's input and

1353

* reset it to the beginning (again). Since the stream was marked

1354

* close-on-exec, we must clear that bit in the new input.

1355

*/

1356

if (dup2(FILENO(job->cmdFILE), 0) == -1) {

1357

execError("dup2", "job->cmdFILE");

1358

_exit(1);

1359

}

1360

(void)fcntl(0, F_SETFD, 0);

1361

(void)lseek(0, (off_t)0, SEEK_SET);

1362

1363

if (job->node->type & OP_MAKE) {

1364

/*

1365

* Pass job token pipe to submakes.

1366

*/

1367

fcntl(tokenWaitJob.inPipe, F_SETFD, 0);

1368

fcntl(tokenWaitJob.outPipe, F_SETFD, 0);

1369

}

1370

1371

/*

1372

* Set up the child's output to be routed through the pipe

1373

* we've created for it.

1374

*/

1375

if (dup2(job->outPipe, 1) == -1) {

1376

execError("dup2", "job->outPipe");

1377

_exit(1);

1378

}

1379

/*

1380

* The output channels are marked close on exec. This bit was

1381

* duplicated by the dup2(on some systems), so we have to clear

1382

* it before routing the shell's error output to the same place as

1383

* its standard output.

1384

*/

1385

(void)fcntl(1, F_SETFD, 0);

1386

if (dup2(1, 2) == -1) {

1387

execError("dup2", "1, 2");

1388

_exit(1);

1389

}

1390

1391

/*

1392

* We want to switch the child into a different process family so

1393

* we can kill it and all its descendants in one fell swoop,

1394

* by killing its process family, but not commit suicide.

1395

*/

1396

#if defined(HAVE_SETPGID)

1397

(void)setpgid(0, getpid());

1398

#else

1399

#if defined(HAVE_SETSID)

1400

/* XXX: dsl - I'm sure this should be setpgrp()... */

1401

(void)setsid();

1402

#else

1403

(void)setpgrp(0, getpid());

1404

#endif

1405

#endif

1406

1407

Var_ExportVars();

1408

1409

(void)execv(shellPath, argv);

1410

execError("exec", shellPath);

1411

_exit(1);

1412

}

1413

1414

/* Parent, continuing after the child exec */

1415

job->pid = cpid;

1416

1417

Trace_Log(JOBSTART, job);

1418

1419

/*

1420

* Set the current position in the buffer to the beginning

1421

* and mark another stream to watch in the outputs mask

1422

*/

1423

job->curPos = 0;

1424

1425

watchfd(job);

1426

1427

if (job->cmdFILE != NULL && job->cmdFILE != stdout) {

1428

(void)fclose(job->cmdFILE);

1429

job->cmdFILE = NULL;

1430

}

1431

1432

/*

1433

* Now the job is actually running, add it to the table.

1434

*/

1435

if (DEBUG(JOB)) {

1436

fprintf(debug_file, "JobExec(%s): pid %d added to jobs table\n",

1437

job->node->name, job->pid);

1438

job_table_dump("job started");

1439

}

1440

JobSigUnlock(&mask);

1441

}

1442

1443

/*-

1444

*-----------------------------------------------------------------------

1445

* JobMakeArgv --

1446

* Create the argv needed to execute the shell for a given job.

1447

*

1448

*

1449

* Results:

1450

*

1451

* Side Effects:

1452

*

1453

*-----------------------------------------------------------------------

1454

*/

1455

static void

1456

JobMakeArgv(Job *job, char **argv)

1457

{

1458

int argc;

1459

static char args[10]; /* For merged arguments */

1460

1461

argv[0] = UNCONST(shellName);

1462

argc = 1;

1463

1464

if ((commandShell->exit && (*commandShell->exit != '-')) ||

1465

(commandShell->echo && (*commandShell->echo != '-')))

1466

{

1467

/*

1468

* At least one of the flags doesn't have a minus before it, so

1469

* merge them together. Have to do this because the *(&(@*#*&#$#

1470

* Bourne shell thinks its second argument is a file to source.

1471

* Grrrr. Note the ten-character limitation on the combined arguments.

1472

*/

1473

(void)snprintf(args, sizeof(args), "-%s%s",

1474

((job->flags & JOB_IGNERR) ? "" :

1475

(commandShell->exit ? commandShell->exit : "")),

1476

((job->flags & JOB_SILENT) ? "" :

1477

(commandShell->echo ? commandShell->echo : "")));

1478

1479

if (args[1]) {

1480

argv[argc] = args;

1481

argc++;

1482

}

1483

} else {

1484

if (!(job->flags & JOB_IGNERR) && commandShell->exit) {

1485

argv[argc] = UNCONST(commandShell->exit);

1486

argc++;

1487

}

1488

if (!(job->flags & JOB_SILENT) && commandShell->echo) {

1489

argv[argc] = UNCONST(commandShell->echo);

1490

argc++;

1491

}

1492

}

1493

argv[argc] = NULL;

1494

}

1495

1496

/*-

1497

*-----------------------------------------------------------------------

1498

* JobStart --

1499

* Start a target-creation process going for the target described

1500

* by the graph node gn.

1501

*

1502

* Input:

1503

* gn target to create

1504

* flags flags for the job to override normal ones.

1505

* e.g. JOB_SPECIAL or JOB_IGNDOTS

1506

* previous The previous Job structure for this node, if any.

1507

*

1508

* Results:

1509

* JOB_ERROR if there was an error in the commands, JOB_FINISHED

1510

* if there isn't actually anything left to do for the job and

1511

* JOB_RUNNING if the job has been started.

1512

*

1513

* Side Effects:

1514

* A new Job node is created and added to the list of running

1515

* jobs. PMake is forked and a child shell created.

1516

*

1517

* NB: I'm fairly sure that this code is never called with JOB_SPECIAL set

1518

* JOB_IGNDOTS is never set (dsl)

1519

* Also the return value is ignored by everyone.

1520

*-----------------------------------------------------------------------

1521

*/

1522

static int

1523

JobStart(GNode *gn, int flags)

1524

{

1525

Job *job; /* new job descriptor */

1526

char *argv[10]; /* Argument vector to shell */

1527

Boolean cmdsOK; /* true if the nodes commands were all right */

1528

Boolean noExec; /* Set true if we decide not to run the job */

1529

int tfd; /* File descriptor to the temp file */

1530

1531

for (job = job_table; job < job_table_end; job++) {

1532

if (job->job_state == JOB_ST_FREE)

1533

break;

1534

}

1535

if (job >= job_table_end)

1536

Punt("JobStart no job slots vacant");

1537

1538

memset(job, 0, sizeof *job);

1539

job->job_state = JOB_ST_SETUP;

1540

if (gn->type & OP_SPECIAL)

1541

flags |= JOB_SPECIAL;

1542

1543

job->node = gn;

1544

job->tailCmds = NULL;

1545

1546

/*

1547

* Set the initial value of the flags for this job based on the global

1548

* ones and the node's attributes... Any flags supplied by the caller

1549

* are also added to the field.

1550

*/

1551

job->flags = 0;

1552

if (Targ_Ignore(gn)) {

1553

job->flags |= JOB_IGNERR;

1554

}

1555

if (Targ_Silent(gn)) {

1556

job->flags |= JOB_SILENT;

1557

}

1558

job->flags |= flags;

1559

1560

/*

1561

* Check the commands now so any attributes from .DEFAULT have a chance

1562

* to migrate to the node

1563

*/

1564

cmdsOK = Job_CheckCommands(gn, Error);

1565

1566

job->inPollfd = NULL;

1567

/*

1568

* If the -n flag wasn't given, we open up OUR (not the child's)

1569

* temporary file to stuff commands in it. The thing is rd/wr so we don't

1570

* need to reopen it to feed it to the shell. If the -n flag *was* given,

1571

* we just set the file to be stdout. Cute, huh?

1572

*/

1573

if (((gn->type & OP_MAKE) && !(noRecursiveExecute)) ||

1574

(!noExecute && !touchFlag)) {

1575

/*

1576

* tfile is the name of a file into which all shell commands are

1577

* put. It is removed before the child shell is executed, unless

1578

* DEBUG(SCRIPT) is set.

1579

*/

1580

char *tfile;

1581

sigset_t mask;

1582

/*

1583

* We're serious here, but if the commands were bogus, we're

1584

* also dead...

1585

*/

1586

if (!cmdsOK) {

1587

PrintOnError(gn, NULL); /* provide some clue */

1588

DieHorribly();

1589

}

1590

1591

JobSigLock(&mask);

1592

tfd = mkTempFile(TMPPAT, &tfile);

1593

if (!DEBUG(SCRIPT))

1594

(void)eunlink(tfile);

1595

JobSigUnlock(&mask);

1596

1597

job->cmdFILE = fdopen(tfd, "w+");

1598

if (job->cmdFILE == NULL) {

1599

Punt("Could not fdopen %s", tfile);

1600

}

1601

(void)fcntl(FILENO(job->cmdFILE), F_SETFD, 1);

1602

/*

1603

* Send the commands to the command file, flush all its buffers then

1604

* rewind and remove the thing.

1605

*/

1606

noExec = FALSE;

1607

1608

#ifdef USE_META

1609

if (useMeta) {

1610

meta_job_start(job, gn);

1611

if (Targ_Silent(gn)) { /* might have changed */

1612

job->flags |= JOB_SILENT;

1613

}

1614

}

1615

#endif

1616

/*

1617

* We can do all the commands at once. hooray for sanity

1618

*/

1619

numCommands = 0;

1620

Lst_ForEach(gn->commands, JobPrintCommand, job);

1621

1622

/*

1623

* If we didn't print out any commands to the shell script,

1624

* there's not much point in executing the shell, is there?

1625

*/

1626

if (numCommands == 0) {

1627

noExec = TRUE;

1628

}

1629

1630

free(tfile);

1631

} else if (NoExecute(gn)) {

1632

/*

1633

* Not executing anything -- just print all the commands to stdout

1634

* in one fell swoop. This will still set up job->tailCmds correctly.

1635

*/

1636

if (lastNode != gn) {

1637

MESSAGE(stdout, gn);

1638

lastNode = gn;

1639

}

1640

job->cmdFILE = stdout;

1641

/*

1642

* Only print the commands if they're ok, but don't die if they're

1643

* not -- just let the user know they're bad and keep going. It

1644

* doesn't do any harm in this case and may do some good.

1645

*/

1646

if (cmdsOK) {

1647

Lst_ForEach(gn->commands, JobPrintCommand, job);

1648

}

1649

/*

1650

* Don't execute the shell, thank you.

1651

*/

1652

noExec = TRUE;

1653

} else {

1654

/*

1655

* Just touch the target and note that no shell should be executed.

1656

* Set cmdFILE to stdout to make life easier. Check the commands, too,

1657

* but don't die if they're no good -- it does no harm to keep working

1658

* up the graph.

1659

*/

1660

job->cmdFILE = stdout;

1661

Job_Touch(gn, job->flags&JOB_SILENT);

1662

noExec = TRUE;

1663

}

1664

/* Just in case it isn't already... */

1665

(void)fflush(job->cmdFILE);

1666

1667

/*

1668

* If we're not supposed to execute a shell, don't.

1669

*/

1670

if (noExec) {

1671

if (!(job->flags & JOB_SPECIAL))

1672

Job_TokenReturn();

1673

/*

1674

* Unlink and close the command file if we opened one

1675

*/

1676

if (job->cmdFILE != stdout) {

1677

if (job->cmdFILE != NULL) {

1678

(void)fclose(job->cmdFILE);

1679

job->cmdFILE = NULL;

1680

}

1681

}

1682

1683

/*

1684

* We only want to work our way up the graph if we aren't here because

1685

* the commands for the job were no good.

1686

*/

1687

if (cmdsOK && aborting == 0) {

1688

if (job->tailCmds != NULL) {

1689

Lst_ForEachFrom(job->node->commands, job->tailCmds,

1690

JobSaveCommand,

1691

job->node);

1692

}

1693

job->node->made = MADE;

1694

Make_Update(job->node);

1695

}

1696

job->job_state = JOB_ST_FREE;

1697

return cmdsOK ? JOB_FINISHED : JOB_ERROR;

1698

}

1699

1700

/*

1701

* Set up the control arguments to the shell. This is based on the flags

1702

* set earlier for this job.

1703

*/

1704

JobMakeArgv(job, argv);

1705

1706

/* Create the pipe by which we'll get the shell's output. */

1707

JobCreatePipe(job, 3);

1708

1709

JobExec(job, argv);

1710

return(JOB_RUNNING);

1711

}

1712

1713

static char *

1714

JobOutput(Job *job, char *cp, char *endp, int msg)

1715

{

1716

char *ecp;

1717

1718

if (commandShell->noPrint) {

1719

ecp = Str_FindSubstring(cp, commandShell->noPrint);

1720

while (ecp != NULL) {

1721

if (cp != ecp) {

1722

*ecp = '\0';

1723

if (!beSilent && msg && job->node != lastNode) {

1724

MESSAGE(stdout, job->node);

1725

lastNode = job->node;

1726

}

1727

/*

1728

* The only way there wouldn't be a newline after

1729

* this line is if it were the last in the buffer.

1730

* however, since the non-printable comes after it,

1731

* there must be a newline, so we don't print one.

1732

*/

1733

(void)fprintf(stdout, "%s", cp);

1734

(void)fflush(stdout);

1735

}

1736

cp = ecp + commandShell->noPLen;

1737

if (cp != endp) {

1738

/*

1739

* Still more to print, look again after skipping

1740

* the whitespace following the non-printable

1741

* command....

1742

*/

1743

cp++;

1744

while (*cp == ' ' || *cp == '\t' || *cp == '\n') {

1745

cp++;

1746

}

1747

ecp = Str_FindSubstring(cp, commandShell->noPrint);

1748

} else {

1749

return cp;

1750

}

1751

}

1752

}

1753

return cp;

1754

}

1755

1756

/*-

1757

*-----------------------------------------------------------------------

1758

* JobDoOutput --

1759

* This function is called at different times depending on

1760

* whether the user has specified that output is to be collected

1761

* via pipes or temporary files. In the former case, we are called

1762

* whenever there is something to read on the pipe. We collect more

1763

* output from the given job and store it in the job's outBuf. If

1764

* this makes up a line, we print it tagged by the job's identifier,

1765

* as necessary.

1766

* If output has been collected in a temporary file, we open the

1767

* file and read it line by line, transfering it to our own

1768

* output channel until the file is empty. At which point we

1769

* remove the temporary file.

1770

* In both cases, however, we keep our figurative eye out for the

1771

* 'noPrint' line for the shell from which the output came. If

1772

* we recognize a line, we don't print it. If the command is not

1773

* alone on the line (the character after it is not \0 or \n), we

1774

* do print whatever follows it.

1775

*

1776

* Input:

1777

* job the job whose output needs printing

1778

* finish TRUE if this is the last time we'll be called

1779

* for this job

1780

*

1781

* Results:

1782

* None

1783

*

1784

* Side Effects:

1785

* curPos may be shifted as may the contents of outBuf.

1786

*-----------------------------------------------------------------------

1787

*/

1788

STATIC void

1789

JobDoOutput(Job *job, Boolean finish)

1790

{

1791

Boolean gotNL = FALSE; /* true if got a newline */

1792

Boolean fbuf; /* true if our buffer filled up */

1793

int nr; /* number of bytes read */

1794

int i; /* auxiliary index into outBuf */

1795

int max; /* limit for i (end of current data) */

1796

int nRead; /* (Temporary) number of bytes read */

1797

1798

/*

1799

* Read as many bytes as will fit in the buffer.

1800

*/

1801

end_loop:

1802

gotNL = FALSE;

1803

fbuf = FALSE;

1804

1805

nRead = read(job->inPipe, &job->outBuf[job->curPos],

1806

JOB_BUFSIZE - job->curPos);

1807

if (nRead < 0) {

1808

if (errno == EAGAIN)

1809

return;

1810

if (DEBUG(JOB)) {

1811

perror("JobDoOutput(piperead)");

1812

}

1813

nr = 0;

1814

} else {

1815

nr = nRead;

1816

}

1817

1818

/*

1819

* If we hit the end-of-file (the job is dead), we must flush its

1820

* remaining output, so pretend we read a newline if there's any

1821

* output remaining in the buffer.

1822

* Also clear the 'finish' flag so we stop looping.

1823

*/

1824

if ((nr == 0) && (job->curPos != 0)) {

1825

job->outBuf[job->curPos] = '\n';

1826

nr = 1;

1827

finish = FALSE;

1828

} else if (nr == 0) {

1829

finish = FALSE;

1830

}

1831

1832

/*

1833

* Look for the last newline in the bytes we just got. If there is

1834

* one, break out of the loop with 'i' as its index and gotNL set

1835

* TRUE.

1836

*/

1837

max = job->curPos + nr;

1838

for (i = job->curPos + nr - 1; i >= job->curPos; i--) {

1839

if (job->outBuf[i] == '\n') {

1840

gotNL = TRUE;

1841

break;

1842

} else if (job->outBuf[i] == '\0') {

1843

/*

1844

* Why?

1845

*/

1846

job->outBuf[i] = ' ';

1847

}

1848

}

1849

1850

if (!gotNL) {

1851

job->curPos += nr;

1852

if (job->curPos == JOB_BUFSIZE) {

1853

/*

1854

* If we've run out of buffer space, we have no choice

1855

* but to print the stuff. sigh.

1856

*/

1857

fbuf = TRUE;

1858

i = job->curPos;

1859

}

1860

}

1861

if (gotNL || fbuf) {

1862

/*

1863

* Need to send the output to the screen. Null terminate it

1864

* first, overwriting the newline character if there was one.

1865

* So long as the line isn't one we should filter (according

1866

* to the shell description), we print the line, preceded

1867

* by a target banner if this target isn't the same as the

1868

* one for which we last printed something.

1869

* The rest of the data in the buffer are then shifted down

1870

* to the start of the buffer and curPos is set accordingly.

1871

*/

1872

job->outBuf[i] = '\0';

1873

if (i >= job->curPos) {

1874

char *cp;

1875

1876

cp = JobOutput(job, job->outBuf, &job->outBuf[i], FALSE);

1877

1878

/*

1879

* There's still more in that thar buffer. This time, though,

1880

* we know there's no newline at the end, so we add one of

1881

* our own free will.

1882

*/

1883

if (*cp != '\0') {

1884

if (!beSilent && job->node != lastNode) {

1885

MESSAGE(stdout, job->node);

1886

lastNode = job->node;

1887

}

1888

#ifdef USE_META

1889

if (useMeta) {

1890

meta_job_output(job, cp, gotNL ? "\n" : "");

1891

}

1892

#endif

1893

(void)fprintf(stdout, "%s%s", cp, gotNL ? "\n" : "");

1894

(void)fflush(stdout);

1895

}

1896

}

1897

if (i < max - 1) {

1898

/* shift the remaining characters down */

1899

(void)memcpy(job->outBuf, &job->outBuf[i + 1], max - (i + 1));

1900

job->curPos = max - (i + 1);

1901

1902

} else {

1903

/*

1904

* We have written everything out, so we just start over

1905

* from the start of the buffer. No copying. No nothing.

1906

*/

1907

job->curPos = 0;

1908

}

1909

}

1910

if (finish) {

1911

/*

1912

* If the finish flag is true, we must loop until we hit

1913

* end-of-file on the pipe. This is guaranteed to happen

1914

* eventually since the other end of the pipe is now closed

1915

* (we closed it explicitly and the child has exited). When

1916

* we do get an EOF, finish will be set FALSE and we'll fall

1917

* through and out.

1918

*/

1919

goto end_loop;

1920

}

1921

}

1922

1923

static void

1924

JobRun(GNode *targ)

1925

{

1926

#ifdef notyet

1927

/*

1928

* Unfortunately it is too complicated to run .BEGIN, .END,

1929

* and .INTERRUPT job in the parallel job module. This has

1930

* the nice side effect that it avoids a lot of other problems.

1931

*/

1932

Lst lst = Lst_Init(FALSE);

1933

Lst_AtEnd(lst, targ);

1934

(void)Make_Run(lst);

1935

Lst_Destroy(lst, NULL);

1936

JobStart(targ, JOB_SPECIAL);

1937

while (jobTokensRunning) {

1938

Job_CatchOutput();

1939

}

1940

#else

1941

Compat_Make(targ, targ);

1942

if (targ->made == ERROR) {

1943

PrintOnError(targ, "\n\nStop.");

1944

exit(1);

1945

}

1946

#endif

1947

}

1948

1949

/*-

1950

*-----------------------------------------------------------------------

1951

* Job_CatchChildren --

1952

* Handle the exit of a child. Called from Make_Make.

1953

*

1954

* Input:

1955

* block TRUE if should block on the wait

1956

*

1957

* Results:

1958

* none.

1959

*

1960

* Side Effects:

1961

* The job descriptor is removed from the list of children.

1962

*

1963

* Notes:

1964

* We do waits, blocking or not, according to the wisdom of our

1965

* caller, until there are no more children to report. For each

1966

* job, call JobFinish to finish things off.

1967

*

1968

*-----------------------------------------------------------------------

1969

*/

1970

1971

void

1972

Job_CatchChildren(void)

1973

{

1974

int pid; /* pid of dead child */

1975

WAIT_T status; /* Exit/termination status */

1976

1977

/*

1978

* Don't even bother if we know there's no one around.

1979

*/

1980

if (jobTokensRunning == 0)

1981

return;

1982

1983

while ((pid = waitpid((pid_t) -1, &status, WNOHANG | WUNTRACED)) > 0) {

1984

if (DEBUG(JOB)) {

1985

(void)fprintf(debug_file, "Process %d exited/stopped status %x.\n", pid,

1986

WAIT_STATUS(status));

1987

}

1988

JobReapChild(pid, status, TRUE);

1989

}

1990

}

1991

1992

/*

1993

* It is possible that wait[pid]() was called from elsewhere,

1994

* this lets us reap jobs regardless.

1995

*/

1996

void

1997

JobReapChild(pid_t pid, WAIT_T status, Boolean isJobs)

1998

{

1999

Job *job; /* job descriptor for dead child */

2000

2001

/*

2002

* Don't even bother if we know there's no one around.

2003

*/

2004

if (jobTokensRunning == 0)

2005

return;

2006

2007

job = JobFindPid(pid, JOB_ST_RUNNING, isJobs);

2008

if (job == NULL) {

2009

if (isJobs) {

2010

if (!lurking_children)

2011

Error("Child (%d) status %x not in table?", pid, status);

2012

}

2013

return; /* not ours */

2014

}

2015

if (WIFSTOPPED(status)) {

2016

if (DEBUG(JOB)) {

2017

(void)fprintf(debug_file, "Process %d (%s) stopped.\n",

2018

job->pid, job->node->name);

2019

}

2020

if (!make_suspended) {

2021

switch (WSTOPSIG(status)) {

2022

case SIGTSTP:

2023

(void)printf("*** [%s] Suspended\n", job->node->name);

2024

break;

2025

case SIGSTOP:

2026

(void)printf("*** [%s] Stopped\n", job->node->name);

2027

break;

2028

default:

2029

(void)printf("*** [%s] Stopped -- signal %d\n",

2030

job->node->name, WSTOPSIG(status));

2031

}

2032

job->job_suspended = 1;

2033

}

2034

(void)fflush(stdout);

2035

return;

2036

}

2037

2038

job->job_state = JOB_ST_FINISHED;

2039

job->exit_status = WAIT_STATUS(status);

2040

2041

JobFinish(job, status);

2042

}

2043

2044

/*-

2045

*-----------------------------------------------------------------------

2046

* Job_CatchOutput --

2047

* Catch the output from our children, if we're using

2048

* pipes do so. Otherwise just block time until we get a

2049

* signal(most likely a SIGCHLD) since there's no point in

2050

* just spinning when there's nothing to do and the reaping

2051

* of a child can wait for a while.

2052

*

2053

* Results:

2054

* None

2055

*

2056

* Side Effects:

2057

* Output is read from pipes if we're piping.

2058

* -----------------------------------------------------------------------

2059

*/

2060

void

2061

Job_CatchOutput(void)

2062

{

2063

int nready;

2064

Job *job;

2065

int i;

2066

2067

(void)fflush(stdout);

2068

2069

/* The first fd in the list is the job token pipe */

2070

do {

2071

nready = poll(fds + 1 - wantToken, nfds - 1 + wantToken, POLL_MSEC);

2072

} while (nready < 0 && errno == EINTR);

2073

2074

if (nready < 0)

2075

Punt("poll: %s", strerror(errno));

2076

2077

if (nready > 0 && readyfd(&childExitJob)) {

2078

char token = 0;

2079

ssize_t count;

2080

count = read(childExitJob.inPipe, &token, 1);

2081

switch (count) {

2082

case 0:

2083

Punt("unexpected eof on token pipe");

2084

case -1:

2085

Punt("token pipe read: %s", strerror(errno));

2086

case 1:

2087

if (token == DO_JOB_RESUME[0])

2088

/* Complete relay requested from our SIGCONT handler */

2089

JobRestartJobs();

2090

break;

2091

default:

2092

abort();

2093

}

2094

--nready;

2095

}

2096

2097

Job_CatchChildren();

2098

if (nready == 0)

2099

return;

2100

2101

for (i = 2; i < nfds; i++) {

2102

if (!fds[i].revents)

2103

continue;

2104

job = jobfds[i];

2105

if (job->job_state == JOB_ST_RUNNING)

2106

JobDoOutput(job, FALSE);

2107

if (--nready == 0)

2108

return;

2109

}

2110

}

2111

2112

/*-

2113

*-----------------------------------------------------------------------

2114

* Job_Make --

2115

* Start the creation of a target. Basically a front-end for

2116

* JobStart used by the Make module.

2117

*

2118

* Results:

2119

* None.

2120

*

2121

* Side Effects:

2122

* Another job is started.

2123

*

2124

*-----------------------------------------------------------------------

2125

*/

2126

void

2127

Job_Make(GNode *gn)

2128

{

2129

(void)JobStart(gn, 0);

2130

}

2131

2132

void

2133

Shell_Init(void)

2134

{

2135

if (shellPath == NULL) {

2136

/*

2137

* We are using the default shell, which may be an absolute

2138

* path if DEFSHELL_CUSTOM is defined.

2139

*/

2140

shellName = commandShell->name;

2141

#ifdef DEFSHELL_CUSTOM

2142

if (*shellName == '/') {

2143

shellPath = shellName;

2144

shellName = strrchr(shellPath, '/');

2145

shellName++;

2146

} else

2147

#endif

2148

shellPath = str_concat(_PATH_DEFSHELLDIR, shellName, STR_ADDSLASH);

2149

}

2150

if (commandShell->exit == NULL) {

2151

commandShell->exit = "";

2152

}

2153

if (commandShell->echo == NULL) {

2154

commandShell->echo = "";

2155

}

2156

if (commandShell->hasErrCtl && *commandShell->exit) {

2157

if (shellErrFlag &&

2158

strcmp(commandShell->exit, &shellErrFlag[1]) != 0) {

2159

free(shellErrFlag);

2160

shellErrFlag = NULL;

2161

}

2162

if (!shellErrFlag) {

2163

int n = strlen(commandShell->exit) + 2;

2164

2165

shellErrFlag = bmake_malloc(n);

2166

if (shellErrFlag) {

2167

snprintf(shellErrFlag, n, "-%s", commandShell->exit);

2168

}

2169

}

2170

} else if (shellErrFlag) {

2171

free(shellErrFlag);

2172

shellErrFlag = NULL;

2173

}

2174

}

2175

2176

/*-

2177

* Returns the string literal that is used in the current command shell

2178

* to produce a newline character.

2179

*/

2180

const char *

2181

Shell_GetNewline(void)

2182

{

2183

2184

return commandShell->newline;

2185

}

2186

2187

void

2188

Job_SetPrefix(void)

2189

{

2190

2191

if (targPrefix) {

2192

free(targPrefix);

2193

} else if (!Var_Exists(MAKE_JOB_PREFIX, VAR_GLOBAL)) {

2194

Var_Set(MAKE_JOB_PREFIX, "---", VAR_GLOBAL, 0);

2195

}

2196

2197

targPrefix = Var_Subst(NULL, "${" MAKE_JOB_PREFIX "}", VAR_GLOBAL, 0);

2198

}

2199

2200

/*-

2201

*-----------------------------------------------------------------------

2202

* Job_Init --

2203

* Initialize the process module

2204

*

2205

* Input:

2206

*

2207

* Results:

2208

* none

2209

*

2210

* Side Effects:

2211

* lists and counters are initialized

2212

*-----------------------------------------------------------------------

2213

*/

2214

void

2215

Job_Init(void)

2216

{

2217

Job_SetPrefix();

2218

/* Allocate space for all the job info */

2219

job_table = bmake_malloc(maxJobs * sizeof *job_table);

2220

memset(job_table, 0, maxJobs * sizeof *job_table);

2221

job_table_end = job_table + maxJobs;

2222

wantToken = 0;

2223

2224

aborting = 0;

2225

errors = 0;

2226

2227

lastNode = NULL;

2228

2229

/*

2230

* There is a non-zero chance that we already have children.

2231

* eg after 'make -f- <<EOF'

2232

* Since their termination causes a 'Child (pid) not in table' message,

2233

* Collect the status of any that are already dead, and suppress the

2234

* error message if there are any undead ones.

2235

*/

2236

for (;;) {

2237

int rval, status;

2238

rval = waitpid((pid_t) -1, &status, WNOHANG);

2239

if (rval > 0)

2240

continue;

2241

if (rval == 0)

2242

lurking_children = 1;

2243

break;

2244

}

2245

2246

Shell_Init();

2247

2248

JobCreatePipe(&childExitJob, 3);

2249

2250

/* We can only need to wait for tokens, children and output from each job */

2251

fds = bmake_malloc(sizeof (*fds) * (2 + maxJobs));

2252

jobfds = bmake_malloc(sizeof (*jobfds) * (2 + maxJobs));

2253

2254

/* These are permanent entries and take slots 0 and 1 */

2255

watchfd(&tokenWaitJob);

2256

watchfd(&childExitJob);

2257

2258

sigemptyset(&caught_signals);

2259

/*

2260

* Install a SIGCHLD handler.

2261

*/

2262

(void)bmake_signal(SIGCHLD, JobChildSig);

2263

sigaddset(&caught_signals, SIGCHLD);

2264

2265

#define ADDSIG(s,h) \

2266

if (bmake_signal(s, SIG_IGN) != SIG_IGN) { \

2267

sigaddset(&caught_signals, s); \

2268

(void)bmake_signal(s, h); \

2269

}

2270

2271

/*

2272

* Catch the four signals that POSIX specifies if they aren't ignored.

2273

* JobPassSig will take care of calling JobInterrupt if appropriate.

2274

*/

2275

ADDSIG(SIGINT, JobPassSig_int)

2276

ADDSIG(SIGHUP, JobPassSig_term)

2277

ADDSIG(SIGTERM, JobPassSig_term)

2278

ADDSIG(SIGQUIT, JobPassSig_term)

2279

2280

/*

2281

* There are additional signals that need to be caught and passed if

2282

* either the export system wants to be told directly of signals or if

2283

* we're giving each job its own process group (since then it won't get

2284

* signals from the terminal driver as we own the terminal)

2285

*/

2286

ADDSIG(SIGTSTP, JobPassSig_suspend)

2287

ADDSIG(SIGTTOU, JobPassSig_suspend)

2288

ADDSIG(SIGTTIN, JobPassSig_suspend)

2289

ADDSIG(SIGWINCH, JobCondPassSig)

2290

ADDSIG(SIGCONT, JobContinueSig)

2291

#undef ADDSIG

2292

2293

(void)Job_RunTarget(".BEGIN", NULL);

2294

postCommands = Targ_FindNode(".END", TARG_CREATE);

2295

}

2296

2297

static void JobSigReset(void)

2298

{

2299

#define DELSIG(s) \

2300

if (sigismember(&caught_signals, s)) { \

2301

(void)bmake_signal(s, SIG_DFL); \

2302

}

2303

2304

DELSIG(SIGINT)

2305

DELSIG(SIGHUP)

2306

DELSIG(SIGQUIT)

2307

DELSIG(SIGTERM)

2308

DELSIG(SIGTSTP)

2309

DELSIG(SIGTTOU)

2310

DELSIG(SIGTTIN)

2311

DELSIG(SIGWINCH)

2312

DELSIG(SIGCONT)

2313

#undef DELSIG

2314

(void)bmake_signal(SIGCHLD, SIG_DFL);

2315

}

2316

2317

/*-

2318

*-----------------------------------------------------------------------

2319

* JobMatchShell --

2320

* Find a shell in 'shells' given its name.

2321

*

2322

* Results:

2323

* A pointer to the Shell structure.

2324

*

2325

* Side Effects:

2326

* None.

2327

*

2328

*-----------------------------------------------------------------------

2329

*/

2330

static Shell *

2331

JobMatchShell(const char *name)

2332

{

2333

Shell *sh;

2334

2335

for (sh = shells; sh->name != NULL; sh++) {

2336

if (strcmp(name, sh->name) == 0)

2337

return (sh);

2338

}

2339

return NULL;

2340

}

2341

2342

/*-

2343

*-----------------------------------------------------------------------

2344

* Job_ParseShell --

2345

* Parse a shell specification and set up commandShell, shellPath

2346

* and shellName appropriately.

2347

*

2348

* Input:

2349

* line The shell spec

2350

*

2351

* Results:

2352

* FAILURE if the specification was incorrect.

2353

*

2354

* Side Effects:

2355

* commandShell points to a Shell structure (either predefined or

2356

* created from the shell spec), shellPath is the full path of the

2357

* shell described by commandShell, while shellName is just the

2358

* final component of shellPath.

2359

*

2360

* Notes:

2361

* A shell specification consists of a .SHELL target, with dependency

2362

* operator, followed by a series of blank-separated words. Double

2363

* quotes can be used to use blanks in words. A backslash escapes

2364

* anything (most notably a double-quote and a space) and

2365

* provides the functionality it does in C. Each word consists of

2366

* keyword and value separated by an equal sign. There should be no

2367

* unnecessary spaces in the word. The keywords are as follows:

2368

* name Name of shell.

2369

* path Location of shell.

2370

* quiet Command to turn off echoing.

2371

* echo Command to turn echoing on

2372

* filter Result of turning off echoing that shouldn't be

2373

* printed.

2374

* echoFlag Flag to turn echoing on at the start

2375

* errFlag Flag to turn error checking on at the start

2376

* hasErrCtl True if shell has error checking control

2377

* newline String literal to represent a newline char

2378

* check Command to turn on error checking if hasErrCtl

2379

* is TRUE or template of command to echo a command

2380

* for which error checking is off if hasErrCtl is

2381

* FALSE.

2382

* ignore Command to turn off error checking if hasErrCtl

2383

* is TRUE or template of command to execute a

2384

* command so as to ignore any errors it returns if

2385

* hasErrCtl is FALSE.

2386

*

2387

*-----------------------------------------------------------------------

2388

*/

2389

ReturnStatus

2390

Job_ParseShell(char *line)

2391

{

2392

char **words;

2393

char **argv;

2394

int argc;

2395

char *path;

2396

Shell newShell;

2397

Boolean fullSpec = FALSE;

2398

Shell *sh;

2399

2400

while (isspace((unsigned char)*line)) {

2401

line++;

2402

}

2403

2404

if (shellArgv)

2405

free(UNCONST(shellArgv));

2406

2407

memset(&newShell, 0, sizeof(newShell));

2408

2409

/*

2410

* Parse the specification by keyword

2411

*/

2412

words = brk_string(line, &argc, TRUE, &path);

2413

if (words == NULL) {

2414

Error("Unterminated quoted string [%s]", line);

2415

return FAILURE;

2416

}

2417

shellArgv = path;

2418

2419

for (path = NULL, argv = words; argc != 0; argc--, argv++) {

2420

if (strncmp(*argv, "path=", 5) == 0) {

2421

path = &argv[0][5];

2422

} else if (strncmp(*argv, "name=", 5) == 0) {

2423

newShell.name = &argv[0][5];

2424

} else {

2425

if (strncmp(*argv, "quiet=", 6) == 0) {

2426

newShell.echoOff = &argv[0][6];

2427

} else if (strncmp(*argv, "echo=", 5) == 0) {

2428

newShell.echoOn = &argv[0][5];

2429

} else if (strncmp(*argv, "filter=", 7) == 0) {

2430

newShell.noPrint = &argv[0][7];

2431

newShell.noPLen = strlen(newShell.noPrint);

2432

} else if (strncmp(*argv, "echoFlag=", 9) == 0) {

2433

newShell.echo = &argv[0][9];

2434

} else if (strncmp(*argv, "errFlag=", 8) == 0) {

2435

newShell.exit = &argv[0][8];

2436

} else if (strncmp(*argv, "hasErrCtl=", 10) == 0) {

2437

char c = argv[0][10];

2438

newShell.hasErrCtl = !((c != 'Y') && (c != 'y') &&

2439

(c != 'T') && (c != 't'));

2440

} else if (strncmp(*argv, "newline=", 8) == 0) {

2441

newShell.newline = &argv[0][8];

2442

} else if (strncmp(*argv, "check=", 6) == 0) {

2443

newShell.errCheck = &argv[0][6];

2444

} else if (strncmp(*argv, "ignore=", 7) == 0) {

2445

newShell.ignErr = &argv[0][7];

2446

} else if (strncmp(*argv, "errout=", 7) == 0) {

2447

newShell.errOut = &argv[0][7];

2448

} else if (strncmp(*argv, "comment=", 8) == 0) {

2449

newShell.commentChar = argv[0][8];

2450

} else {

2451

Parse_Error(PARSE_FATAL, "Unknown keyword \"%s\"",

2452

*argv);

2453

free(words);

2454

return(FAILURE);

2455

}

2456

fullSpec = TRUE;

2457

}

2458

}

2459

2460

if (path == NULL) {

2461

/*

2462

* If no path was given, the user wants one of the pre-defined shells,

2463

* yes? So we find the one s/he wants with the help of JobMatchShell

2464

* and set things up the right way. shellPath will be set up by

2465

* Shell_Init.

2466

*/

2467

if (newShell.name == NULL) {

2468

Parse_Error(PARSE_FATAL, "Neither path nor name specified");

2469

free(words);

2470

return(FAILURE);

2471

} else {

2472

if ((sh = JobMatchShell(newShell.name)) == NULL) {

2473

Parse_Error(PARSE_WARNING, "%s: No matching shell",

2474

newShell.name);

2475

free(words);

2476

return(FAILURE);

2477

}

2478

commandShell = sh;

2479

shellName = newShell.name;

2480

if (shellPath) {

2481

/* Shell_Init has already been called! Do it again. */

2482

free(UNCONST(shellPath));

2483

shellPath = NULL;

2484

Shell_Init();

2485

}

2486

}

2487

} else {

2488

/*

2489

* The user provided a path. If s/he gave nothing else (fullSpec is

2490

* FALSE), try and find a matching shell in the ones we know of.

2491

* Else we just take the specification at its word and copy it

2492

* to a new location. In either case, we need to record the

2493

* path the user gave for the shell.

2494

*/

2495

shellPath = path;

2496

path = strrchr(path, '/');

2497

if (path == NULL) {

2498

path = UNCONST(shellPath);

2499

} else {

2500

path += 1;

2501

}

2502

if (newShell.name != NULL) {

2503

shellName = newShell.name;

2504

} else {

2505

shellName = path;

2506

}

2507

if (!fullSpec) {

2508

if ((sh = JobMatchShell(shellName)) == NULL) {

2509

Parse_Error(PARSE_WARNING, "%s: No matching shell",

2510

shellName);

2511

free(words);

2512

return(FAILURE);

2513

}

2514

commandShell = sh;

2515

} else {

2516

commandShell = bmake_malloc(sizeof(Shell));

2517

*commandShell = newShell;

2518

}

2519

/* this will take care of shellErrFlag */

2520

Shell_Init();

2521

}

2522

2523

if (commandShell->echoOn && commandShell->echoOff) {

2524

commandShell->hasEchoCtl = TRUE;

2525

}

2526

2527

if (!commandShell->hasErrCtl) {

2528

if (commandShell->errCheck == NULL) {

2529

commandShell->errCheck = "";

2530

}

2531

if (commandShell->ignErr == NULL) {

2532

commandShell->ignErr = "%s\n";

2533

}

2534

}

2535

2536

/*

2537

* Do not free up the words themselves, since they might be in use by the

2538

* shell specification.

2539

*/

2540

free(words);

2541

return SUCCESS;

2542

}

2543

2544

/*-

2545

*-----------------------------------------------------------------------

2546

* JobInterrupt --

2547

* Handle the receipt of an interrupt.

2548

*

2549

* Input:

2550

* runINTERRUPT Non-zero if commands for the .INTERRUPT target

2551

* should be executed

2552

* signo signal received

2553

*

2554

* Results:

2555

* None

2556

*

2557

* Side Effects:

2558

* All children are killed. Another job will be started if the

2559

* .INTERRUPT target was given.

2560

*-----------------------------------------------------------------------

2561

*/

2562

static void

2563

JobInterrupt(int runINTERRUPT, int signo)

2564

{

2565

Job *job; /* job descriptor in that element */

2566

GNode *interrupt; /* the node describing the .INTERRUPT target */

2567

sigset_t mask;

2568

GNode *gn;

2569

2570

aborting = ABORT_INTERRUPT;

2571

2572

JobSigLock(&mask);

2573

2574

for (job = job_table; job < job_table_end; job++) {

2575

if (job->job_state != JOB_ST_RUNNING)

2576

continue;

2577

2578

gn = job->node;

2579

2580

if ((gn->type & (OP_JOIN|OP_PHONY)) == 0 && !Targ_Precious(gn)) {

2581

char *file = (gn->path == NULL ? gn->name : gn->path);

2582

if (!noExecute && eunlink(file) != -1) {

2583

Error("*** %s removed", file);

2584

}

2585

}

2586

if (job->pid) {

2587

if (DEBUG(JOB)) {

2588

(void)fprintf(debug_file,

2589

"JobInterrupt passing signal %d to child %d.\n",

2590

signo, job->pid);

2591

}

2592

KILLPG(job->pid, signo);

2593

}

2594

}

2595

2596

JobSigUnlock(&mask);

2597

2598

if (runINTERRUPT && !touchFlag) {

2599

interrupt = Targ_FindNode(".INTERRUPT", TARG_NOCREATE);

2600

if (interrupt != NULL) {

2601

ignoreErrors = FALSE;

2602

JobRun(interrupt);

2603

}

2604

}

2605

Trace_Log(MAKEINTR, 0);

2606

exit(signo);

2607

}

2608

2609

/*

2610

*-----------------------------------------------------------------------

2611

* Job_Finish --

2612

* Do final processing such as the running of the commands

2613

* attached to the .END target.

2614

*

2615

* Results:

2616

* Number of errors reported.

2617

*

2618

* Side Effects:

2619

* None.

2620

*-----------------------------------------------------------------------

2621

*/

2622

int

2623

Job_Finish(void)

2624

{

2625

if (postCommands != NULL &&

2626

(!Lst_IsEmpty(postCommands->commands) ||

2627

!Lst_IsEmpty(postCommands->children))) {

2628

if (errors) {

2629

Error("Errors reported so .END ignored");

2630

} else {

2631

JobRun(postCommands);

2632

}

2633

}

2634

return(errors);

2635

}

2636

2637

/*-

2638

*-----------------------------------------------------------------------

2639

* Job_End --

2640

* Cleanup any memory used by the jobs module

2641

*

2642

* Results:

2643

* None.

2644

*

2645

* Side Effects:

2646

* Memory is freed

2647

*-----------------------------------------------------------------------

2648

*/

2649

void

2650

Job_End(void)

2651

{

2652

#ifdef CLEANUP

2653

if (shellArgv)

2654

free(shellArgv);

2655

#endif

2656

}

2657

2658

/*-

2659

*-----------------------------------------------------------------------

2660

* Job_Wait --

2661

* Waits for all running jobs to finish and returns. Sets 'aborting'

2662

* to ABORT_WAIT to prevent other jobs from starting.

2663

*

2664

* Results:

2665

* None.

2666

*

2667

* Side Effects:

2668

* Currently running jobs finish.

2669

*

2670

*-----------------------------------------------------------------------

2671

*/

2672

void

2673

Job_Wait(void)

2674

{

2675

aborting = ABORT_WAIT;

2676

while (jobTokensRunning != 0) {

2677

Job_CatchOutput();

2678

}

2679

aborting = 0;

2680

}

2681

2682

/*-

2683

*-----------------------------------------------------------------------

2684

* Job_AbortAll --

2685

* Abort all currently running jobs without handling output or anything.

2686

* This function is to be called only in the event of a major

2687

* error. Most definitely NOT to be called from JobInterrupt.

2688

*

2689

* Results:

2690

* None

2691

*

2692

* Side Effects:

2693

* All children are killed, not just the firstborn

2694

*-----------------------------------------------------------------------

2695

*/

2696

void

2697

Job_AbortAll(void)

2698

{

2699

Job *job; /* the job descriptor in that element */

2700

WAIT_T foo;

2701

2702

aborting = ABORT_ERROR;

2703

2704

if (jobTokensRunning) {

2705

for (job = job_table; job < job_table_end; job++) {

2706

if (job->job_state != JOB_ST_RUNNING)

2707

continue;

2708

/*

2709

* kill the child process with increasingly drastic signals to make

2710

* darn sure it's dead.

2711

*/

2712

KILLPG(job->pid, SIGINT);

2713

KILLPG(job->pid, SIGKILL);

2714

}

2715

}

2716

2717

/*

2718

* Catch as many children as want to report in at first, then give up

2719

*/

2720

while (waitpid((pid_t) -1, &foo, WNOHANG) > 0)

2721

continue;

2722

}

2723

2724

2725

/*-

2726

*-----------------------------------------------------------------------

2727

* JobRestartJobs --

2728

* Tries to restart stopped jobs if there are slots available.

2729

* Called in process context in response to a SIGCONT.

2730

*

2731

* Results:

2732

* None.

2733

*

2734

* Side Effects:

2735

* Resumes jobs.

2736

*

2737

*-----------------------------------------------------------------------

2738

*/

2739

static void

2740

JobRestartJobs(void)

2741

{

2742

Job *job;

2743

2744

for (job = job_table; job < job_table_end; job++) {

2745

if (job->job_state == JOB_ST_RUNNING &&

2746

(make_suspended || job->job_suspended)) {

2747

if (DEBUG(JOB)) {

2748

(void)fprintf(debug_file, "Restarting stopped job pid %d.\n",

2749

job->pid);

2750

}

2751

if (job->job_suspended) {

2752

(void)printf("*** [%s] Continued\n", job->node->name);

2753

(void)fflush(stdout);

2754

}

2755

job->job_suspended = 0;

2756

if (KILLPG(job->pid, SIGCONT) != 0 && DEBUG(JOB)) {

2757

fprintf(debug_file, "Failed to send SIGCONT to %d\n", job->pid);

2758

}

2759

}

2760

if (job->job_state == JOB_ST_FINISHED)

2761

/* Job exit deferred after calling waitpid() in a signal handler */

2762

JobFinish(job, job->exit_status);

2763

}

2764

make_suspended = 0;

2765

}

2766

2767

static void

2768

watchfd(Job *job)

2769

{

2770

if (job->inPollfd != NULL)

2771

Punt("Watching watched job");

2772

2773

fds[nfds].fd = job->inPipe;

2774

fds[nfds].events = POLLIN;

2775

jobfds[nfds] = job;

2776

job->inPollfd = &fds[nfds];

2777

nfds++;

2778

}

2779

2780

static void

2781

clearfd(Job *job)

2782

{

2783

int i;

2784

if (job->inPollfd == NULL)

2785

Punt("Unwatching unwatched job");

2786

i = job->inPollfd - fds;

2787

nfds--;

2788

/*

2789

* Move last job in table into hole made by dead job.

2790

*/

2791

if (nfds != i) {

2792

fds[i] = fds[nfds];

2793

jobfds[i] = jobfds[nfds];

2794

jobfds[i]->inPollfd = &fds[i];

2795

}

2796

job->inPollfd = NULL;

2797

}

2798

2799

static int

2800

readyfd(Job *job)

2801

{

2802

if (job->inPollfd == NULL)

2803

Punt("Polling unwatched job");

2804

return (job->inPollfd->revents & POLLIN) != 0;

2805

}

2806

2807

/*-

2808

*-----------------------------------------------------------------------

2809

* JobTokenAdd --

2810

* Put a token into the job pipe so that some make process can start

2811

* another job.

2812

*

2813

* Side Effects:

2814

* Allows more build jobs to be spawned somewhere.

2815

*

2816

*-----------------------------------------------------------------------

2817

*/

2818

2819

static void

2820

JobTokenAdd(void)

2821

{

2822

char tok = JOB_TOKENS[aborting], tok1;

2823

2824

/* If we are depositing an error token flush everything else */

2825

while (tok != '+' && read(tokenWaitJob.inPipe, &tok1, 1) == 1)

2826

continue;

2827

2828

if (DEBUG(JOB))

2829

fprintf(debug_file, "(%d) aborting %d, deposit token %c\n",

2830

getpid(), aborting, JOB_TOKENS[aborting]);

2831

while (write(tokenWaitJob.outPipe, &tok, 1) == -1 && errno == EAGAIN)

2832

continue;

2833

}

2834

2835

/*-

2836

*-----------------------------------------------------------------------

2837

* Job_ServerStartTokenAdd --

2838

* Prep the job token pipe in the root make process.

2839

*

2840

*-----------------------------------------------------------------------

2841

*/

2842

2843

void

2844

Job_ServerStart(int max_tokens, int jp_0, int jp_1)

2845

{

2846

int i;

2847

char jobarg[64];

2848

2849

if (jp_0 >= 0 && jp_1 >= 0) {

2850

/* Pipe passed in from parent */

2851

tokenWaitJob.inPipe = jp_0;

2852

tokenWaitJob.outPipe = jp_1;

2853

(void)fcntl(jp_0, F_SETFD, 1);

2854

(void)fcntl(jp_1, F_SETFD, 1);

2855

return;

2856

}

2857

2858

JobCreatePipe(&tokenWaitJob, 15);

2859

2860

snprintf(jobarg, sizeof(jobarg), "%d,%d",

2861

tokenWaitJob.inPipe, tokenWaitJob.outPipe);

2862

2863

Var_Append(MAKEFLAGS, "-J", VAR_GLOBAL);

2864

Var_Append(MAKEFLAGS, jobarg, VAR_GLOBAL);

2865

2866

/*

2867

* Preload the job pipe with one token per job, save the one

2868

* "extra" token for the primary job.

2869

*

2870

* XXX should clip maxJobs against PIPE_BUF -- if max_tokens is

2871

* larger than the write buffer size of the pipe, we will

2872

* deadlock here.

2873

*/

2874

for (i = 1; i < max_tokens; i++)

2875

JobTokenAdd();

2876

}

2877

2878

/*-

2879

*-----------------------------------------------------------------------

2880

* Job_TokenReturn --

2881

* Return a withdrawn token to the pool.

2882

*

2883

*-----------------------------------------------------------------------

2884

*/

2885

2886

void

2887

Job_TokenReturn(void)

2888

{

2889

jobTokensRunning--;

2890

if (jobTokensRunning < 0)

2891

Punt("token botch");

2892

if (jobTokensRunning || JOB_TOKENS[aborting] != '+')

2893

JobTokenAdd();

2894

}

2895

2896

/*-

2897

*-----------------------------------------------------------------------

2898

* Job_TokenWithdraw --

2899

* Attempt to withdraw a token from the pool.

2900

*

2901

* Results:

2902

* Returns TRUE if a token was withdrawn, and FALSE if the pool

2903

* is currently empty.

2904

*

2905

* Side Effects:

2906

* If pool is empty, set wantToken so that we wake up

2907

* when a token is released.

2908

*

2909

*-----------------------------------------------------------------------

2910

*/

2911

2912

2913

Boolean

2914

Job_TokenWithdraw(void)

2915

{

2916

char tok, tok1;

2917

int count;

2918

2919

wantToken = 0;

2920

if (DEBUG(JOB))

2921

fprintf(debug_file, "Job_TokenWithdraw(%d): aborting %d, running %d\n",

2922

getpid(), aborting, jobTokensRunning);

2923

2924

if (aborting || (jobTokensRunning >= maxJobs))

2925

return FALSE;

2926

2927

count = read(tokenWaitJob.inPipe, &tok, 1);

2928

if (count == 0)

2929

Fatal("eof on job pipe!");

2930

if (count < 0 && jobTokensRunning != 0) {

2931

if (errno != EAGAIN) {

2932

Fatal("job pipe read: %s", strerror(errno));

2933

}

2934

if (DEBUG(JOB))

2935

fprintf(debug_file, "(%d) blocked for token\n", getpid());

2936

wantToken = 1;

2937

return FALSE;

2938

}

2939

2940

if (count == 1 && tok != '+') {

2941

/* make being abvorted - remove any other job tokens */

2942

if (DEBUG(JOB))

2943

fprintf(debug_file, "(%d) aborted by token %c\n", getpid(), tok);

2944

while (read(tokenWaitJob.inPipe, &tok1, 1) == 1)

2945

continue;

2946

/* And put the stopper back */

2947

while (write(tokenWaitJob.outPipe, &tok, 1) == -1 && errno == EAGAIN)

2948

continue;

2949

Fatal("A failure has been detected in another branch of the parallel make");

2950

}

2951

2952

if (count == 1 && jobTokensRunning == 0)

2953

/* We didn't want the token really */

2954

while (write(tokenWaitJob.outPipe, &tok, 1) == -1 && errno == EAGAIN)

2955

continue;

2956

2957

jobTokensRunning++;

2958

if (DEBUG(JOB))

2959

fprintf(debug_file, "(%d) withdrew token\n", getpid());

2960

return TRUE;

2961

}

2962

2963

/*-

2964

*-----------------------------------------------------------------------

2965

* Job_RunTarget --

2966

* Run the named target if found. If a filename is specified, then

2967

* set that to the sources.

2968

*

2969

* Results:

2970

* None

2971

*

2972

* Side Effects:

2973

* exits if the target fails.

2974

*

2975

*-----------------------------------------------------------------------

2976

*/

2977

Boolean

2978

Job_RunTarget(const char *target, const char *fname) {

2979

GNode *gn = Targ_FindNode(target, TARG_NOCREATE);

2980

2981

if (gn == NULL)

2982

return FALSE;

2983

2984

if (fname)

2985

Var_Set(ALLSRC, fname, gn, 0);

2986

2987

JobRun(gn);

2988

if (gn->made == ERROR) {

2989

PrintOnError(gn, "\n\nStop.");

2990

exit(1);

2991

}

2992

return TRUE;

2993

}

2994

2995

#ifdef USE_SELECT

2996

int

2997

emul_poll(struct pollfd *fd, int nfd, int timeout)

2998

{

2999

fd_set rfds, wfds;

3000

int i, maxfd, nselect, npoll;

3001

struct timeval tv, *tvp;

3002

long usecs;

3003

3004

FD_ZERO(&rfds);

3005

FD_ZERO(&wfds);

3006

3007

maxfd = -1;

3008

for (i = 0; i < nfd; i++) {

3009

fd[i].revents = 0;

3010

3011

if (fd[i].events & POLLIN)

3012

FD_SET(fd[i].fd, &rfds);

3013

3014

if (fd[i].events & POLLOUT)

3015

FD_SET(fd[i].fd, &wfds);

3016

3017

if (fd[i].fd > maxfd)

3018

maxfd = fd[i].fd;

3019

}

3020

3021

if (maxfd >= FD_SETSIZE) {

3022

Punt("Ran out of fd_set slots; "

3023

"recompile with a larger FD_SETSIZE.");

3024

}

3025

3026

if (timeout < 0) {

3027

tvp = NULL;

3028

} else {

3029

usecs = timeout * 1000;

3030

tv.tv_sec = usecs / 1000000;

3031

tv.tv_usec = usecs % 1000000;

3032

tvp = &tv;

3033

}

3034

3035

nselect = select(maxfd + 1, &rfds, &wfds, 0, tvp);

3036

3037

if (nselect <= 0)

3038

return nselect;

3039

3040

npoll = 0;

3041

for (i = 0; i < nfd; i++) {

3042

if (FD_ISSET(fd[i].fd, &rfds))

3043

fd[i].revents |= POLLIN;

3044

3045

if (FD_ISSET(fd[i].fd, &wfds))

3046

fd[i].revents |= POLLOUT;

3047

3048

if (fd[i].revents)

3049

npoll++;

3050

}

3051

3052

return npoll;

3053

}

3054

#endif /* USE_SELECT */