core/unit: rename freezer "target" to "objective"

diff --git a/src/core/cgroup.c b/src/core/cgroup.c
index 218f867f24739b8f3ae01e7503d1890d91e5df4e..e370a04b8f6186e4e4074a96a90353c8e9e557e6 100644 (file)
--- a/src/core/cgroup.c
+++ b/src/core/cgroup.c
@@ -5106,7 +5106,7 @@ static int unit_cgroup_freezer_kernel_state(Unit *u, FreezerState *ret) {
 
 int unit_cgroup_freezer_action(Unit *u, FreezerAction action) {
         _cleanup_free_ char *path = NULL;
-        FreezerState target, current, next;
+        FreezerState current, next, objective;
         int r;
 
         assert(u);
@@ -5116,7 +5116,7 @@ int unit_cgroup_freezer_action(Unit *u, FreezerAction action) {
         if (!cg_freezer_supported())
                 return 0;
 
-        unit_next_freezer_state(u, action, &next, &target);
+        unit_next_freezer_state(u, action, &next, &objective);
 
         CGroupRuntime *crt = unit_get_cgroup_runtime(u);
         if (!crt || !crt->cgroup_path) {
@@ -5129,11 +5129,11 @@ int unit_cgroup_freezer_action(Unit *u, FreezerAction action) {
         if (r < 0)
                 return r;
 
-        if (current == target)
+        if (current == objective)
                 next = freezer_state_finish(next);
         else if (IN_SET(next, FREEZER_FROZEN, FREEZER_FROZEN_BY_PARENT, FREEZER_RUNNING)) {
                 /* We're transitioning into a finished state, which implies that the cgroup's
-                 * current state already matches the target and thus we'd return 0. But, reality
+                 * current state already matches the objective and thus we'd return 0. But, reality
                  * shows otherwise. This indicates that our freezer_state tracking has diverged
                  * from the real state of the cgroup, which can happen if someone meddles with the
                  * cgroup from underneath us. This really shouldn't happen during normal operation,
@@ -5158,12 +5158,12 @@ int unit_cgroup_freezer_action(Unit *u, FreezerAction action) {
                        freezer_state_to_string(u->freezer_state),
                        freezer_state_to_string(next));
 
-        r = write_string_file(path, one_zero(target == FREEZER_FROZEN), WRITE_STRING_FILE_DISABLE_BUFFER);
+        r = write_string_file(path, one_zero(objective == FREEZER_FROZEN), WRITE_STRING_FILE_DISABLE_BUFFER);
         if (r < 0)
                 return r;
 
         u->freezer_state = next;
-        return target != current;
+        return current != objective;
 }
 
 int unit_get_cpuset(Unit *u, CPUSet *cpus, const char *name) {

diff --git a/src/core/unit.c b/src/core/unit.c
index 3a83ed087842f2d0b57e6b5460e019ed1505a887..ced23a83b2157aa2a63a92283c540952d163e2fa 100644 (file)
--- a/src/core/unit.c
+++ b/src/core/unit.c
@@ -6156,26 +6156,26 @@ bool unit_can_isolate_refuse_manual(Unit *u) {
         return unit_can_isolate(u) && !u->refuse_manual_start;
 }
 
-void unit_next_freezer_state(Unit *u, FreezerAction action, FreezerState *ret, FreezerState *ret_target) {
-        Unit *slice;
-        FreezerState curr, parent, next, tgt;
+void unit_next_freezer_state(Unit *u, FreezerAction action, FreezerState *ret, FreezerState *ret_objective) {
+        FreezerState curr, parent, next, objective;
 
         assert(u);
         assert(action >= 0);
         assert(action < _FREEZER_ACTION_MAX);
         assert(ret);
-        assert(ret_target);
+        assert(ret_objective);
 
         /* This function determines the correct freezer state transitions for a unit
-         * given the action being requested. It returns the next state, and also the "target",
+         * given the action being requested. It returns the next state, and also the "objective",
          * which is either FREEZER_FROZEN or FREEZER_RUNNING, depending on what actual state we
          * ultimately want to achieve. */
 
-         curr = u->freezer_state;
-         slice = UNIT_GET_SLICE(u);
-         if (slice)
+        curr = u->freezer_state;
+
+        Unit *slice = UNIT_GET_SLICE(u);
+        if (slice)
                 parent = slice->freezer_state;
-         else
+        else
                 parent = FREEZER_RUNNING;
 
         if (action == FREEZER_FREEZE) {
@@ -6219,13 +6219,13 @@ void unit_next_freezer_state(Unit *u, FreezerAction action, FreezerState *ret, F
                         next = FREEZER_THAWING;
         }
 
-        tgt = freezer_state_finish(next);
-        if (tgt == FREEZER_FROZEN_BY_PARENT)
-                tgt = FREEZER_FROZEN;
-        assert(IN_SET(tgt, FREEZER_RUNNING, FREEZER_FROZEN));
+        objective = freezer_state_finish(next);
+        if (objective == FREEZER_FROZEN_BY_PARENT)
+                objective = FREEZER_FROZEN;
+        assert(IN_SET(objective, FREEZER_RUNNING, FREEZER_FROZEN));
 
         *ret = next;
-        *ret_target = tgt;
+        *ret_objective = objective;
 }
 
 bool unit_can_freeze(const Unit *u) {

diff --git a/src/core/unit.h b/src/core/unit.h
index 81502265101017cc87d8841cb4302678e4ebab2f..a55754ad485271b9d9b42c7c34ea1632adb58079 100644 (file)
--- a/src/core/unit.h
+++ b/src/core/unit.h
@@ -1038,7 +1038,7 @@ bool unit_can_isolate_refuse_manual(Unit *u);
 
 bool unit_can_freeze(const Unit *u);
 int unit_freezer_action(Unit *u, FreezerAction action);
-void unit_next_freezer_state(Unit *u, FreezerAction a, FreezerState *ret, FreezerState *ret_tgt);
+void unit_next_freezer_state(Unit *u, FreezerAction a, FreezerState *ret, FreezerState *ret_objective);
 void unit_frozen(Unit *u);
 void unit_thawed(Unit *u);