Conservative SmartOS global-zone memory pressure guard with dry-run-first policy and SMF integration.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 

116 line
5.0 KiB

  1. /* Actual illumos preparation code against API sketches and injected I/O. */
  2. #include "guard.h"
  3. #include <sys/types.h>
  4. #include <fcntl.h>
  5. #include <unistd.h>
  6. #include <string.h>
  7. #include <errno.h>
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. static int mock_open(const char *, int, ...);
  11. static int mock_openat(int, const char *, int, ...);
  12. static ssize_t mock_pread(int, void *, size_t, off_t);
  13. static int mock_close(int);
  14. #define open mock_open
  15. #define openat mock_openat
  16. #define pread mock_pread
  17. #define close mock_close
  18. #include "../src/illumos.c"
  19. #undef open
  20. #undef openat
  21. #undef pread
  22. #undef close
  23. static unsigned checks;
  24. #define CHECK(x) do { if (!(x)) { fprintf(stderr, "FAIL prepare %d: %s\n", __LINE__, #x); exit(1); } checks++; } while (0)
  25. static double now;
  26. static psinfo_t ps;
  27. static uint64_t generation = 20, available = 486;
  28. static int ctl_opens, closed, fail_open, fail_read, fail_generation;
  29. static kstat_ctl_t fake_kc;
  30. static kstat_t fake_kstat;
  31. static kstat_named_t fake_value;
  32. static const char *uuid = "11111111-1111-4111-8111-111111111111";
  33. double monotime(void) { return now; }
  34. static int mock_open(const char *path, int flags, ...)
  35. { (void)path; (void)flags; now += .001; if (fail_open) { errno = ENOMEM; return -1; } return 10; }
  36. static int mock_openat(int dir, const char *path, int flags, ...)
  37. {
  38. (void)dir; (void)flags; now += .002;
  39. if (!strcmp(path, "ctl")) { ctl_opens++; return 12; }
  40. return 11;
  41. }
  42. static ssize_t mock_pread(int fd, void *out, size_t n, off_t offset)
  43. {
  44. (void)fd; (void)offset; now += .003;
  45. if (fail_read) { errno = EIO; return -1; }
  46. memcpy(out, &ps, n); return (ssize_t)n;
  47. }
  48. static int mock_close(int fd)
  49. { (void)fd; closed++; errno = EINVAL; return 0; }
  50. ssize_t getzonenamebyid(zoneid_t zid, char *out, size_t n)
  51. { (void)zid; now += .004; snprintf(out, n, "%s", uuid); return 37; }
  52. ssize_t zone_getattr(zoneid_t zid, int attr, void *out, size_t n)
  53. {
  54. (void)zid; now += .005;
  55. if (attr == ZONE_ATTR_UNIQID) {
  56. if (fail_generation) { errno = EAGAIN; return -1; }
  57. memcpy(out, &generation, n);
  58. } else { pid_t init = 99; memcpy(out, &init, n); }
  59. return (ssize_t)n;
  60. }
  61. kstat_ctl_t *kstat_open(void) { return &fake_kc; }
  62. int kstat_close(kstat_ctl_t *ctl) { (void)ctl; return 0; }
  63. int kstat_chain_update(kstat_ctl_t *ctl) { (void)ctl; return 0; }
  64. zoneid_t getzoneid(void) { return 0; }
  65. int swapctl(int command, void *arg) { (void)command; (void)arg; return -1; }
  66. kstat_t *kstat_lookup(kstat_ctl_t *ctl, char *module, int instance, char *name)
  67. { (void)ctl; (void)module; (void)instance; (void)name; return &fake_kstat; }
  68. int kstat_read(kstat_ctl_t *ctl, kstat_t *k, void *buf)
  69. { (void)ctl; (void)k; (void)buf; now += .006; return 0; }
  70. void *kstat_data_lookup(kstat_t *k, char *name)
  71. {
  72. (void)k; (void)name;
  73. fake_value.data_type = KSTAT_DATA_UINT64; fake_value.value.ui64 = available;
  74. return &fake_value;
  75. }
  76. int main(void)
  77. {
  78. config_t c; process_t p; validation_t t; int handle;
  79. defaults(&c); c.armed = 1; c.nzones = 1;
  80. strcpy(c.zones[0].uuid, uuid); c.zones[0].policy = ALLOW;
  81. memset(&ps, 0, sizeof (ps)); ps.pr_pid = 123; ps.pr_ppid = 100;
  82. ps.pr_zoneid = 9; ps.pr_nlwp = 1; ps.pr_start.tv_sec = 1000;
  83. ps.pr_rssize = 2000000; strcpy(ps.pr_fname, "clamd");
  84. { zone_cache_t z; memset(&z, 0, sizeof (z));
  85. z.initpid = 99; z.generation = 20; strcpy(z.uuid, uuid); convert(&ps, &z, &p); }
  86. CHECK(platform_validation_init(16) == 0);
  87. memset(&t, 0, sizeof (t)); errno = EAGAIN;
  88. CHECK(platform_prepare(0, &c, &p, 1, 24539, &handle, &t) == 0);
  89. CHECK(handle == 12 && errno == 0 && ctl_opens == 1 && closed == 2);
  90. CHECK(t.open_ms > 4.9 && t.read_ms > 2.9 && t.zone_ms > 3.9);
  91. CHECK(t.generation_ms > 4.9 && t.memory_ms > 5.9);
  92. platform_dispose(handle);
  93. available = 214354; memset(&t, 0, sizeof (t));
  94. CHECK(platform_prepare(0, &c, &p, 1, 24539, &handle, &t) == -1);
  95. CHECK(handle == -1 && errno == EAGAIN && !strcmp(t.stage, "memory_recovered"));
  96. available = 486; ps.pr_start.tv_sec++;
  97. CHECK(platform_prepare(0, &c, &p, 1, 24539, &handle, &t) == -1 && errno == ESTALE);
  98. ps.pr_start.tv_sec--; generation++;
  99. CHECK(platform_prepare(0, &c, &p, 1, 24539, &handle, &t) == -1 && errno == ESTALE);
  100. generation--; c.zones[0].policy = PROTECT;
  101. CHECK(platform_prepare(0, &c, &p, 1, 24539, &handle, &t) == -1 && errno == EPERM);
  102. c.zones[0].policy = ALLOW; fail_open = 1;
  103. CHECK(platform_prepare(0, &c, &p, 1, 24539, &handle, &t) == -1 && errno == ENOMEM);
  104. fail_open = 0; fail_read = 1;
  105. CHECK(platform_prepare(0, &c, &p, 1, 24539, &handle, &t) == -1 && errno == EIO);
  106. fail_read = 0; fail_generation = 1;
  107. CHECK(platform_prepare(0, &c, &p, 1, 24539, &handle, &t) == -1 && errno == EAGAIN);
  108. fail_generation = 0; ctl_opens = 0;
  109. CHECK(platform_prepare(0, &c, &p, 0, 24539, &handle, &t) == 0);
  110. CHECK(handle == -1 && ctl_opens == 0);
  111. printf("PASS %u native preparation source checks with mocked proc/kstat/zone I/O; no native ABI claim or signals\n", checks);
  112. return 0;
  113. }