1 /* SPDX-License-Identifier: LGPL-2.1+ */
8 #include "string-util.h"
9 #include "test-helper.h"
13 static int test_cgroup_mask(void) {
14 _cleanup_(rm_rf_physical_and_freep
) char *runtime_dir
= NULL
;
15 _cleanup_(manager_freep
) Manager
*m
= NULL
;
16 Unit
*son
, *daughter
, *parent
, *root
, *grandchild
, *parent_deep
;
19 r
= enter_cgroup_subroot();
21 return log_tests_skipped("cgroupfs not available");
23 /* Prepare the manager. */
24 assert_se(set_unit_path(get_testdata_dir()) >= 0);
25 assert_se(runtime_dir
= setup_fake_runtime_dir());
26 r
= manager_new(UNIT_FILE_USER
, MANAGER_TEST_RUN_BASIC
, &m
);
27 if (IN_SET(r
, -EPERM
, -EACCES
)) {
28 log_error_errno(r
, "manager_new: %m");
29 return log_tests_skipped("cannot create manager");
34 /* Turn off all kinds of default accouning, so that we can
35 * verify the masks resulting of our configuration and nothing
37 m
->default_cpu_accounting
=
38 m
->default_memory_accounting
=
39 m
->default_blockio_accounting
=
40 m
->default_io_accounting
=
41 m
->default_tasks_accounting
= false;
42 m
->default_tasks_max
= (uint64_t) -1;
45 assert_se(manager_startup(m
, NULL
, NULL
) >= 0);
47 /* Load units and verify hierarchy. */
48 assert_se(manager_load_startable_unit_or_warn(m
, "parent.slice", NULL
, &parent
) >= 0);
49 assert_se(manager_load_startable_unit_or_warn(m
, "son.service", NULL
, &son
) >= 0);
50 assert_se(manager_load_startable_unit_or_warn(m
, "daughter.service", NULL
, &daughter
) >= 0);
51 assert_se(manager_load_startable_unit_or_warn(m
, "grandchild.service", NULL
, &grandchild
) >= 0);
52 assert_se(manager_load_startable_unit_or_warn(m
, "parent-deep.slice", NULL
, &parent_deep
) >= 0);
53 assert_se(UNIT_DEREF(son
->slice
) == parent
);
54 assert_se(UNIT_DEREF(daughter
->slice
) == parent
);
55 assert_se(UNIT_DEREF(parent_deep
->slice
) == parent
);
56 assert_se(UNIT_DEREF(grandchild
->slice
) == parent_deep
);
57 root
= UNIT_DEREF(parent
->slice
);
59 /* Verify per-unit cgroups settings. */
60 assert_se(unit_get_own_mask(son
) == (CGROUP_MASK_CPU
| CGROUP_MASK_CPUACCT
));
61 assert_se(unit_get_own_mask(daughter
) == 0);
62 assert_se(unit_get_own_mask(grandchild
) == 0);
63 assert_se(unit_get_own_mask(parent_deep
) == CGROUP_MASK_MEMORY
);
64 assert_se(unit_get_own_mask(parent
) == (CGROUP_MASK_IO
| CGROUP_MASK_BLKIO
));
65 assert_se(unit_get_own_mask(root
) == 0);
67 /* Verify aggregation of member masks */
68 assert_se(unit_get_members_mask(son
) == 0);
69 assert_se(unit_get_members_mask(daughter
) == 0);
70 assert_se(unit_get_members_mask(grandchild
) == 0);
71 assert_se(unit_get_members_mask(parent_deep
) == 0);
72 assert_se(unit_get_members_mask(parent
) == (CGROUP_MASK_CPU
| CGROUP_MASK_CPUACCT
| CGROUP_MASK_MEMORY
));
73 assert_se(unit_get_members_mask(root
) == (CGROUP_MASK_CPU
| CGROUP_MASK_CPUACCT
| CGROUP_MASK_IO
| CGROUP_MASK_BLKIO
| CGROUP_MASK_MEMORY
));
75 /* Verify aggregation of sibling masks. */
76 assert_se(unit_get_siblings_mask(son
) == (CGROUP_MASK_CPU
| CGROUP_MASK_CPUACCT
| CGROUP_MASK_MEMORY
));
77 assert_se(unit_get_siblings_mask(daughter
) == (CGROUP_MASK_CPU
| CGROUP_MASK_CPUACCT
| CGROUP_MASK_MEMORY
));
78 assert_se(unit_get_siblings_mask(grandchild
) == 0);
79 assert_se(unit_get_siblings_mask(parent_deep
) == (CGROUP_MASK_CPU
| CGROUP_MASK_CPUACCT
| CGROUP_MASK_MEMORY
));
80 assert_se(unit_get_siblings_mask(parent
) == (CGROUP_MASK_CPU
| CGROUP_MASK_CPUACCT
| CGROUP_MASK_IO
| CGROUP_MASK_BLKIO
| CGROUP_MASK_MEMORY
));
81 assert_se(unit_get_siblings_mask(root
) == (CGROUP_MASK_CPU
| CGROUP_MASK_CPUACCT
| CGROUP_MASK_IO
| CGROUP_MASK_BLKIO
| CGROUP_MASK_MEMORY
));
83 /* Verify aggregation of target masks. */
84 assert_se(unit_get_target_mask(son
) == ((CGROUP_MASK_CPU
| CGROUP_MASK_CPUACCT
| CGROUP_MASK_MEMORY
) & m
->cgroup_supported
));
85 assert_se(unit_get_target_mask(daughter
) == ((CGROUP_MASK_CPU
| CGROUP_MASK_CPUACCT
| CGROUP_MASK_MEMORY
) & m
->cgroup_supported
));
86 assert_se(unit_get_target_mask(grandchild
) == 0);
87 assert_se(unit_get_target_mask(parent_deep
) == ((CGROUP_MASK_CPU
| CGROUP_MASK_CPUACCT
| CGROUP_MASK_MEMORY
) & m
->cgroup_supported
));
88 assert_se(unit_get_target_mask(parent
) == ((CGROUP_MASK_CPU
| CGROUP_MASK_CPUACCT
| CGROUP_MASK_IO
| CGROUP_MASK_BLKIO
| CGROUP_MASK_MEMORY
) & m
->cgroup_supported
));
89 assert_se(unit_get_target_mask(root
) == ((CGROUP_MASK_CPU
| CGROUP_MASK_CPUACCT
| CGROUP_MASK_IO
| CGROUP_MASK_BLKIO
| CGROUP_MASK_MEMORY
) & m
->cgroup_supported
));
94 static void test_cg_mask_to_string_one(CGroupMask mask
, const char *t
) {
95 _cleanup_free_
char *b
= NULL
;
97 assert_se(cg_mask_to_string(mask
, &b
) >= 0);
98 assert_se(streq_ptr(b
, t
));
101 static void test_cg_mask_to_string(void) {
102 test_cg_mask_to_string_one(0, NULL
);
103 test_cg_mask_to_string_one(_CGROUP_MASK_ALL
, "cpu cpuacct io blkio memory devices pids bpf-firewall bpf-devices");
104 test_cg_mask_to_string_one(CGROUP_MASK_CPU
, "cpu");
105 test_cg_mask_to_string_one(CGROUP_MASK_CPUACCT
, "cpuacct");
106 test_cg_mask_to_string_one(CGROUP_MASK_IO
, "io");
107 test_cg_mask_to_string_one(CGROUP_MASK_BLKIO
, "blkio");
108 test_cg_mask_to_string_one(CGROUP_MASK_MEMORY
, "memory");
109 test_cg_mask_to_string_one(CGROUP_MASK_DEVICES
, "devices");
110 test_cg_mask_to_string_one(CGROUP_MASK_PIDS
, "pids");
111 test_cg_mask_to_string_one(CGROUP_MASK_CPU
|CGROUP_MASK_CPUACCT
, "cpu cpuacct");
112 test_cg_mask_to_string_one(CGROUP_MASK_CPU
|CGROUP_MASK_PIDS
, "cpu pids");
113 test_cg_mask_to_string_one(CGROUP_MASK_CPUACCT
|CGROUP_MASK_PIDS
, "cpuacct pids");
114 test_cg_mask_to_string_one(CGROUP_MASK_DEVICES
|CGROUP_MASK_PIDS
, "devices pids");
115 test_cg_mask_to_string_one(CGROUP_MASK_IO
|CGROUP_MASK_BLKIO
, "io blkio");
118 int main(int argc
, char* argv
[]) {
119 int rc
= EXIT_SUCCESS
;
121 test_setup_logging(LOG_DEBUG
);
123 test_cg_mask_to_string();
124 TEST_REQ_RUNNING_SYSTEMD(rc
= test_cgroup_mask());