2 * collectd - src/pcie_errors.c
4 * Copyright(c) 2018 Intel Corporation. All rights reserved.
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
25 * Kamil Wiatrowski <kamilx.wiatrowski@intel.com>
28 #include "pcie_errors.c" /* sic */
33 #define TEST_DEVICE 0xc
34 #define TEST_FUNCTION 2
35 #define TEST_DEVICE_STR "0001:05:0c.2"
39 static notification_t last_notif;
40 static char g_buff[G_BUFF_LEN];
43 int plugin_dispatch_notification(const notification_t *notif) {
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)
53 memcpy(buf, g_buff, count);
56 /* end mock functions */
58 DEF_TEST(clear_dev_list) {
59 pcie_clear_list(NULL);
61 llist_t *test_list = llist_create();
62 CHECK_NOT_NULL(test_list);
64 pcie_device_t *dev = calloc(1, sizeof(*dev));
67 llentry_t *entry = llentry_create(NULL, dev);
68 CHECK_NOT_NULL(entry);
70 llist_append(test_list, entry);
72 for (llentry_t *e = llist_head(test_list); e != NULL; e = e->next) {
73 EXPECT_EQ_UINT64(dev, e->value);
76 pcie_clear_list(test_list);
81 DEF_TEST(add_to_list) {
82 llist_t *test_list = llist_create();
83 CHECK_NOT_NULL(test_list);
85 int ret = pcie_add_device(test_list, TEST_DOMAIN, TEST_BUS, TEST_DEVICE,
87 EXPECT_EQ_INT(0, ret);
89 llentry_t *e = llist_head(test_list);
93 pcie_device_t *dev = e->value;
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);
102 pcie_clear_list(test_list);
107 DEF_TEST(pcie_read) {
109 pcie_device_t dev = {0};
116 ret = pcie_read(&dev, &val, 1, 0);
117 EXPECT_EQ_INT(0, ret);
118 EXPECT_EQ_INT(4, val);
120 ret = pcie_read(&dev, &val, 2, 0);
121 EXPECT_EQ_INT(0, ret);
122 EXPECT_EQ_INT(0x304, val);
124 ret = pcie_read(&dev, &val, 3, 0);
125 EXPECT_EQ_INT(0, ret);
126 EXPECT_EQ_INT(0x20304, val);
128 ret = pcie_read(&dev, &val, 4, 0);
129 EXPECT_EQ_INT(0, ret);
130 EXPECT_EQ_INT(0x1020304, val);
132 ret = pcie_read(&dev, &val, G_BUFF_LEN + 1, 0);
133 EXPECT_EQ_INT(-1, ret);
135 pcie_fops.read = pcie_read;
137 uint8_t val8 = pcie_read8(&dev, 0);
138 EXPECT_EQ_INT(4, val8);
140 uint16_t val16 = pcie_read16(&dev, 0);
141 EXPECT_EQ_INT(0x304, val16);
143 uint32_t val32 = pcie_read32(&dev, 0);
144 EXPECT_EQ_INT(0x1020304, val32);
149 DEF_TEST(dispatch_notification) {
150 pcie_device_t dev = {0, TEST_DOMAIN, TEST_BUS, TEST_DEVICE, TEST_FUNCTION,
152 cdtime_t t = cdtime();
154 .severity = 1, .time = t, .plugin = "pcie_errors_test", .meta = NULL};
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);
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);
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);
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);
190 pcie_config.access_dir[0] = '\0';
191 pcie_access_config();
192 EXPECT_EQ_STR(PCIE_DEFAULT_SYSFSDIR, pcie_config.access_dir);
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};
205 test_cfg_parent.children = &test_cfg;
206 test_cfg_parent.children_num = 1;
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;
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;
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;
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;
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};
243 test_cfg_parent.children = &test_cfg;
244 test_cfg_parent.children_num = 1;
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);
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);
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);
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);
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);
284 #define BAD_TLP_SET_MSG "Correctable Error set: Bad TLP Status"
285 #define BAD_TLP_CLEAR_MSG "Correctable Error cleared: Bad TLP Status"
287 DEF_TEST(dispatch_correctable_errors) {
288 pcie_device_t dev = {0, TEST_DOMAIN, TEST_BUS, TEST_DEVICE, TEST_FUNCTION,
290 pcie_config.notif_masked = 0;
291 pcie_config.persistent = 0;
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);
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);
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);
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);
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);
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);
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);
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);
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);
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"
385 DEF_TEST(dispatch_uncorrectable_errors) {
386 pcie_device_t dev = {0, TEST_DOMAIN, TEST_BUS, TEST_DEVICE, TEST_FUNCTION,
388 pcie_config.notif_masked = 0;
389 pcie_config.persistent = 0;
391 pcie_dispatch_uncorrectable_errors(&dev, PCI_ERR_UNC_FCP, ~(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);
401 pcie_dispatch_uncorrectable_errors(&dev, PCI_ERR_UNC_FCP, ~(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);
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),
415 EXPECT_EQ_STR("", last_notif.plugin_instance);
417 pcie_config.persistent = 1;
418 pcie_dispatch_uncorrectable_errors(&dev, PCI_ERR_UNC_FCP, ~(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);
428 memset(&last_notif, 0, sizeof(last_notif));
429 pcie_dispatch_uncorrectable_errors(&dev, PCI_ERR_UNC_FCP, PCI_ERR_UNC_FCP,
431 EXPECT_EQ_STR("", last_notif.plugin_instance);
433 pcie_config.notif_masked = 1;
434 pcie_dispatch_uncorrectable_errors(&dev, PCI_ERR_UNC_FCP, 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);
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),
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);
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),
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);
469 memset(&last_notif, 0, sizeof(last_notif));
470 pcie_dispatch_uncorrectable_errors(&dev, 0, ~(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);
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"
488 DEF_TEST(device_status_errors) {
489 pcie_device_t dev = {0, TEST_DOMAIN, TEST_BUS, TEST_DEVICE, TEST_FUNCTION,
491 pcie_config.persistent = 0;
492 g_buff[0] = (PCI_EXP_DEVSTA_URD & 0xff);
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);
504 memset(&last_notif, 0, sizeof(last_notif));
505 pcie_check_dev_status(&dev, 0);
506 EXPECT_EQ_STR("", last_notif.plugin_instance);
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);
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);
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);
539 memset(&last_notif, 0, sizeof(last_notif));
540 pcie_check_dev_status(&dev, 0);
541 EXPECT_EQ_STR("", last_notif.plugin_instance);
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);
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);
567 RUN_TEST(clear_dev_list);
568 RUN_TEST(add_to_list);
570 RUN_TEST(dispatch_notification);
572 RUN_TEST(access_config);
573 RUN_TEST(plugin_config_fail);
574 RUN_TEST(plugin_config);
576 RUN_TEST(dispatch_correctable_errors);
577 RUN_TEST(dispatch_uncorrectable_errors);
578 RUN_TEST(device_status_errors);