/* Actual illumos preparation code against API sketches and injected I/O. */ #include "guard.h" #include #include #include #include #include #include #include static int mock_open(const char *, int, ...); static int mock_openat(int, const char *, int, ...); static ssize_t mock_pread(int, void *, size_t, off_t); static int mock_close(int); #define open mock_open #define openat mock_openat #define pread mock_pread #define close mock_close #include "../src/illumos.c" #undef open #undef openat #undef pread #undef close static unsigned checks; #define CHECK(x) do { if (!(x)) { fprintf(stderr, "FAIL prepare %d: %s\n", __LINE__, #x); exit(1); } checks++; } while (0) static double now; static psinfo_t ps; static uint64_t generation = 20, available = 486; static int ctl_opens, closed, fail_open, fail_read, fail_generation; static kstat_ctl_t fake_kc; static kstat_t fake_kstat; static kstat_named_t fake_value; static const char *uuid = "11111111-1111-4111-8111-111111111111"; double monotime(void) { return now; } static int mock_open(const char *path, int flags, ...) { (void)path; (void)flags; now += .001; if (fail_open) { errno = ENOMEM; return -1; } return 10; } static int mock_openat(int dir, const char *path, int flags, ...) { (void)dir; (void)flags; now += .002; if (!strcmp(path, "ctl")) { ctl_opens++; return 12; } return 11; } static ssize_t mock_pread(int fd, void *out, size_t n, off_t offset) { (void)fd; (void)offset; now += .003; if (fail_read) { errno = EIO; return -1; } memcpy(out, &ps, n); return (ssize_t)n; } static int mock_close(int fd) { (void)fd; closed++; errno = EINVAL; return 0; } ssize_t getzonenamebyid(zoneid_t zid, char *out, size_t n) { (void)zid; now += .004; snprintf(out, n, "%s", uuid); return 37; } ssize_t zone_getattr(zoneid_t zid, int attr, void *out, size_t n) { (void)zid; now += .005; if (attr == ZONE_ATTR_UNIQID) { if (fail_generation) { errno = EAGAIN; return -1; } memcpy(out, &generation, n); } else { pid_t init = 99; memcpy(out, &init, n); } return (ssize_t)n; } kstat_ctl_t *kstat_open(void) { return &fake_kc; } int kstat_close(kstat_ctl_t *ctl) { (void)ctl; return 0; } int kstat_chain_update(kstat_ctl_t *ctl) { (void)ctl; return 0; } zoneid_t getzoneid(void) { return 0; } int swapctl(int command, void *arg) { (void)command; (void)arg; return -1; } kstat_t *kstat_lookup(kstat_ctl_t *ctl, char *module, int instance, char *name) { (void)ctl; (void)module; (void)instance; (void)name; return &fake_kstat; } int kstat_read(kstat_ctl_t *ctl, kstat_t *k, void *buf) { (void)ctl; (void)k; (void)buf; now += .006; return 0; } void *kstat_data_lookup(kstat_t *k, char *name) { (void)k; (void)name; fake_value.data_type = KSTAT_DATA_UINT64; fake_value.value.ui64 = available; return &fake_value; } int main(void) { config_t c; process_t p; validation_t t; int handle; defaults(&c); c.armed = 1; c.nzones = 1; strcpy(c.zones[0].uuid, uuid); c.zones[0].policy = ALLOW; memset(&ps, 0, sizeof (ps)); ps.pr_pid = 123; ps.pr_ppid = 100; ps.pr_zoneid = 9; ps.pr_nlwp = 1; ps.pr_start.tv_sec = 1000; ps.pr_rssize = 2000000; strcpy(ps.pr_fname, "clamd"); { zone_cache_t z; memset(&z, 0, sizeof (z)); z.initpid = 99; z.generation = 20; strcpy(z.uuid, uuid); convert(&ps, &z, &p); } CHECK(platform_validation_init(16) == 0); memset(&t, 0, sizeof (t)); errno = EAGAIN; CHECK(platform_prepare(0, &c, &p, 1, 24539, &handle, &t) == 0); CHECK(handle == 12 && errno == 0 && ctl_opens == 1 && closed == 2); CHECK(t.open_ms > 4.9 && t.read_ms > 2.9 && t.zone_ms > 3.9); CHECK(t.ctl_open_ms > 1.9 && t.ctl_open_ms < 2.1 && t.ctl_open_ms < t.open_ms); CHECK(t.generation_ms > 4.9 && t.memory_ms > 5.9); platform_dispose(handle); available = 214354; memset(&t, 0, sizeof (t)); CHECK(platform_prepare(0, &c, &p, 1, 24539, &handle, &t) == -1); CHECK(handle == -1 && errno == EAGAIN && !strcmp(t.stage, "memory_recovered")); available = 486; ps.pr_start.tv_sec++; CHECK(platform_prepare(0, &c, &p, 1, 24539, &handle, &t) == -1 && errno == ESTALE); ps.pr_start.tv_sec--; generation++; CHECK(platform_prepare(0, &c, &p, 1, 24539, &handle, &t) == -1 && errno == ESTALE); generation--; c.zones[0].policy = PROTECT; CHECK(platform_prepare(0, &c, &p, 1, 24539, &handle, &t) == -1 && errno == EPERM); c.zones[0].policy = ALLOW; fail_open = 1; CHECK(platform_prepare(0, &c, &p, 1, 24539, &handle, &t) == -1 && errno == ENOMEM); fail_open = 0; fail_read = 1; CHECK(platform_prepare(0, &c, &p, 1, 24539, &handle, &t) == -1 && errno == EIO); fail_read = 0; fail_generation = 1; CHECK(platform_prepare(0, &c, &p, 1, 24539, &handle, &t) == -1 && errno == EAGAIN); fail_generation = 0; ctl_opens = 0; CHECK(platform_prepare(0, &c, &p, 0, 24539, &handle, &t) == 0); CHECK(handle == -1 && ctl_opens == 0); printf("PASS %u native preparation source checks with mocked proc/kstat/zone I/O; no native ABI claim or signals\n", checks); return 0; }