Conservative SmartOS global-zone memory pressure guard with dry-run-first policy and SMF integration.
Du kan inte välja fler än 25 ämnen Ämnen måste starta med en bokstav eller siffra, kan innehålla bindestreck ('-') och vara max 35 tecken långa.
 
 
 
 

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