HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/home/homed-manager.c
Git blob: 6dc0d82d7dca55da6726e4e1cd82945faa02caf0
Lines 2001–2238 of 2,238
r = sd_bus_reply_method_return(msg, NULL);
if (r < 0)
log_debug_errno(r, "Failed to reply to rebalance method call, ignoring: %m");
}
}
static int manager_rebalance_now(Manager *m) {
RebalanceState busy_state; /* the state to revert to when operation fails if busy */
int r;
assert(m);
log_debug("Rebalancing now...");
/* We maintain a simple state engine here to keep track of what we are doing. We'll first shrink all
* homes that shall be shrunk and then grow all homes that shall be grown, so that they can take up
* the space now freed. */
for (;;) {
switch (m->rebalance_state) {
case REBALANCE_IDLE:
case REBALANCE_PENDING:
case REBALANCE_WAITING:
/* First shrink large home dirs */
m->rebalance_state = REBALANCE_SHRINKING;
busy_state = REBALANCE_PENDING;
/* We are initiating the next rebalancing cycle now, let's make the queued methods
* calls the pending ones, and flush out any pending ones (which shouldn't exist at
* this time anyway) */
set_clear(m->rebalance_pending_method_calls);
SWAP_TWO(m->rebalance_pending_method_calls, m->rebalance_queued_method_calls);
log_debug("Shrinking phase..");
break;
case REBALANCE_SHRINKING:
/* Then grow small home dirs */
m->rebalance_state = REBALANCE_GROWING;
busy_state = REBALANCE_SHRINKING;
log_debug("Growing phase..");
break;
case REBALANCE_GROWING:
/* Finally, we are done */
log_info("Rebalancing complete.");
m->rebalance_state = REBALANCE_IDLE;
r = 0;
goto finish;
case REBALANCE_OFF:
default:
assert_not_reached();
}
r = manager_rebalance_calculate(m);
if (r == -EBUSY) {
/* Calculations failed because one home directory is currently busy. Revert to a state that
* tells us what to do next. */
log_debug("Can't enter phase, busy.");
m->rebalance_state = busy_state;
return r;
}
if (r < 0)
goto finish;
if (r == 0)
continue; /* got to next step immediately, if there's nothing to do */
r = manager_rebalance_apply(m);
if (r < 0)
goto finish;
if (r > 0)
break; /* At least one resize operation is now pending, we are done for now */
/* If there was nothing to apply, go for next state right-away */
}
return 0;
finish:
/* Reset state and schedule next rebalance */
m->rebalance_state = REBALANCE_IDLE;
manager_rebalance_reply_messages(m);
(void) manager_schedule_rebalance(m, /* immediately= */ false);
return r;
}
static int on_rebalance_timer(sd_event_source *s, usec_t t, void *userdata) {
Manager *m = ASSERT_PTR(userdata);
assert(s);
assert(IN_SET(m->rebalance_state, REBALANCE_WAITING, REBALANCE_PENDING, REBALANCE_SHRINKING, REBALANCE_GROWING));
(void) manager_rebalance_now(m);
return 0;
}
int manager_schedule_rebalance(Manager *m, bool immediately) {
int r;
assert(m);
/* Check if there are any records where rebalancing is requested */
if (!manager_shall_rebalance(m)) {
log_debug("Not scheduling rebalancing, not needed.");
r = 0; /* report that we didn't schedule anything because nothing needed it */
goto turn_off;
}
if (immediately) {
/* If we are told to rebalance immediately, then mark a rebalance as pending (even if we area
* already running one) */
if (m->rebalance_event_source) {
r = sd_event_source_set_time(m->rebalance_event_source, 0);
if (r < 0) {
log_error_errno(r, "Failed to schedule immediate rebalancing: %m");
goto turn_off;
}
r = sd_event_source_set_enabled(m->rebalance_event_source, SD_EVENT_ONESHOT);
if (r < 0) {
log_error_errno(r, "Failed to enable rebalancing event source: %m");
goto turn_off;
}
} else {
r = sd_event_add_time(m->event, &m->rebalance_event_source, CLOCK_MONOTONIC, 0, USEC_PER_SEC, on_rebalance_timer, m);
if (r < 0) {
log_error_errno(r, "Failed to allocate rebalance event source: %m");
goto turn_off;
}
r = sd_event_source_set_priority(m->rebalance_event_source, SD_EVENT_PRIORITY_IDLE + 10);
if (r < 0) {
log_error_errno(r, "Failed to set rebalance event source priority: %m");
goto turn_off;
}
(void) sd_event_source_set_description(m->rebalance_event_source, "rebalance");
}
if (!IN_SET(m->rebalance_state, REBALANCE_PENDING, REBALANCE_SHRINKING, REBALANCE_GROWING))
m->rebalance_state = REBALANCE_PENDING;
log_debug("Scheduled immediate rebalancing...");
return 1; /* report that we scheduled something */
}
/* If we are told to schedule a rebalancing eventually, then do so only if we are not executing
* anything yet. Also if we have something scheduled already, leave it in place */
if (!IN_SET(m->rebalance_state, REBALANCE_OFF, REBALANCE_IDLE))
return 1; /* report that there's already something scheduled */
if (m->rebalance_event_source) {
r = sd_event_source_set_time_relative(m->rebalance_event_source, m->rebalance_interval_usec);
if (r < 0) {
log_error_errno(r, "Failed to schedule immediate rebalancing: %m");
goto turn_off;
}
r = sd_event_source_set_enabled(m->rebalance_event_source, SD_EVENT_ONESHOT);
if (r < 0) {
log_error_errno(r, "Failed to enable rebalancing event source: %m");
goto turn_off;
}
} else {
r = sd_event_add_time_relative(m->event, &m->rebalance_event_source, CLOCK_MONOTONIC, m->rebalance_interval_usec, USEC_PER_SEC, on_rebalance_timer, m);
if (r < 0) {
log_error_errno(r, "Failed to allocate rebalance event source: %m");
goto turn_off;
}
r = sd_event_source_set_priority(m->rebalance_event_source, SD_EVENT_PRIORITY_IDLE + 10);
if (r < 0) {
log_error_errno(r, "Failed to set rebalance event source priority: %m");
goto turn_off;
}
(void) sd_event_source_set_description(m->rebalance_event_source, "rebalance");
}
m->rebalance_state = REBALANCE_WAITING; /* We managed to enqueue a timer event, we now wait until it fires */
log_debug("Scheduled rebalancing in %s...", FORMAT_TIMESPAN(m->rebalance_interval_usec, 0));
return 1; /* report that we scheduled something */
turn_off:
m->rebalance_event_source = sd_event_source_disable_unref(m->rebalance_event_source);
m->rebalance_state = REBALANCE_OFF;
manager_rebalance_reply_messages(m);
return r;
}
int manager_reschedule_rebalance(Manager *m) {
int r;
assert(m);
/* If a rebalance is pending reschedules it so it gets executed immediately */
if (!IN_SET(m->rebalance_state, REBALANCE_PENDING, REBALANCE_SHRINKING, REBALANCE_GROWING))
return 0;
r = manager_schedule_rebalance(m, /* immediately= */ true);
if (r < 0)
return r;
return 1;
}
int manager_get_home_by_name(Manager *m, const char *user_name, Home **ret) {
assert(m);
assert(user_name);
Home *h = hashmap_get(m->homes_by_name, user_name);
if (!h) {
/* Also search by username and realm. For that simply chop off realm, then look for the home, and verify it afterwards. */
const char *realm = strrchr(user_name, '@');
if (realm) {
_cleanup_free_ char *prefix = strndup(user_name, realm - user_name);
if (!prefix)
return -ENOMEM;
Home *j;
j = hashmap_get(m->homes_by_name, prefix);
if (j && user_record_matches_user_name(j->record, user_name))
h = j;
}
}
if (ret)
*ret = h;
return !!h;
}