src/pcie_errors_test.c

   1 /**
   2  * collectd - src/pcie_errors.c
   3  *
   4  * Copyright(c) 2018 Intel Corporation. All rights reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  *
  24  * Authors:
  25  *   Kamil Wiatrowski <kamilx.wiatrowski@intel.com>
  26  **/
  27
  28 #include "pcie_errors.c" /* sic */
  29 #include "testing.h"
  30
  31 #define TEST_DOMAIN 1
  32 #define TEST_BUS 5
  33 #define TEST_DEVICE 0xc
  34 #define TEST_FUNCTION 2
  35 #define TEST_DEVICE_STR "0001:05:0c.2"
  36
  37 #define G_BUFF_LEN 4
  38
  39 static notification_t last_notif;
  40 static char g_buff[G_BUFF_LEN];
  41
  42 /* mock functions */
  43 int plugin_dispatch_notification(const notification_t *notif) {
  44   last_notif = *notif;
  45   return ENOTSUP;
  46 }
  47
  48 ssize_t pread(__attribute__((unused)) int fd, void *buf, size_t count,
  49               __attribute__((unused)) off_t offset) {
  50   if (count == 0 || count > G_BUFF_LEN)
  51     return -1;
  52
  53   memcpy(buf, g_buff, count);
  54   return count;
  55 }
  56 /* end mock functions */
  57
  58 DEF_TEST(clear_dev_list) {
  59   pcie_clear_list(NULL);
  60
  61   llist_t *test_list = llist_create();
  62   CHECK_NOT_NULL(test_list);
  63
  64   pcie_device_t *dev = calloc(1, sizeof(*dev));
  65   CHECK_NOT_NULL(dev);
  66
  67   llentry_t *entry = llentry_create(NULL, dev);
  68   CHECK_NOT_NULL(entry);
  69
  70   llist_append(test_list, entry);
  71
  72   for (llentry_t *e = llist_head(test_list); e != NULL; e = e->next) {
  73     EXPECT_EQ_UINT64(dev, e->value);
  74   }
  75
  76   pcie_clear_list(test_list);
  77
  78   return 0;
  79 }
  80
  81 DEF_TEST(add_to_list) {
  82   llist_t *test_list = llist_create();
  83   CHECK_NOT_NULL(test_list);
  84
  85   int ret = pcie_add_device(test_list, TEST_DOMAIN, TEST_BUS, TEST_DEVICE,
  86                             TEST_FUNCTION);
  87   EXPECT_EQ_INT(0, ret);
  88
  89   llentry_t *e = llist_head(test_list);
  90   CHECK_NOT_NULL(e);
  91   OK(NULL == e->next);
  92
  93   pcie_device_t *dev = e->value;
  94   CHECK_NOT_NULL(dev);
  95   EXPECT_EQ_INT(TEST_DOMAIN, dev->domain);
  96   EXPECT_EQ_INT(TEST_BUS, dev->bus);
  97   EXPECT_EQ_INT(TEST_DEVICE, dev->device);
  98   EXPECT_EQ_INT(TEST_FUNCTION, dev->function);
  99   EXPECT_EQ_INT(-1, dev->cap_exp);
 100   EXPECT_EQ_INT(-1, dev->ecap_aer);
 101
 102   pcie_clear_list(test_list);
 103
 104   return 0;
 105 }
 106
 107 DEF_TEST(pcie_read) {
 108   int ret;
 109   pcie_device_t dev = {0};
 110   uint32_t val = 0;
 111   g_buff[0] = 4;
 112   g_buff[1] = 3;
 113   g_buff[2] = 2;
 114   g_buff[3] = 1;
 115
 116   ret = pcie_read(&dev, &val, 1, 0);
 117   EXPECT_EQ_INT(0, ret);
 118   EXPECT_EQ_INT(4, val);
 119
 120   ret = pcie_read(&dev, &val, 2, 0);
 121   EXPECT_EQ_INT(0, ret);
 122   EXPECT_EQ_INT(0x304, val);
 123
 124   ret = pcie_read(&dev, &val, 3, 0);
 125   EXPECT_EQ_INT(0, ret);
 126   EXPECT_EQ_INT(0x20304, val);
 127
 128   ret = pcie_read(&dev, &val, 4, 0);
 129   EXPECT_EQ_INT(0, ret);
 130   EXPECT_EQ_INT(0x1020304, val);
 131
 132   ret = pcie_read(&dev, &val, G_BUFF_LEN + 1, 0);
 133   EXPECT_EQ_INT(-1, ret);
 134
 135   pcie_fops.read = pcie_read;
 136
 137   uint8_t val8 = pcie_read8(&dev, 0);
 138   EXPECT_EQ_INT(4, val8);
 139
 140   uint16_t val16 = pcie_read16(&dev, 0);
 141   EXPECT_EQ_INT(0x304, val16);
 142
 143   uint32_t val32 = pcie_read32(&dev, 0);
 144   EXPECT_EQ_INT(0x1020304, val32);
 145
 146   return 0;
 147 }
 148
 149 DEF_TEST(dispatch_notification) {
 150   pcie_device_t dev = {0, TEST_DOMAIN, TEST_BUS, TEST_DEVICE, TEST_FUNCTION,
 151                        0, 0,           0,        0,           0};
 152   cdtime_t t = cdtime();
 153   notification_t n = {
 154       .severity = 1, .time = t, .plugin = "pcie_errors_test", .meta = NULL};
 155
 156   pcie_dispatch_notification(&dev, &n, "test_type", "test_type_instance");
 157   EXPECT_EQ_INT(1, last_notif.severity);
 158   EXPECT_EQ_UINT64(t, last_notif.time);
 159   EXPECT_EQ_STR("pcie_errors_test", last_notif.plugin);
 160   OK(NULL == last_notif.meta);
 161   EXPECT_EQ_STR(hostname_g, last_notif.host);
 162   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 163   EXPECT_EQ_STR("test_type", last_notif.type);
 164   EXPECT_EQ_STR("test_type_instance", last_notif.type_instance);
 165
 166   return 0;
 167 }
 168
 169 DEF_TEST(access_config) {
 170   pcie_config.use_sysfs = 0;
 171   pcie_access_config();
 172   EXPECT_EQ_UINT64(pcie_list_devices_proc, pcie_fops.list_devices);
 173   EXPECT_EQ_UINT64(pcie_open_proc, pcie_fops.open);
 174   EXPECT_EQ_UINT64(pcie_close, pcie_fops.close);
 175   EXPECT_EQ_UINT64(pcie_read, pcie_fops.read);
 176   EXPECT_EQ_STR(PCIE_DEFAULT_PROCDIR, pcie_config.access_dir);
 177
 178   sstrncpy(pcie_config.access_dir, "Test", sizeof(pcie_config.access_dir));
 179   pcie_access_config();
 180   EXPECT_EQ_STR("Test", pcie_config.access_dir);
 181
 182   pcie_config.use_sysfs = 1;
 183   pcie_access_config();
 184   EXPECT_EQ_UINT64(pcie_list_devices_sysfs, pcie_fops.list_devices);
 185   EXPECT_EQ_UINT64(pcie_open_sysfs, pcie_fops.open);
 186   EXPECT_EQ_UINT64(pcie_close, pcie_fops.close);
 187   EXPECT_EQ_UINT64(pcie_read, pcie_fops.read);
 188   EXPECT_EQ_STR("Test", pcie_config.access_dir);
 189
 190   pcie_config.access_dir[0] = '\0';
 191   pcie_access_config();
 192   EXPECT_EQ_STR(PCIE_DEFAULT_SYSFSDIR, pcie_config.access_dir);
 193
 194   return 0;
 195 }
 196
 197 DEF_TEST(plugin_config_fail) {
 198   oconfig_item_t test_cfg_parent = {"pcie_errors", NULL, 0, NULL, NULL, 0};
 199   char value_buff[256] = "procs";
 200   char key_buff[256] = "Sources";
 201   oconfig_value_t test_cfg_value = {{value_buff}, OCONFIG_TYPE_STRING};
 202   oconfig_item_t test_cfg = {
 203       key_buff, &test_cfg_value, 1, &test_cfg_parent, NULL, 0};
 204
 205   test_cfg_parent.children = &test_cfg;
 206   test_cfg_parent.children_num = 1;
 207
 208   int ret = pcie_plugin_config(&test_cfg_parent);
 209   EXPECT_EQ_INT(0, ret);
 210   EXPECT_EQ_INT(1, pcie_config.config_error);
 211   pcie_config.config_error = 0;
 212
 213   sstrncpy(key_buff, "Source", sizeof(key_buff));
 214   ret = pcie_plugin_config(&test_cfg_parent);
 215   EXPECT_EQ_INT(0, ret);
 216   EXPECT_EQ_INT(1, pcie_config.config_error);
 217   pcie_config.config_error = 0;
 218
 219   sstrncpy(value_buff, "proc", sizeof(value_buff));
 220   test_cfg_value.type = OCONFIG_TYPE_NUMBER;
 221   ret = pcie_plugin_config(&test_cfg_parent);
 222   EXPECT_EQ_INT(0, ret);
 223   EXPECT_EQ_INT(1, pcie_config.config_error);
 224   pcie_config.config_error = 0;
 225
 226   sstrncpy(key_buff, "AccessDir", sizeof(key_buff));
 227   ret = pcie_plugin_config(&test_cfg_parent);
 228   EXPECT_EQ_INT(0, ret);
 229   EXPECT_EQ_INT(1, pcie_config.config_error);
 230   pcie_config.config_error = 0;
 231
 232   return 0;
 233 }
 234
 235 DEF_TEST(plugin_config) {
 236   oconfig_item_t test_cfg_parent = {"pcie_errors", NULL, 0, NULL, NULL, 0};
 237   char value_buff[256] = "proc";
 238   char key_buff[256] = "source";
 239   oconfig_value_t test_cfg_value = {{value_buff}, OCONFIG_TYPE_STRING};
 240   oconfig_item_t test_cfg = {
 241       key_buff, &test_cfg_value, 1, &test_cfg_parent, NULL, 0};
 242
 243   test_cfg_parent.children = &test_cfg;
 244   test_cfg_parent.children_num = 1;
 245
 246   pcie_config.use_sysfs = 1;
 247   int ret = pcie_plugin_config(&test_cfg_parent);
 248   EXPECT_EQ_INT(0, ret);
 249   EXPECT_EQ_INT(0, pcie_config.config_error);
 250   EXPECT_EQ_INT(0, pcie_config.use_sysfs);
 251
 252   pcie_config.use_sysfs = 1;
 253   sstrncpy(value_buff, "sysfs", sizeof(value_buff));
 254   ret = pcie_plugin_config(&test_cfg_parent);
 255   EXPECT_EQ_INT(0, ret);
 256   EXPECT_EQ_INT(0, pcie_config.config_error);
 257   EXPECT_EQ_INT(1, pcie_config.use_sysfs);
 258
 259   sstrncpy(key_buff, "AccessDir", sizeof(key_buff));
 260   sstrncpy(value_buff, "some/test/value", sizeof(value_buff));
 261   ret = pcie_plugin_config(&test_cfg_parent);
 262   EXPECT_EQ_INT(0, ret);
 263   EXPECT_EQ_INT(0, pcie_config.config_error);
 264   EXPECT_EQ_STR("some/test/value", pcie_config.access_dir);
 265
 266   memset(&test_cfg_value.value, 0, sizeof(test_cfg_value.value));
 267   test_cfg_value.value.boolean = 1;
 268   test_cfg_value.type = OCONFIG_TYPE_BOOLEAN;
 269   sstrncpy(key_buff, "ReportMasked", sizeof(key_buff));
 270   ret = pcie_plugin_config(&test_cfg_parent);
 271   EXPECT_EQ_INT(0, ret);
 272   EXPECT_EQ_INT(0, pcie_config.config_error);
 273   EXPECT_EQ_INT(1, pcie_config.notif_masked);
 274
 275   sstrncpy(key_buff, "PersistentNotifications", sizeof(key_buff));
 276   ret = pcie_plugin_config(&test_cfg_parent);
 277   EXPECT_EQ_INT(0, ret);
 278   EXPECT_EQ_INT(0, pcie_config.config_error);
 279   EXPECT_EQ_INT(1, pcie_config.persistent);
 280
 281   return 0;
 282 }
 283
 284 #define BAD_TLP_SET_MSG "Correctable Error set: Bad TLP Status"
 285 #define BAD_TLP_CLEAR_MSG "Correctable Error cleared: Bad TLP Status"
 286
 287 DEF_TEST(dispatch_correctable_errors) {
 288   pcie_device_t dev = {0, TEST_DOMAIN, TEST_BUS, TEST_DEVICE, TEST_FUNCTION,
 289                        0, 0,           0,        0,           0};
 290   pcie_config.notif_masked = 0;
 291   pcie_config.persistent = 0;
 292
 293   pcie_dispatch_correctable_errors(&dev, PCI_ERR_COR_BAD_TLP,
 294                                    ~(PCI_ERR_COR_BAD_TLP));
 295   EXPECT_EQ_INT(NOTIF_WARNING, last_notif.severity);
 296   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 297   OK(NULL == last_notif.meta);
 298   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 299   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 300   EXPECT_EQ_STR(PCIE_SEV_CE, last_notif.type_instance);
 301   EXPECT_EQ_STR(BAD_TLP_SET_MSG, last_notif.message);
 302
 303   memset(&last_notif, 0, sizeof(last_notif));
 304   dev.correctable_errors = PCI_ERR_COR_BAD_TLP;
 305   pcie_dispatch_correctable_errors(&dev, PCI_ERR_COR_BAD_TLP,
 306                                    ~(PCI_ERR_COR_BAD_TLP));
 307   EXPECT_EQ_STR("", last_notif.plugin_instance);
 308
 309   pcie_config.persistent = 1;
 310   pcie_dispatch_correctable_errors(&dev, PCI_ERR_COR_BAD_TLP,
 311                                    ~(PCI_ERR_COR_BAD_TLP));
 312   EXPECT_EQ_INT(NOTIF_WARNING, last_notif.severity);
 313   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 314   OK(NULL == last_notif.meta);
 315   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 316   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 317   EXPECT_EQ_STR(PCIE_SEV_CE, last_notif.type_instance);
 318   EXPECT_EQ_STR(BAD_TLP_SET_MSG, last_notif.message);
 319
 320   memset(&last_notif, 0, sizeof(last_notif));
 321   pcie_dispatch_correctable_errors(&dev, PCI_ERR_COR_BAD_TLP,
 322                                    PCI_ERR_COR_BAD_TLP);
 323   EXPECT_EQ_STR("", last_notif.plugin_instance);
 324
 325   pcie_config.notif_masked = 1;
 326   pcie_dispatch_correctable_errors(&dev, PCI_ERR_COR_BAD_TLP,
 327                                    PCI_ERR_COR_BAD_TLP);
 328   EXPECT_EQ_INT(NOTIF_WARNING, last_notif.severity);
 329   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 330   OK(NULL == last_notif.meta);
 331   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 332   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 333   EXPECT_EQ_STR(PCIE_SEV_CE, last_notif.type_instance);
 334   EXPECT_EQ_STR(BAD_TLP_SET_MSG, last_notif.message);
 335
 336   pcie_config.persistent = 0;
 337   memset(&last_notif, 0, sizeof(last_notif));
 338   pcie_dispatch_correctable_errors(&dev, PCI_ERR_COR_BAD_TLP,
 339                                    PCI_ERR_COR_BAD_TLP);
 340   EXPECT_EQ_STR("", last_notif.plugin_instance);
 341
 342   dev.correctable_errors = 0;
 343   pcie_dispatch_correctable_errors(&dev, PCI_ERR_COR_BAD_TLP,
 344                                    PCI_ERR_COR_BAD_TLP);
 345   EXPECT_EQ_INT(NOTIF_WARNING, last_notif.severity);
 346   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 347   OK(NULL == last_notif.meta);
 348   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 349   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 350   EXPECT_EQ_STR(PCIE_SEV_CE, last_notif.type_instance);
 351   EXPECT_EQ_STR(BAD_TLP_SET_MSG, last_notif.message);
 352
 353   pcie_dispatch_correctable_errors(&dev, PCI_ERR_COR_BAD_TLP,
 354                                    ~(PCI_ERR_COR_BAD_TLP));
 355   EXPECT_EQ_INT(NOTIF_WARNING, last_notif.severity);
 356   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 357   OK(NULL == last_notif.meta);
 358   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 359   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 360   EXPECT_EQ_STR(PCIE_SEV_CE, last_notif.type_instance);
 361   EXPECT_EQ_STR(BAD_TLP_SET_MSG, last_notif.message);
 362
 363   pcie_config.notif_masked = 0;
 364   dev.correctable_errors = PCI_ERR_COR_BAD_TLP;
 365   pcie_dispatch_correctable_errors(&dev, 0, ~(PCI_ERR_COR_BAD_TLP));
 366   EXPECT_EQ_INT(NOTIF_OKAY, last_notif.severity);
 367   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 368   OK(NULL == last_notif.meta);
 369   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 370   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 371   EXPECT_EQ_STR(PCIE_SEV_CE, last_notif.type_instance);
 372   EXPECT_EQ_STR(BAD_TLP_CLEAR_MSG, last_notif.message);
 373
 374   return 0;
 375 }
 376
 377 #define FCP_NF_SET_MSG                                                         \
 378   "Uncorrectable(non_fatal) Error set: Flow Control Protocol"
 379 #define FCP_F_SET_MSG "Uncorrectable(fatal) Error set: Flow Control Protocol"
 380 #define FCP_NF_CLEAR_MSG                                                       \
 381   "Uncorrectable(non_fatal) Error cleared: Flow Control Protocol"
 382 #define FCP_F_CLEAR_MSG                                                        \
 383   "Uncorrectable(fatal) Error cleared: Flow Control Protocol"
 384
 385 DEF_TEST(dispatch_uncorrectable_errors) {
 386   pcie_device_t dev = {0, TEST_DOMAIN, TEST_BUS, TEST_DEVICE, TEST_FUNCTION,
 387                        0, 0,           0,        0,           0};
 388   pcie_config.notif_masked = 0;
 389   pcie_config.persistent = 0;
 390
 391   pcie_dispatch_uncorrectable_errors(&dev, PCI_ERR_UNC_FCP, ~(PCI_ERR_UNC_FCP),
 392                                      ~(PCI_ERR_UNC_FCP));
 393   EXPECT_EQ_INT(NOTIF_WARNING, last_notif.severity);
 394   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 395   OK(NULL == last_notif.meta);
 396   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 397   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 398   EXPECT_EQ_STR(PCIE_SEV_NOFATAL, last_notif.type_instance);
 399   EXPECT_EQ_STR(FCP_NF_SET_MSG, last_notif.message);
 400
 401   pcie_dispatch_uncorrectable_errors(&dev, PCI_ERR_UNC_FCP, ~(PCI_ERR_UNC_FCP),
 402                                      PCI_ERR_UNC_FCP);
 403   EXPECT_EQ_INT(NOTIF_FAILURE, last_notif.severity);
 404   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 405   OK(NULL == last_notif.meta);
 406   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 407   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 408   EXPECT_EQ_STR(PCIE_SEV_FATAL, last_notif.type_instance);
 409   EXPECT_EQ_STR(FCP_F_SET_MSG, last_notif.message);
 410
 411   memset(&last_notif, 0, sizeof(last_notif));
 412   dev.uncorrectable_errors = PCI_ERR_UNC_FCP;
 413   pcie_dispatch_uncorrectable_errors(&dev, PCI_ERR_UNC_FCP, ~(PCI_ERR_UNC_FCP),
 414                                      PCI_ERR_UNC_FCP);
 415   EXPECT_EQ_STR("", last_notif.plugin_instance);
 416
 417   pcie_config.persistent = 1;
 418   pcie_dispatch_uncorrectable_errors(&dev, PCI_ERR_UNC_FCP, ~(PCI_ERR_UNC_FCP),
 419                                      PCI_ERR_UNC_FCP);
 420   EXPECT_EQ_INT(NOTIF_FAILURE, last_notif.severity);
 421   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 422   OK(NULL == last_notif.meta);
 423   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 424   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 425   EXPECT_EQ_STR(PCIE_SEV_FATAL, last_notif.type_instance);
 426   EXPECT_EQ_STR(FCP_F_SET_MSG, last_notif.message);
 427
 428   memset(&last_notif, 0, sizeof(last_notif));
 429   pcie_dispatch_uncorrectable_errors(&dev, PCI_ERR_UNC_FCP, PCI_ERR_UNC_FCP,
 430                                      PCI_ERR_UNC_FCP);
 431   EXPECT_EQ_STR("", last_notif.plugin_instance);
 432
 433   pcie_config.notif_masked = 1;
 434   pcie_dispatch_uncorrectable_errors(&dev, PCI_ERR_UNC_FCP, PCI_ERR_UNC_FCP,
 435                                      PCI_ERR_UNC_FCP);
 436   EXPECT_EQ_INT(NOTIF_FAILURE, last_notif.severity);
 437   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 438   OK(NULL == last_notif.meta);
 439   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 440   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 441   EXPECT_EQ_STR(PCIE_SEV_FATAL, last_notif.type_instance);
 442   EXPECT_EQ_STR(FCP_F_SET_MSG, last_notif.message);
 443
 444   pcie_config.persistent = 0;
 445   dev.uncorrectable_errors = 0;
 446   memset(&last_notif, 0, sizeof(last_notif));
 447   pcie_dispatch_uncorrectable_errors(&dev, PCI_ERR_UNC_FCP, ~(PCI_ERR_UNC_FCP),
 448                                      PCI_ERR_UNC_FCP);
 449   EXPECT_EQ_INT(NOTIF_FAILURE, last_notif.severity);
 450   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 451   OK(NULL == last_notif.meta);
 452   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 453   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 454   EXPECT_EQ_STR(PCIE_SEV_FATAL, last_notif.type_instance);
 455   EXPECT_EQ_STR(FCP_F_SET_MSG, last_notif.message);
 456
 457   pcie_config.notif_masked = 0;
 458   dev.uncorrectable_errors = PCI_ERR_UNC_FCP;
 459   pcie_dispatch_uncorrectable_errors(&dev, 0, ~(PCI_ERR_UNC_FCP),
 460                                      ~(PCI_ERR_UNC_FCP));
 461   EXPECT_EQ_INT(NOTIF_OKAY, last_notif.severity);
 462   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 463   OK(NULL == last_notif.meta);
 464   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 465   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 466   EXPECT_EQ_STR(PCIE_SEV_NOFATAL, last_notif.type_instance);
 467   EXPECT_EQ_STR(FCP_NF_CLEAR_MSG, last_notif.message);
 468
 469   memset(&last_notif, 0, sizeof(last_notif));
 470   pcie_dispatch_uncorrectable_errors(&dev, 0, ~(PCI_ERR_UNC_FCP),
 471                                      PCI_ERR_UNC_FCP);
 472   EXPECT_EQ_INT(NOTIF_OKAY, last_notif.severity);
 473   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 474   OK(NULL == last_notif.meta);
 475   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 476   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 477   EXPECT_EQ_STR(PCIE_SEV_FATAL, last_notif.type_instance);
 478   EXPECT_EQ_STR(FCP_F_CLEAR_MSG, last_notif.message);
 479
 480   return 0;
 481 }
 482
 483 #define UR_SET_MSG "Device Status Error set: Unsupported Request"
 484 #define UR_CLEAR_MSG "Device Status Error cleared: Unsupported Request"
 485 #define FE_SET_MSG "Device Status Error set: Fatal Error"
 486 #define FE_CLEAR_MSG "Device Status Error cleared: Fatal Error"
 487
 488 DEF_TEST(device_status_errors) {
 489   pcie_device_t dev = {0, TEST_DOMAIN, TEST_BUS, TEST_DEVICE, TEST_FUNCTION,
 490                        0, 0,           0,        0,           0};
 491   pcie_config.persistent = 0;
 492   g_buff[0] = (PCI_EXP_DEVSTA_URD & 0xff);
 493
 494   memset(&last_notif, 0, sizeof(last_notif));
 495   pcie_check_dev_status(&dev, 0);
 496   EXPECT_EQ_INT(NOTIF_WARNING, last_notif.severity);
 497   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 498   OK(NULL == last_notif.meta);
 499   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 500   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 501   EXPECT_EQ_STR(PCIE_SEV_NOFATAL, last_notif.type_instance);
 502   EXPECT_EQ_STR(UR_SET_MSG, last_notif.message);
 503
 504   memset(&last_notif, 0, sizeof(last_notif));
 505   pcie_check_dev_status(&dev, 0);
 506   EXPECT_EQ_STR("", last_notif.plugin_instance);
 507
 508   pcie_config.persistent = 1;
 509   pcie_check_dev_status(&dev, 0);
 510   EXPECT_EQ_INT(NOTIF_WARNING, last_notif.severity);
 511   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 512   OK(NULL == last_notif.meta);
 513   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 514   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 515   EXPECT_EQ_STR(PCIE_SEV_NOFATAL, last_notif.type_instance);
 516   EXPECT_EQ_STR(UR_SET_MSG, last_notif.message);
 517
 518   g_buff[0] = 0;
 519   pcie_check_dev_status(&dev, 0);
 520   EXPECT_EQ_INT(NOTIF_OKAY, last_notif.severity);
 521   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 522   OK(NULL == last_notif.meta);
 523   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 524   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 525   EXPECT_EQ_STR(PCIE_SEV_NOFATAL, last_notif.type_instance);
 526   EXPECT_EQ_STR(UR_CLEAR_MSG, last_notif.message);
 527
 528   pcie_config.persistent = 0;
 529   dev.device_status = PCI_EXP_DEVSTA_URD;
 530   pcie_check_dev_status(&dev, 0);
 531   EXPECT_EQ_INT(NOTIF_OKAY, last_notif.severity);
 532   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 533   OK(NULL == last_notif.meta);
 534   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 535   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 536   EXPECT_EQ_STR(PCIE_SEV_NOFATAL, last_notif.type_instance);
 537   EXPECT_EQ_STR(UR_CLEAR_MSG, last_notif.message);
 538
 539   memset(&last_notif, 0, sizeof(last_notif));
 540   pcie_check_dev_status(&dev, 0);
 541   EXPECT_EQ_STR("", last_notif.plugin_instance);
 542
 543   g_buff[0] = (PCI_EXP_DEVSTA_FED & 0xff);
 544   pcie_check_dev_status(&dev, 0);
 545   EXPECT_EQ_INT(NOTIF_FAILURE, last_notif.severity);
 546   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 547   OK(NULL == last_notif.meta);
 548   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 549   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 550   EXPECT_EQ_STR(PCIE_SEV_FATAL, last_notif.type_instance);
 551   EXPECT_EQ_STR(FE_SET_MSG, last_notif.message);
 552
 553   g_buff[0] = 0;
 554   pcie_check_dev_status(&dev, 0);
 555   EXPECT_EQ_INT(NOTIF_OKAY, last_notif.severity);
 556   EXPECT_EQ_STR(PCIE_ERRORS_PLUGIN, last_notif.plugin);
 557   OK(NULL == last_notif.meta);
 558   EXPECT_EQ_STR(TEST_DEVICE_STR, last_notif.plugin_instance);
 559   EXPECT_EQ_STR(PCIE_ERROR, last_notif.type);
 560   EXPECT_EQ_STR(PCIE_SEV_FATAL, last_notif.type_instance);
 561   EXPECT_EQ_STR(FE_CLEAR_MSG, last_notif.message);
 562
 563   return 0;
 564 }
 565
 566 int main(void) {
 567   RUN_TEST(clear_dev_list);
 568   RUN_TEST(add_to_list);
 569   RUN_TEST(pcie_read);
 570   RUN_TEST(dispatch_notification);
 571
 572   RUN_TEST(access_config);
 573   RUN_TEST(plugin_config_fail);
 574   RUN_TEST(plugin_config);
 575
 576   RUN_TEST(dispatch_correctable_errors);
 577   RUN_TEST(dispatch_uncorrectable_errors);
 578   RUN_TEST(device_status_errors);
 579
 580   END_TEST;
 581 }