static bool check_idle(void *userdata) {
Manager *m = userdata;
manager_gc(m, true);
return hashmap_isempty(m->machines);
}
static void test_hashmap_isempty(void) {
Hashmap *m;
char *val1;
val1 = strdup("my val");
assert_se(val1);
m = hashmap_new(&string_hash_ops);
assert_se(hashmap_isempty(m));
hashmap_put(m, "Key 1", val1);
assert_se(!hashmap_isempty(m));
assert_se(m);
hashmap_free_free(m);
}
_public_ int sd_lldp_get_neighbors(sd_lldp *lldp, sd_lldp_neighbor ***ret) {
sd_lldp_neighbor **l = NULL, *n;
Iterator i;
int k = 0, r;
assert_return(lldp, -EINVAL);
assert_return(ret, -EINVAL);
if (hashmap_isempty(lldp->neighbor_by_id)) { /* Special shortcut */
*ret = NULL;
return 0;
}
l = new0(sd_lldp_neighbor*, hashmap_size(lldp->neighbor_by_id));
if (!l)
return -ENOMEM;
r = lldp_start_timer(lldp, NULL);
if (r < 0) {
free(l);
return r;
}
HASHMAP_FOREACH(n, lldp->neighbor_by_id, i)
l[k++] = sd_lldp_neighbor_ref(n);
assert((size_t) k == hashmap_size(lldp->neighbor_by_id));
/* Return things in a stable order */
qsort(l, k, sizeof(sd_lldp_neighbor*), neighbor_compare_func);
*ret = l;
return k;
}
static bool bus_match_node_maybe_free(struct bus_match_node *node) {
assert(node);
if (node->child)
return false;
if (BUS_MATCH_IS_COMPARE(node->type) && !hashmap_isempty(node->compare.children))
return true;
bus_match_node_free(node);
return true;
}
_public_ int sd_bus_track_remove_name(sd_bus_track *track, const char *name) {
_cleanup_bus_slot_unref_ sd_bus_slot *slot = NULL;
_cleanup_free_ char *n = NULL;
assert_return(name, -EINVAL);
if (!track)
return 0;
slot = hashmap_remove2(track->names, (char*) name, (void**) &n);
if (!slot)
return 0;
if (hashmap_isempty(track->names))
bus_track_add_to_queue(track);
track->modified = true;
return 1;
}
static void bus_match_node_free(struct bus_match_node *node) {
assert(node);
assert(node->parent);
assert(!node->child);
assert(node->type != BUS_MATCH_ROOT);
assert(node->type < _BUS_MATCH_NODE_TYPE_MAX);
if (node->parent->child) {
/* We are apparently linked into the parent's child
* list. Let's remove us from there. */
if (node->prev) {
assert(node->prev->next == node);
node->prev->next = node->next;
} else {
assert(node->parent->child == node);
node->parent->child = node->next;
}
if (node->next)
node->next->prev = node->prev;
}
if (node->type == BUS_MATCH_VALUE) {
/* We might be in the parent's hash table, so clean
* this up */
if (node->parent->type == BUS_MATCH_MESSAGE_TYPE)
hashmap_remove(node->parent->compare.children, UINT_TO_PTR(node->value.u8));
else if (BUS_MATCH_CAN_HASH(node->parent->type) && node->value.str)
hashmap_remove(node->parent->compare.children, node->value.str);
free(node->value.str);
}
if (BUS_MATCH_IS_COMPARE(node->type)) {
assert(hashmap_isempty(node->compare.children));
hashmap_free(node->compare.children);
}
free(node);
}
void bus_match_free(struct bus_match_node *node) {
struct bus_match_node *c;
if (!node)
return;
if (BUS_MATCH_CAN_HASH(node->type)) {
Iterator i;
HASHMAP_FOREACH(c, node->compare.children, i)
bus_match_free(c);
assert(hashmap_isempty(node->compare.children));
}
while ((c = node->child))
bus_match_free(c);
if (node->type != BUS_MATCH_ROOT)
bus_match_node_free(node);
}
static void test_catalog_importing(void) {
Hashmap *h;
struct strbuf *sb;
assert_se(h = hashmap_new(&catalog_hash_ops));
assert_se(sb = strbuf_new());
#define BUF "xxx"
test_import(h, sb, BUF, sizeof(BUF), -EINVAL);
#undef BUF
assert_se(hashmap_isempty(h));
log_debug("----------------------------------------");
#define BUF \
"-- 0027229ca0644181a76c4e92458afaff dededededededededededededededede\n" \
"Subject: message\n" \
"\n" \
"payload\n"
test_import(h, sb, BUF, sizeof(BUF), -EINVAL);
#undef BUF
log_debug("----------------------------------------");
#define BUF \
"-- 0027229ca0644181a76c4e92458afaff dededededededededededededededed\n" \
"Subject: message\n" \
"\n" \
"payload\n"
test_import(h, sb, BUF, sizeof(BUF), 0);
#undef BUF
assert_se(hashmap_size(h) == 1);
log_debug("----------------------------------------");
hashmap_free_free(h);
strbuf_cleanup(sb);
}
bool set_isempty(Set *s) {
return hashmap_isempty(MAKE_HASHMAP(s));
}
int main(int argc, char *argv[]) {
int ret = EXIT_FAILURE;
_cleanup_endmntent_ FILE *f = NULL;
struct mntent* me;
Hashmap *pids = NULL;
if (argc > 1) {
log_error("This program takes no argument.");
return EXIT_FAILURE;
}
log_set_target(LOG_TARGET_AUTO);
log_parse_environment();
log_open();
umask(0022);
f = setmntent("/etc/fstab", "r");
if (!f) {
if (errno == ENOENT)
return EXIT_SUCCESS;
log_error("Failed to open /etc/fstab: %m");
return EXIT_FAILURE;
}
pids = hashmap_new(trivial_hash_func, trivial_compare_func);
if (!pids) {
log_error("Failed to allocate set");
goto finish;
}
ret = EXIT_SUCCESS;
while ((me = getmntent(f))) {
pid_t pid;
int k;
char *s;
/* Remount the root fs, /usr and all API VFS */
if (!mount_point_is_api(me->mnt_dir) &&
!path_equal(me->mnt_dir, "/") &&
!path_equal(me->mnt_dir, "/usr"))
continue;
log_debug("Remounting %s", me->mnt_dir);
pid = fork();
if (pid < 0) {
log_error("Failed to fork: %m");
ret = EXIT_FAILURE;
continue;
}
if (pid == 0) {
const char *arguments[5];
/* Child */
arguments[0] = "/bin/mount";
arguments[1] = me->mnt_dir;
arguments[2] = "-o";
arguments[3] = "remount";
arguments[4] = NULL;
execv("/bin/mount", (char **) arguments);
log_error("Failed to execute /bin/mount: %m");
_exit(EXIT_FAILURE);
}
/* Parent */
s = strdup(me->mnt_dir);
if (!s) {
log_oom();
ret = EXIT_FAILURE;
continue;
}
k = hashmap_put(pids, UINT_TO_PTR(pid), s);
if (k < 0) {
log_error("Failed to add PID to set: %s", strerror(-k));
ret = EXIT_FAILURE;
continue;
}
}
while (!hashmap_isempty(pids)) {
siginfo_t si = {};
char *s;
if (waitid(P_ALL, 0, &si, WEXITED) < 0) {
if (errno == EINTR)
continue;
log_error("waitid() failed: %m");
ret = EXIT_FAILURE;
break;
}
s = hashmap_remove(pids, UINT_TO_PTR(si.si_pid));
if (s) {
if (!is_clean_exit(si.si_code, si.si_status, NULL)) {
if (si.si_code == CLD_EXITED)
log_error("/bin/mount for %s exited with exit status %i.", s, si.si_status);
else
log_error("/bin/mount for %s terminated by signal %s.", s, signal_to_string(si.si_status));
ret = EXIT_FAILURE;
}
free(s);
}
}
finish:
if (pids)
hashmap_free_free(pids);
return ret;
}
int main(int argc, char *argv[]) {
_cleanup_hashmap_free_free_ Hashmap *pids = NULL;
_cleanup_endmntent_ FILE *f = NULL;
struct mntent* me;
int r;
if (argc > 1) {
log_error("This program takes no argument.");
return EXIT_FAILURE;
}
log_set_target(LOG_TARGET_AUTO);
log_parse_environment();
log_open();
umask(0022);
f = setmntent("/etc/fstab", "r");
if (!f) {
if (errno == ENOENT) {
r = 0;
goto finish;
}
r = log_error_errno(errno, "Failed to open /etc/fstab: %m");
goto finish;
}
pids = hashmap_new(NULL);
if (!pids) {
r = log_oom();
goto finish;
}
while ((me = getmntent(f))) {
pid_t pid;
int k;
char *s;
/* Remount the root fs, /usr and all API VFS */
if (!mount_point_is_api(me->mnt_dir) &&
!path_equal(me->mnt_dir, "/") &&
!path_equal(me->mnt_dir, "/usr"))
continue;
log_debug("Remounting %s", me->mnt_dir);
pid = fork();
if (pid < 0) {
r = log_error_errno(errno, "Failed to fork: %m");
goto finish;
}
if (pid == 0) {
/* Child */
(void) reset_all_signal_handlers();
(void) reset_signal_mask();
(void) prctl(PR_SET_PDEATHSIG, SIGTERM);
execv(MOUNT_PATH, STRV_MAKE(MOUNT_PATH, me->mnt_dir, "-o", "remount"));
log_error_errno(errno, "Failed to execute " MOUNT_PATH ": %m");
_exit(EXIT_FAILURE);
}
/* Parent */
s = strdup(me->mnt_dir);
if (!s) {
r = log_oom();
goto finish;
}
k = hashmap_put(pids, PID_TO_PTR(pid), s);
if (k < 0) {
free(s);
r = log_oom();
goto finish;
}
}
r = 0;
while (!hashmap_isempty(pids)) {
siginfo_t si = {};
char *s;
if (waitid(P_ALL, 0, &si, WEXITED) < 0) {
if (errno == EINTR)
continue;
r = log_error_errno(errno, "waitid() failed: %m");
goto finish;
}
s = hashmap_remove(pids, PID_TO_PTR(si.si_pid));
if (s) {
if (!is_clean_exit(si.si_code, si.si_status, EXIT_CLEAN_COMMAND, NULL)) {
if (si.si_code == CLD_EXITED)
log_error(MOUNT_PATH " for %s exited with exit status %i.", s, si.si_status);
else
log_error(MOUNT_PATH " for %s terminated by signal %s.", s, signal_to_string(si.si_status));
r = -ENOEXEC;
}
free(s);
}
}
finish:
return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}
static void test_catalog_import_invalid(void) {
_cleanup_hashmap_free_free_free_ Hashmap *h = NULL;
h = test_import("xxx", -1, -EINVAL);
assert_se(hashmap_isempty(h));
}
