← Back to branch summary

~jamesodhunt/upstart/async-spawn.20140310

« back to all changes in this revision

Viewing changes to init/job.c

  • Committer: Scott James Remnant
  • Date: 2007-11-15 05:48:07 UTC
  • Revision ID: scott@netsplit.com-20071115054807-u20wcoa4gyik7ghs
* init/job.c (job_child_reaper): Update argument names and types
to match new NihChildHandler pattern; switch on event instead,
which can now have three values not two (it always could, this was
a bug) to output warning and assume that status is always non-zero
if killed so no need to check that separately.
* init/job.h: Update prototype.
* init/tests/test_job.c (test_child_reaper): Update calls to
job_child_reaper to pass an NihChildEvents member instead of FALSE
or TRUE for killed.
* init/main.c: Adjust call to nih_child_add_watch to indicate which
events we want to pass to the reaper; we don't use NIH_CHILD_ALL
since we're going to add ptrace stuff to a different function.

Show diffs side-by-side

added added

removed removed

Lines of Context:
init/job.c
1293
1293
/**
1294
1294
 * job_child_reaper:
1295
1295
 * @data: unused,
1296
 
 * @pid: process that died,
1297
 
 * @killed: whether @pid was killed,
1298
 
 * @status: exit status of @pid or signal that killed it.
 
1296
 * @pid: process that changed,
 
1297
 * @event: event that occurred on the child,
 
1298
 * @status: exit status of process, signal that killed it or ptrace event.
1299
1299
 *
1300
1300
 * This callback should be registered with nih_child_add_watch() so that
1301
1301
 * when processes associated with jobs die, the structure is updated and
1305
1305
 * safe to do as it only acts if the process is linked to a job.
1306
1306
 **/
1307
1307
void
1308
 
job_child_reaper (void  *data,
1309
 
                  pid_t  pid,
1310
 
                  int    killed,
1311
 
                  int    status)
 
1308
job_child_reaper (void           *data,
 
1309
                  pid_t           pid,
 
1310
                  NihChildEvents  event,
 
1311
                  int             status)
1312
1312
{
1313
1313
        Job         *job;
 
1314
        const char  *sig;
1314
1315
        ProcessType  process;
1315
1316
        int          failed = FALSE, stop = FALSE, state = TRUE;
1316
1317
 
1324
1325
        if (! job)
1325
1326
                return;
1326
1327
 
1327
 
        /* Report the death */
1328
 
        if (killed) {
1329
 
                const char *sig;
1330
 
 
 
1328
        switch (event) {
 
1329
        case NIH_CHILD_EXITED:
 
1330
                /* Child exited; check status to see whether it exited
 
1331
                 * normally (zero) or with a non-zero status.
 
1332
                 */
 
1333
                if (status) {
 
1334
                        nih_warn (_("%s (#%u) %s process (%d) "
 
1335
                                    "terminated with status %d"),
 
1336
                                  job->config->name, job->id,
 
1337
                                  process_name (process), pid, status);
 
1338
                } else {
 
1339
                        nih_info (_("%s (#%u) %s process (%d) "
 
1340
                                    "exited normally"),
 
1341
                                  job->config->name, job->id,
 
1342
                                  process_name (process), pid);
 
1343
                }
 
1344
                break;
 
1345
        case NIH_CHILD_KILLED:
 
1346
        case NIH_CHILD_DUMPED:
 
1347
                /* Child was killed by a signal, and maybe dumped core.  We
 
1348
                 * store the signal value in the higher byte of status (it's
 
1349
                 * safe to do that) to distinguish it from a normal exit
 
1350
                 * status.
 
1351
                 */
1331
1352
                sig = nih_signal_to_name (status);
1332
1353
                if (sig) {
1333
 
                        nih_warn (_("%s (#%u) %s process (%d) killed by %s signal"),
 
1354
                        nih_warn (_("%s (#%u) %s process (%d) "
 
1355
                                    "killed by %s signal"),
1334
1356
                                  job->config->name, job->id,
1335
1357
                                  process_name (process), pid, sig);
1336
1358
                } else {
1337
 
                        nih_warn (_("%s (#%u) %s process (%d) killed by signal %d"),
 
1359
                        nih_warn (_("%s (#%u) %s process (%d) "
 
1360
                                    "killed by signal %d"),
1338
1361
                                  job->config->name, job->id,
1339
1362
                                  process_name (process), pid, status);
1340
1363
                }
1341
1364
 
1342
 
                /* Store the signal value in the higher byte so we can
1343
 
                 * distinguish it from a normal exit status.
1344
 
                 */
1345
1365
                status <<= 8;
1346
 
        } else if (status) {
1347
 
                nih_warn (_("%s (#%u) %s process (%d) terminated with status %d"),
1348
 
                          job->config->name, job->id,
1349
 
                          process_name (process), pid, status);
1350
 
        } else {
1351
 
                nih_info (_("%s (#%u) %s process (%d) exited normally"),
1352
 
                          job->config->name, job->id,
1353
 
                          process_name (process), pid);
 
1366
                break;
 
1367
        default:
 
1368
                nih_assert_not_reached ();
1354
1369
        }
1355
1370
 
1356
1371
        switch (process) {
1375
1390
                 * it to be failed since we probably caused the termination.
1376
1391
                 */
1377
1392
                if ((job->goal != JOB_STOP)
1378
 
                    && (killed || status || job->config->respawn))
 
1393
                    && (status || job->config->respawn))
1379
1394
                {
1380
1395
                        failed = TRUE;
1381
1396
                        for (size_t i = 0; i < job->config->normalexit_len; i++) {
1424
1439
                 * other than zero, it's always considered a failure since
1425
1440
                 * we don't know what state the job might be in.
1426
1441
                 */
1427
 
                if (killed || status) {
 
1442
                if (status) {
1428
1443
                        failed = TRUE;
1429
1444
                        stop = TRUE;
1430
1445
                }
1458
1473
                 * other than zero, it's always considered a failure since
1459
1474
                 * we don't know what state the job might be in.
1460
1475
                 */
1461
 
                if (killed || status) {
 
1476
                if (status) {
1462
1477
                        failed = TRUE;
1463
1478
                        stop = TRUE;
1464
1479
                }