Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 1 | /* Copyright 2016 The Chromium OS Authors. All rights reserved. |
| 2 | * Use of this source code is governed by a BSD-style license that can be |
| 3 | * found in the LICENSE file. |
| 4 | */ |
| 5 | |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 6 | #include <errno.h> |
| 7 | #include <signal.h> |
| 8 | #include <sys/mount.h> |
| 9 | #include <sys/stat.h> |
| 10 | #include <sys/types.h> |
| 11 | #include <unistd.h> |
| 12 | |
Luis Hector Chavez | 836d7b2 | 2017-09-14 15:11:15 -0700 | [diff] [blame] | 13 | #include "libcontainer/test_harness.h" |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 14 | |
Luis Hector Chavez | 836d7b2 | 2017-09-14 15:11:15 -0700 | [diff] [blame] | 15 | #include "libcontainer/container_cgroup.h" |
| 16 | #include "libcontainer/libcontainer.h" |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 17 | |
| 18 | static const pid_t INIT_TEST_PID = 5555; |
Chinyue Chen | 4f3fd68 | 2016-07-01 14:11:42 +0800 | [diff] [blame] | 19 | static const int TEST_CPU_SHARES = 200; |
| 20 | static const int TEST_CPU_QUOTA = 20000; |
| 21 | static const int TEST_CPU_PERIOD = 50000; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 22 | |
| 23 | struct mount_args { |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 24 | char* source; |
| 25 | char* target; |
| 26 | char* filesystemtype; |
| 27 | unsigned long mountflags; |
| 28 | const void* data; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 29 | }; |
| 30 | static struct mount_args mount_call_args[5]; |
| 31 | static int mount_called; |
| 32 | |
| 33 | struct mknod_args { |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 34 | char* pathname; |
| 35 | mode_t mode; |
| 36 | dev_t dev; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 37 | }; |
| 38 | static struct mknod_args mknod_call_args; |
Chinyue Chen | 03c54ae | 2016-06-29 12:29:10 +0800 | [diff] [blame] | 39 | static dev_t stat_rdev_ret; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 40 | |
| 41 | static int kill_called; |
| 42 | static int kill_sig; |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 43 | static const char* minijail_alt_syscall_table; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 44 | static int minijail_ipc_called; |
| 45 | static int minijail_vfs_called; |
| 46 | static int minijail_net_called; |
| 47 | static int minijail_pids_called; |
| 48 | static int minijail_run_as_init_called; |
| 49 | static int minijail_user_called; |
| 50 | static int minijail_wait_called; |
| 51 | static int minijail_reset_signal_mask_called; |
| 52 | static int mount_ret; |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 53 | static char* mkdtemp_root; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 54 | |
| 55 | /* global mock cgroup. */ |
Dylan Reid | 355d5e4 | 2016-04-29 16:53:31 -0700 | [diff] [blame] | 56 | #define MAX_ADD_DEVICE_CALLS 2 |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 57 | struct mock_cgroup { |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 58 | struct container_cgroup cg; |
| 59 | int freeze_ret; |
| 60 | int thaw_ret; |
| 61 | int deny_all_devs_ret; |
| 62 | int add_device_ret; |
| 63 | int set_cpu_ret; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 64 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 65 | int init_called_count; |
| 66 | int deny_all_devs_called_count; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 67 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 68 | int add_dev_allow[MAX_ADD_DEVICE_CALLS]; |
| 69 | int add_dev_major[MAX_ADD_DEVICE_CALLS]; |
| 70 | int add_dev_minor[MAX_ADD_DEVICE_CALLS]; |
| 71 | int add_dev_read[MAX_ADD_DEVICE_CALLS]; |
| 72 | int add_dev_write[MAX_ADD_DEVICE_CALLS]; |
| 73 | int add_dev_modify[MAX_ADD_DEVICE_CALLS]; |
| 74 | char add_dev_type[MAX_ADD_DEVICE_CALLS]; |
| 75 | int add_dev_called_count; |
Chinyue Chen | fac909e | 2016-06-24 14:17:42 +0800 | [diff] [blame] | 76 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 77 | int set_cpu_shares_count; |
| 78 | int set_cpu_quota_count; |
| 79 | int set_cpu_period_count; |
| 80 | int set_cpu_rt_runtime_count; |
| 81 | int set_cpu_rt_period_count; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 82 | }; |
| 83 | |
| 84 | static struct mock_cgroup gmcg; |
| 85 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 86 | static int mock_freeze(const struct container_cgroup* cg) { |
| 87 | struct mock_cgroup* mcg = (struct mock_cgroup*)cg; |
| 88 | return mcg->freeze_ret; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 89 | } |
| 90 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 91 | static int mock_thaw(const struct container_cgroup* cg) { |
| 92 | struct mock_cgroup* mcg = (struct mock_cgroup*)cg; |
| 93 | return mcg->thaw_ret; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 94 | } |
| 95 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 96 | static int mock_deny_all_devices(const struct container_cgroup* cg) { |
| 97 | struct mock_cgroup* mcg = (struct mock_cgroup*)cg; |
| 98 | ++mcg->deny_all_devs_called_count; |
| 99 | return mcg->deny_all_devs_ret; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 100 | } |
| 101 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 102 | static int mock_add_device(const struct container_cgroup* cg, |
| 103 | int allow, |
| 104 | int major, |
| 105 | int minor, |
| 106 | int read, |
| 107 | int write, |
| 108 | int modify, |
| 109 | char type) { |
| 110 | struct mock_cgroup* mcg = (struct mock_cgroup*)cg; |
Dylan Reid | 355d5e4 | 2016-04-29 16:53:31 -0700 | [diff] [blame] | 111 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 112 | if (mcg->add_dev_called_count >= MAX_ADD_DEVICE_CALLS) |
| 113 | return mcg->add_device_ret; |
| 114 | mcg->add_dev_allow[mcg->add_dev_called_count] = allow; |
| 115 | mcg->add_dev_major[mcg->add_dev_called_count] = major; |
| 116 | mcg->add_dev_minor[mcg->add_dev_called_count] = minor; |
| 117 | mcg->add_dev_read[mcg->add_dev_called_count] = read; |
| 118 | mcg->add_dev_write[mcg->add_dev_called_count] = write; |
| 119 | mcg->add_dev_modify[mcg->add_dev_called_count] = modify; |
| 120 | mcg->add_dev_type[mcg->add_dev_called_count] = type; |
| 121 | mcg->add_dev_called_count++; |
| 122 | return mcg->add_device_ret; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 123 | } |
| 124 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 125 | static int mock_set_cpu_shares(const struct container_cgroup* cg, int shares) { |
| 126 | struct mock_cgroup* mcg = (struct mock_cgroup*)cg; |
| 127 | mcg->set_cpu_shares_count++; |
| 128 | return mcg->set_cpu_ret; |
Chinyue Chen | fac909e | 2016-06-24 14:17:42 +0800 | [diff] [blame] | 129 | } |
| 130 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 131 | static int mock_set_cpu_quota(const struct container_cgroup* cg, int quota) { |
| 132 | struct mock_cgroup* mcg = (struct mock_cgroup*)cg; |
| 133 | mcg->set_cpu_quota_count++; |
| 134 | return mcg->set_cpu_ret; |
Chinyue Chen | fac909e | 2016-06-24 14:17:42 +0800 | [diff] [blame] | 135 | } |
| 136 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 137 | static int mock_set_cpu_period(const struct container_cgroup* cg, int period) { |
| 138 | struct mock_cgroup* mcg = (struct mock_cgroup*)cg; |
| 139 | mcg->set_cpu_period_count++; |
| 140 | return mcg->set_cpu_ret; |
Chinyue Chen | fac909e | 2016-06-24 14:17:42 +0800 | [diff] [blame] | 141 | } |
| 142 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 143 | static int mock_set_cpu_rt_runtime(const struct container_cgroup* cg, |
| 144 | int rt_runtime) { |
| 145 | struct mock_cgroup* mcg = (struct mock_cgroup*)cg; |
| 146 | mcg->set_cpu_rt_runtime_count++; |
| 147 | return mcg->set_cpu_ret; |
Chinyue Chen | fac909e | 2016-06-24 14:17:42 +0800 | [diff] [blame] | 148 | } |
| 149 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 150 | static int mock_set_cpu_rt_period(const struct container_cgroup* cg, |
| 151 | int rt_period) { |
| 152 | struct mock_cgroup* mcg = (struct mock_cgroup*)cg; |
| 153 | mcg->set_cpu_rt_period_count++; |
| 154 | return mcg->set_cpu_ret; |
Chinyue Chen | fac909e | 2016-06-24 14:17:42 +0800 | [diff] [blame] | 155 | } |
| 156 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 157 | struct container_cgroup* container_cgroup_new(const char* name, |
| 158 | const char* cgroup_root, |
| 159 | const char* cgroup_parent, |
| 160 | uid_t uid, |
| 161 | gid_t gid) { |
| 162 | gmcg.cg.name = strdup(name); |
| 163 | return &gmcg.cg; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 164 | } |
| 165 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 166 | void container_cgroup_destroy(struct container_cgroup* c) { |
| 167 | free(c->name); |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 168 | } |
| 169 | |
Luis Hector Chavez | 836d7b2 | 2017-09-14 15:11:15 -0700 | [diff] [blame] | 170 | TEST(premounted_runfs) { |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 171 | char premounted_runfs[] = "/tmp/cgtest_run/root"; |
| 172 | struct container_config* config = container_config_create(); |
| 173 | ASSERT_NE(nullptr, config); |
Keshav Santhanam | 0e4c328 | 2016-07-14 10:25:16 -0700 | [diff] [blame] | 174 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 175 | container_config_premounted_runfs(config, premounted_runfs); |
| 176 | const char* result = container_config_get_premounted_runfs(config); |
| 177 | ASSERT_EQ(0, strcmp(result, premounted_runfs)); |
Keshav Santhanam | 0e4c328 | 2016-07-14 10:25:16 -0700 | [diff] [blame] | 178 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 179 | container_config_destroy(config); |
Keshav Santhanam | 0e4c328 | 2016-07-14 10:25:16 -0700 | [diff] [blame] | 180 | } |
| 181 | |
Luis Hector Chavez | 836d7b2 | 2017-09-14 15:11:15 -0700 | [diff] [blame] | 182 | TEST(pid_file_path) { |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 183 | char pid_file_path[] = "/tmp/cgtest_run/root/container.pid"; |
| 184 | struct container_config* config = container_config_create(); |
| 185 | ASSERT_NE(nullptr, config); |
Keshav Santhanam | 0e4c328 | 2016-07-14 10:25:16 -0700 | [diff] [blame] | 186 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 187 | container_config_pid_file(config, pid_file_path); |
| 188 | const char* result = container_config_get_pid_file(config); |
| 189 | ASSERT_EQ(0, strcmp(result, pid_file_path)); |
Keshav Santhanam | 0e4c328 | 2016-07-14 10:25:16 -0700 | [diff] [blame] | 190 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 191 | container_config_destroy(config); |
Keshav Santhanam | 0e4c328 | 2016-07-14 10:25:16 -0700 | [diff] [blame] | 192 | } |
| 193 | |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 194 | /* Start of tests. */ |
| 195 | FIXTURE(container_test) { |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 196 | struct container_config* config; |
| 197 | struct container* container; |
| 198 | int mount_flags; |
| 199 | char* rootfs; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 200 | }; |
| 201 | |
Luis Hector Chavez | 836d7b2 | 2017-09-14 15:11:15 -0700 | [diff] [blame] | 202 | FIXTURE_SETUP(container_test) { |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 203 | char temp_template[] = "/tmp/cgtestXXXXXX"; |
| 204 | char rundir_template[] = "/tmp/cgtest_runXXXXXX"; |
| 205 | char* rundir; |
| 206 | char path[256]; |
| 207 | const char* pargs[] = { |
| 208 | "/sbin/init", |
| 209 | }; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 210 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 211 | memset(&mount_call_args, 0, sizeof(mount_call_args)); |
| 212 | mount_called = 0; |
| 213 | memset(&mknod_call_args, 0, sizeof(mknod_call_args)); |
| 214 | mkdtemp_root = nullptr; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 215 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 216 | memset(&gmcg, 0, sizeof(gmcg)); |
| 217 | static const struct cgroup_ops cgops = { |
| 218 | .freeze = mock_freeze, |
| 219 | .thaw = mock_thaw, |
| 220 | .deny_all_devices = mock_deny_all_devices, |
| 221 | .add_device = mock_add_device, |
| 222 | .set_cpu_shares = mock_set_cpu_shares, |
| 223 | .set_cpu_quota = mock_set_cpu_quota, |
| 224 | .set_cpu_period = mock_set_cpu_period, |
| 225 | .set_cpu_rt_runtime = mock_set_cpu_rt_runtime, |
| 226 | .set_cpu_rt_period = mock_set_cpu_rt_period, |
| 227 | }; |
| 228 | gmcg.cg.ops = &cgops; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 229 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 230 | self->rootfs = strdup(mkdtemp(temp_template)); |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 231 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 232 | kill_called = 0; |
| 233 | minijail_alt_syscall_table = nullptr; |
| 234 | minijail_ipc_called = 0; |
| 235 | minijail_vfs_called = 0; |
| 236 | minijail_net_called = 0; |
| 237 | minijail_pids_called = 0; |
| 238 | minijail_run_as_init_called = 0; |
| 239 | minijail_user_called = 0; |
| 240 | minijail_wait_called = 0; |
| 241 | minijail_reset_signal_mask_called = 0; |
| 242 | mount_ret = 0; |
| 243 | stat_rdev_ret = makedev(2, 3); |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 244 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 245 | snprintf(path, sizeof(path), "%s/dev", self->rootfs); |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 246 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 247 | self->mount_flags = MS_NOSUID | MS_NODEV | MS_NOEXEC; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 248 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 249 | self->config = container_config_create(); |
| 250 | container_config_rootfs(self->config, self->rootfs); |
| 251 | container_config_program_argv(self->config, pargs, 1); |
| 252 | container_config_alt_syscall_table(self->config, "testsyscalltable"); |
| 253 | container_config_add_mount(self->config, |
| 254 | "testtmpfs", |
| 255 | "tmpfs", |
| 256 | "/tmp", |
| 257 | "tmpfs", |
| 258 | nullptr, |
| 259 | nullptr, |
| 260 | self->mount_flags, |
| 261 | 0, |
| 262 | 1000, |
| 263 | 1000, |
| 264 | 0x666, |
| 265 | 0, |
| 266 | 1); |
| 267 | container_config_add_device(self->config, |
| 268 | 'c', |
| 269 | "/dev/foo", |
| 270 | S_IRWXU | S_IRWXG, |
| 271 | 245, |
| 272 | 2, |
| 273 | 0, |
| 274 | 1000, |
| 275 | 1001, |
| 276 | 1, |
| 277 | 1, |
| 278 | 0); |
| 279 | /* test dynamic minor on /dev/null */ |
| 280 | container_config_add_device(self->config, |
| 281 | 'c', |
| 282 | "/dev/null", |
| 283 | S_IRWXU | S_IRWXG, |
| 284 | 1, |
| 285 | -1, |
| 286 | 1, |
| 287 | 1000, |
| 288 | 1001, |
| 289 | 1, |
| 290 | 1, |
| 291 | 0); |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 292 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 293 | container_config_set_cpu_shares(self->config, TEST_CPU_SHARES); |
| 294 | container_config_set_cpu_cfs_params( |
| 295 | self->config, TEST_CPU_QUOTA, TEST_CPU_PERIOD); |
| 296 | /* Invalid params, so this won't be applied. */ |
| 297 | container_config_set_cpu_rt_params(self->config, 20000, 20000); |
Chinyue Chen | fac909e | 2016-06-24 14:17:42 +0800 | [diff] [blame] | 298 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 299 | rundir = mkdtemp(rundir_template); |
| 300 | self->container = container_new("containerUT", rundir); |
| 301 | ASSERT_NE(nullptr, self->container); |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 302 | } |
| 303 | |
Luis Hector Chavez | 836d7b2 | 2017-09-14 15:11:15 -0700 | [diff] [blame] | 304 | FIXTURE_TEARDOWN(container_test) { |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 305 | char path[256]; |
| 306 | int i; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 307 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 308 | container_destroy(self->container); |
| 309 | snprintf(path, sizeof(path), "rm -rf %s", self->rootfs); |
| 310 | EXPECT_EQ(0, system(path)); |
| 311 | free(self->rootfs); |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 312 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 313 | for (i = 0; i < mount_called; i++) { |
| 314 | free(mount_call_args[i].source); |
| 315 | free(mount_call_args[i].target); |
| 316 | free(mount_call_args[i].filesystemtype); |
| 317 | } |
| 318 | free(mknod_call_args.pathname); |
| 319 | free(mkdtemp_root); |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 320 | } |
| 321 | |
Luis Hector Chavez | 836d7b2 | 2017-09-14 15:11:15 -0700 | [diff] [blame] | 322 | TEST_F(container_test, test_mount_tmp_start) { |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 323 | char* path; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 324 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 325 | EXPECT_EQ(0, container_start(self->container, self->config)); |
| 326 | EXPECT_EQ(2, mount_called); |
| 327 | EXPECT_EQ(0, strcmp(mount_call_args[1].source, "tmpfs")); |
| 328 | EXPECT_LT(0, asprintf(&path, "%s/root/tmp", mkdtemp_root)); |
| 329 | EXPECT_EQ(0, strcmp(mount_call_args[1].target, path)); |
| 330 | free(path); |
| 331 | EXPECT_EQ(0, strcmp(mount_call_args[1].filesystemtype, "tmpfs")); |
| 332 | EXPECT_EQ(mount_call_args[1].mountflags, |
| 333 | static_cast<unsigned long>(self->mount_flags)); |
| 334 | EXPECT_EQ(mount_call_args[1].data, nullptr); |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 335 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 336 | EXPECT_EQ(1, minijail_ipc_called); |
| 337 | EXPECT_EQ(1, minijail_vfs_called); |
| 338 | EXPECT_EQ(1, minijail_net_called); |
| 339 | EXPECT_EQ(1, minijail_pids_called); |
| 340 | EXPECT_EQ(1, minijail_user_called); |
| 341 | EXPECT_EQ(1, minijail_run_as_init_called); |
| 342 | EXPECT_EQ(1, gmcg.deny_all_devs_called_count); |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 343 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 344 | EXPECT_EQ(1, gmcg.add_dev_allow[0]); |
| 345 | EXPECT_EQ(245, gmcg.add_dev_major[0]); |
| 346 | EXPECT_EQ(2, gmcg.add_dev_minor[0]); |
| 347 | EXPECT_EQ(1, gmcg.add_dev_read[0]); |
| 348 | EXPECT_EQ(1, gmcg.add_dev_write[0]); |
| 349 | EXPECT_EQ(0, gmcg.add_dev_modify[0]); |
| 350 | EXPECT_EQ('c', gmcg.add_dev_type[0]); |
Dylan Reid | 355d5e4 | 2016-04-29 16:53:31 -0700 | [diff] [blame] | 351 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 352 | EXPECT_EQ(1, gmcg.add_dev_allow[1]); |
| 353 | EXPECT_EQ(1, gmcg.add_dev_major[1]); |
| 354 | EXPECT_EQ(3, gmcg.add_dev_minor[1]); |
| 355 | EXPECT_EQ(1, gmcg.add_dev_read[1]); |
| 356 | EXPECT_EQ(1, gmcg.add_dev_write[1]); |
| 357 | EXPECT_EQ(0, gmcg.add_dev_modify[1]); |
| 358 | EXPECT_EQ('c', gmcg.add_dev_type[1]); |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 359 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 360 | EXPECT_LT(0, asprintf(&path, "%s/root/dev/null", mkdtemp_root)); |
| 361 | EXPECT_EQ(0, strcmp(mknod_call_args.pathname, path)); |
| 362 | free(path); |
| 363 | EXPECT_EQ(mknod_call_args.mode, |
| 364 | static_cast<mode_t>(S_IRWXU | S_IRWXG | S_IFCHR)); |
| 365 | EXPECT_EQ(mknod_call_args.dev, makedev(1, 3)); |
Chinyue Chen | 03c54ae | 2016-06-29 12:29:10 +0800 | [diff] [blame] | 366 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 367 | EXPECT_EQ(1, gmcg.set_cpu_shares_count); |
| 368 | EXPECT_EQ(TEST_CPU_SHARES, container_config_get_cpu_shares(self->config)); |
| 369 | EXPECT_EQ(1, gmcg.set_cpu_quota_count); |
| 370 | EXPECT_EQ(TEST_CPU_QUOTA, container_config_get_cpu_quota(self->config)); |
| 371 | EXPECT_EQ(1, gmcg.set_cpu_period_count); |
| 372 | EXPECT_EQ(TEST_CPU_PERIOD, container_config_get_cpu_period(self->config)); |
| 373 | EXPECT_EQ(0, gmcg.set_cpu_rt_runtime_count); |
| 374 | EXPECT_EQ(0, container_config_get_cpu_rt_runtime(self->config)); |
| 375 | EXPECT_EQ(0, gmcg.set_cpu_rt_period_count); |
| 376 | EXPECT_EQ(0, container_config_get_cpu_rt_period(self->config)); |
Chinyue Chen | fac909e | 2016-06-24 14:17:42 +0800 | [diff] [blame] | 377 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 378 | ASSERT_NE(nullptr, minijail_alt_syscall_table); |
| 379 | EXPECT_EQ(0, strcmp(minijail_alt_syscall_table, "testsyscalltable")); |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 380 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 381 | EXPECT_EQ(0, container_wait(self->container)); |
| 382 | EXPECT_EQ(1, minijail_wait_called); |
| 383 | EXPECT_EQ(1, minijail_reset_signal_mask_called); |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 384 | } |
| 385 | |
Luis Hector Chavez | 836d7b2 | 2017-09-14 15:11:15 -0700 | [diff] [blame] | 386 | TEST_F(container_test, test_kill_container) { |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 387 | EXPECT_EQ(0, container_start(self->container, self->config)); |
| 388 | EXPECT_EQ(0, container_kill(self->container)); |
| 389 | EXPECT_EQ(1, kill_called); |
| 390 | EXPECT_EQ(SIGKILL, kill_sig); |
| 391 | EXPECT_EQ(1, minijail_wait_called); |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 392 | } |
| 393 | |
| 394 | /* libc stubs so the UT doesn't need root to call mount, etc. */ |
Luis Hector Chavez | f9b1687 | 2017-09-14 14:22:15 -0700 | [diff] [blame] | 395 | extern "C" { |
| 396 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 397 | int mount(const char* source, |
| 398 | const char* target, |
| 399 | const char* filesystemtype, |
| 400 | unsigned long mountflags, |
| 401 | const void* data) { |
| 402 | if (mount_called >= 5) |
| 403 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 404 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 405 | mount_call_args[mount_called].source = strdup(source); |
| 406 | mount_call_args[mount_called].target = strdup(target); |
| 407 | mount_call_args[mount_called].filesystemtype = strdup(filesystemtype); |
| 408 | mount_call_args[mount_called].mountflags = mountflags; |
| 409 | mount_call_args[mount_called].data = data; |
| 410 | ++mount_called; |
| 411 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 412 | } |
| 413 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 414 | int umount(const char* target) { |
| 415 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 416 | } |
| 417 | |
Luis Hector Chavez | f9b1687 | 2017-09-14 14:22:15 -0700 | [diff] [blame] | 418 | #ifdef __USE_EXTERN_INLINES |
| 419 | /* Some environments use an inline version of mknod. */ |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 420 | int __xmknod(int ver, const char* pathname, __mode_t mode, __dev_t* dev) |
Luis Hector Chavez | f9b1687 | 2017-09-14 14:22:15 -0700 | [diff] [blame] | 421 | #else |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 422 | int mknod(const char* pathname, mode_t mode, dev_t dev) |
Luis Hector Chavez | f9b1687 | 2017-09-14 14:22:15 -0700 | [diff] [blame] | 423 | #endif |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 424 | { |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 425 | mknod_call_args.pathname = strdup(pathname); |
| 426 | mknod_call_args.mode = mode; |
Luis Hector Chavez | f9b1687 | 2017-09-14 14:22:15 -0700 | [diff] [blame] | 427 | #ifdef __USE_EXTERN_INLINES |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 428 | mknod_call_args.dev = *dev; |
Luis Hector Chavez | f9b1687 | 2017-09-14 14:22:15 -0700 | [diff] [blame] | 429 | #else |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 430 | mknod_call_args.dev = dev; |
Luis Hector Chavez | f9b1687 | 2017-09-14 14:22:15 -0700 | [diff] [blame] | 431 | #endif |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 432 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 433 | } |
| 434 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 435 | int chown(const char* path, uid_t owner, gid_t group) { |
| 436 | return 0; |
Luis Hector Chavez | 836d7b2 | 2017-09-14 15:11:15 -0700 | [diff] [blame] | 437 | } |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 438 | |
Luis Hector Chavez | 836d7b2 | 2017-09-14 15:11:15 -0700 | [diff] [blame] | 439 | int kill(pid_t pid, int sig) { |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 440 | ++kill_called; |
| 441 | kill_sig = sig; |
| 442 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 443 | } |
| 444 | |
Luis Hector Chavez | f9b1687 | 2017-09-14 14:22:15 -0700 | [diff] [blame] | 445 | #ifdef __USE_EXTERN_INLINES |
| 446 | /* Some environments use an inline version of stat. */ |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 447 | int __xstat(int ver, const char* path, struct stat* buf) |
Luis Hector Chavez | f9b1687 | 2017-09-14 14:22:15 -0700 | [diff] [blame] | 448 | #else |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 449 | int stat(const char* path, struct stat* buf) |
Luis Hector Chavez | f9b1687 | 2017-09-14 14:22:15 -0700 | [diff] [blame] | 450 | #endif |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 451 | { |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 452 | buf->st_rdev = stat_rdev_ret; |
| 453 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 454 | } |
| 455 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 456 | int chmod(const char* path, mode_t mode) { |
| 457 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 458 | } |
| 459 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 460 | char* mkdtemp(char* template_string) { |
| 461 | mkdtemp_root = strdup(template_string); |
| 462 | return template_string; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 463 | } |
| 464 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 465 | int mkdir(const char* pathname, mode_t mode) { |
| 466 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 467 | } |
| 468 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 469 | int rmdir(const char* pathname) { |
| 470 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 471 | } |
| 472 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 473 | int unlink(const char* pathname) { |
| 474 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 475 | } |
| 476 | |
| 477 | /* Minijail stubs */ |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 478 | struct minijail* minijail_new(void) { |
| 479 | return (struct minijail*)0x55; |
Chinyue Chen | 03c54ae | 2016-06-29 12:29:10 +0800 | [diff] [blame] | 480 | } |
| 481 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 482 | void minijail_destroy(struct minijail* j) {} |
| 483 | |
| 484 | int minijail_mount(struct minijail* j, |
| 485 | const char* src, |
| 486 | const char* dest, |
| 487 | const char* type, |
| 488 | unsigned long flags) { |
| 489 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 490 | } |
| 491 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 492 | void minijail_namespace_vfs(struct minijail* j) { |
| 493 | ++minijail_vfs_called; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 494 | } |
| 495 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 496 | void minijail_namespace_ipc(struct minijail* j) { |
| 497 | ++minijail_ipc_called; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 498 | } |
| 499 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 500 | void minijail_namespace_net(struct minijail* j) { |
| 501 | ++minijail_net_called; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 502 | } |
| 503 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 504 | void minijail_namespace_pids(struct minijail* j) { |
| 505 | ++minijail_pids_called; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 506 | } |
| 507 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 508 | void minijail_namespace_user(struct minijail* j) { |
| 509 | ++minijail_user_called; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 510 | } |
| 511 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 512 | int minijail_uidmap(struct minijail* j, const char* uidmap) { |
| 513 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 514 | } |
| 515 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 516 | int minijail_gidmap(struct minijail* j, const char* gidmap) { |
| 517 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 518 | } |
| 519 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 520 | int minijail_enter_pivot_root(struct minijail* j, const char* dir) { |
| 521 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 522 | } |
| 523 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 524 | void minijail_run_as_init(struct minijail* j) { |
| 525 | ++minijail_run_as_init_called; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 526 | } |
| 527 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 528 | int minijail_run_pid_pipes_no_preload(struct minijail* j, |
| 529 | const char* filename, |
| 530 | char* const argv[], |
| 531 | pid_t* pchild_pid, |
| 532 | int* pstdin_fd, |
| 533 | int* pstdout_fd, |
| 534 | int* pstderr_fd) { |
| 535 | *pchild_pid = INIT_TEST_PID; |
| 536 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 537 | } |
| 538 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 539 | int minijail_write_pid_file(struct minijail* j, const char* path) { |
| 540 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 541 | } |
| 542 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 543 | int minijail_wait(struct minijail* j) { |
| 544 | ++minijail_wait_called; |
| 545 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 546 | } |
| 547 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 548 | int minijail_use_alt_syscall(struct minijail* j, const char* table) { |
| 549 | minijail_alt_syscall_table = table; |
| 550 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 551 | } |
| 552 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 553 | int minijail_add_to_cgroup(struct minijail* j, const char* cg_path) { |
| 554 | return 0; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 555 | } |
| 556 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 557 | void minijail_reset_signal_mask(struct minijail* j) { |
| 558 | ++minijail_reset_signal_mask_called; |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 559 | } |
| 560 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 561 | void minijail_skip_remount_private(struct minijail* j) {} |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 562 | |
Luis Hector Chavez | 31735bc | 2017-09-15 08:17:10 -0700 | [diff] [blame^] | 563 | } // extern "C" |
Luis Hector Chavez | f9b1687 | 2017-09-14 14:22:15 -0700 | [diff] [blame] | 564 | |
Dylan Reid | 837c74a | 2016-01-22 17:25:21 -0800 | [diff] [blame] | 565 | TEST_HARNESS_MAIN |