检测服务启动事务中的顺序环

729        for (;;) {730                /* Fourth step: Let's remove unneeded jobs that might731                 * be lurking. */732                if (mode != JOB_ISOLATE)733                        transaction_collect_garbage(tr);734735                /* Fifth step: verify order makes sense and correct736                 * cycles if necessary and possible */737                r = transaction_verify_order(tr, &generation, e);738                if (r >= 0)739                        break;740                if (r != -EAGAIN)741                        return log_warning_errno(r, "Requested transaction contains an unfixable cyclic ordering dependency: %s", bus_error_message(e, r));742743                /* Let's see if the resulting transaction ordering744                 * graph is still cyclic... */745        }

368        if (j->generation == generation) {369                Job *k, *delete = NULL;370                _cleanup_free_ char **array = NULL, *unit_ids = NULL;371372                /* If the marker is NULL we have been here already and decided the job was loop-free from373                 * here. Hence shortcut things and return right-away. */374                if (!j->marker)375                        return 0;376377                /* So, the marker is not NULL and we already have been here. We have a cycle. Let's try to378                 * break it. We go backwards in our path and try to find a suitable job to remove. We use the379                 * marker to find our way back, since smart how we are we stored our way back in there. */380                for (k = from; k; k = ((k->generation == generation && k->marker != k) ? k->marker : NULL)) {381382                        /* For logging below */383                        if (strv_push_pair(&array, k->unit->id, (char*) job_type_to_string(k->type)) < 0)384                                log_oom();385386                        if (!delete && hashmap_contains(tr->jobs, k->unit) && !job_matters_to_anchor(k))387                                /* Ok, we can drop this one, so let's do so. */388                                delete = k;

443        j->marker = from ?: j;444        j->generation = generation;445446        /* Actual ordering of jobs depends on the unit ordering dependency and job types. We need to traverse447         * the graph over 'before' edges in the actual job execution order. We traverse over both unit448         * ordering dependencies and we test with job_compare() whether it is the 'before' edge in the job449         * execution ordering. */450        FOREACH_ELEMENT(d, directions) {451                Unit *u;452453                UNIT_FOREACH_DEPENDENCY(u, j->unit, *d) {454                        Job *o;455456                        /* Is there a job for this unit? */457                        o = hashmap_get(tr->jobs, u);458                        if (!o) {459                                /* Ok, there is no job for this in the transaction, but maybe there is460                                 * already one running? */461                                o = u->job;462                                if (!o)463                                        continue;464                        }

466                        /* Cut traversing if the job j is not really *before* o. */467                        if (job_compare(j, o, *d) >= 0)468                                continue;469470                        r = transaction_verify_order_one(tr, o, j, generation, e);471                        if (r < 0)472                                return r;473                }474        }475476        /* Ok, let's backtrack, and remember that this entry is not on477         * our path anymore. */478        j->marker = NULL;479480        return 0;

421                        unit_status_printf(delete->unit,422                                           STATUS_TYPE_NOTICE,423                                           status,424                                           "Ordering cycle found, skipping %s",425                                           unit_status_string(delete->unit, NULL));426                        transaction_delete_unit(tr, delete->unit);427                        return -EAGAIN;428                }429430                log_struct(LOG_ERR,431                           LOG_UNIT_MESSAGE(j->unit, "Unable to break cycle starting with %s/%s",432                                            j->unit->id, job_type_to_string(j->type)),433                           "%s", strna(unit_ids));434435                return sd_bus_error_setf(e, BUS_ERROR_TRANSACTION_ORDER_IS_CYCLIC,436                                         "Transaction order is cyclic. See system logs for details.");

550        UNIT_FOREACH_DEPENDENCY(other, j->unit, UNIT_ATOM_AFTER)551                if (other->job && job_compare(j, other->job, UNIT_ATOM_AFTER) > 0) {552                        log_unit_debug(j->unit,553                                       "starting held back, waiting for: %s",554                                       other->id);555                        return false;556                }557558        UNIT_FOREACH_DEPENDENCY(other, j->unit, UNIT_ATOM_BEFORE)559                if (other->job && job_compare(j, other->job, UNIT_ATOM_BEFORE) > 0) {560                        log_unit_debug(j->unit,561                                       "stopping held back, waiting for: %s",562                                       other->id);563                        return false;564                }565566        return true;