Conservative SmartOS global-zone memory pressure guard with dry-run-first policy and SMF integration.
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
 
 
 
 

144 lignes
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. }