From 4f1fc1e5a7fe01f5d355ae3219b931a389f6bdbe Mon Sep 17 00:00:00 2001 From: overweight <5324761+overweight@user.noreply.gitee.com> Date: Mon, 30 Sep 2019 11:16:11 -0400 Subject: [PATCH] Package init --- add-rbtree-support-for-page-record.patch | 601 ++++++++++++++++++++ bugfix-fix-fd-check.patch | 18 + bugfix-ras-events-memory-leak.patch | 18 + bugfix-rasdaemon-wait-for-file-access.patch | 50 ++ feature-mc-support-page-isolation.patch | 524 +++++++++++++++++ feature-report-ARM-processor-info.patch | 367 ++++++++++++ output-log-timely.patch | 27 + rasdaemon-0.6.3.tar.gz | Bin 0 -> 134127 bytes rasdaemon.spec | 77 +++ 9 files changed, 1682 insertions(+) create mode 100644 add-rbtree-support-for-page-record.patch create mode 100644 bugfix-fix-fd-check.patch create mode 100644 bugfix-ras-events-memory-leak.patch create mode 100644 bugfix-rasdaemon-wait-for-file-access.patch create mode 100644 feature-mc-support-page-isolation.patch create mode 100644 feature-report-ARM-processor-info.patch create mode 100644 output-log-timely.patch create mode 100644 rasdaemon-0.6.3.tar.gz create mode 100644 rasdaemon.spec diff --git a/add-rbtree-support-for-page-record.patch b/add-rbtree-support-for-page-record.patch new file mode 100644 index 0000000..efd8742 --- /dev/null +++ b/add-rbtree-support-for-page-record.patch @@ -0,0 +1,601 @@ +From 3d5d5b581e92cf4240485a1c0fb92d35da0dfb7f Mon Sep 17 00:00:00 2001 +From: lvying +Date: Sat, 26 Jan 2019 15:19:16 +0800 +Subject: [PATCH] add rbtree support for page record + +--- + Makefile.am | 4 +- + rbtree.c | 385 ++++++++++++++++++++++++++++++++++++++++++++++++++++ + rbtree.h | 166 ++++++++++++++++++++++ + 3 files changed, 553 insertions(+), 2 deletions(-) + create mode 100644 rbtree.c + create mode 100644 rbtree.h + +diff --git a/Makefile.am b/Makefile.am +index 843b538..2ff742d 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -17,7 +17,7 @@ all-local: $(SYSTEMD_SERVICES) + + sbin_PROGRAMS = rasdaemon + rasdaemon_SOURCES = rasdaemon.c ras-events.c ras-mc-handler.c \ +- bitfield.c ++ bitfield.c rbtree.c + if WITH_SQLITE3 + rasdaemon_SOURCES += ras-record.c + endif +@@ -59,7 +59,7 @@ rasdaemon_LDADD = -lpthread $(SQLITE3_LIBS) libtrace/libtrace.a + include_HEADERS = config.h ras-events.h ras-logger.h ras-mc-handler.h \ + ras-aer-handler.h ras-mce-handler.h ras-record.h bitfield.h ras-report.h \ + ras-extlog-handler.h ras-arm-handler.h ras-non-standard-handler.h \ +- ras-devlink-handler.h ras-diskerror-handler.h ++ ras-devlink-handler.h ras-diskerror-handler.h rbtree.h + + # This rule can't be called with more than one Makefile job (like make -j8) + # I can't figure out a way to fix that +diff --git a/rbtree.c b/rbtree.c +new file mode 100644 +index 0000000..0bc6267 +--- /dev/null ++++ b/rbtree.c +@@ -0,0 +1,385 @@ ++/* ++ Red Black Trees ++ (C) 1999 Andrea Arcangeli ++ (C) 2002 David Woodhouse ++ Taken from the Linux 2.6.30 source with some minor modificatons. ++ ++ This program is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 2 of the License, or ++ (at your option) any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software ++ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ ++ linux/lib/rbtree.c ++*/ ++ ++#include "rbtree.h" ++ ++static void __rb_rotate_left(struct rb_node *node, struct rb_root *root) ++{ ++ struct rb_node *right = node->rb_right; ++ struct rb_node *parent = rb_parent(node); ++ ++ if ((node->rb_right = right->rb_left)) ++ rb_set_parent(right->rb_left, node); ++ right->rb_left = node; ++ ++ rb_set_parent(right, parent); ++ ++ if (parent) ++ { ++ if (node == parent->rb_left) ++ parent->rb_left = right; ++ else ++ parent->rb_right = right; ++ } ++ else ++ root->rb_node = right; ++ rb_set_parent(node, right); ++} ++ ++static void __rb_rotate_right(struct rb_node *node, struct rb_root *root) ++{ ++ struct rb_node *left = node->rb_left; ++ struct rb_node *parent = rb_parent(node); ++ ++ if ((node->rb_left = left->rb_right)) ++ rb_set_parent(left->rb_right, node); ++ left->rb_right = node; ++ ++ rb_set_parent(left, parent); ++ ++ if (parent) ++ { ++ if (node == parent->rb_right) ++ parent->rb_right = left; ++ else ++ parent->rb_left = left; ++ } ++ else ++ root->rb_node = left; ++ rb_set_parent(node, left); ++} ++ ++void rb_insert_color(struct rb_node *node, struct rb_root *root) ++{ ++ struct rb_node *parent, *gparent; ++ ++ while ((parent = rb_parent(node)) && rb_is_red(parent)) ++ { ++ gparent = rb_parent(parent); ++ ++ if (parent == gparent->rb_left) ++ { ++ { ++ register struct rb_node *uncle = gparent->rb_right; ++ if (uncle && rb_is_red(uncle)) ++ { ++ rb_set_black(uncle); ++ rb_set_black(parent); ++ rb_set_red(gparent); ++ node = gparent; ++ continue; ++ } ++ } ++ ++ if (parent->rb_right == node) ++ { ++ struct rb_node *tmp; ++ __rb_rotate_left(parent, root); ++ tmp = parent; ++ parent = node; ++ node = tmp; ++ } ++ ++ rb_set_black(parent); ++ rb_set_red(gparent); ++ __rb_rotate_right(gparent, root); ++ } else { ++ { ++ struct rb_node *uncle = gparent->rb_left; ++ if (uncle && rb_is_red(uncle)) ++ { ++ rb_set_black(uncle); ++ rb_set_black(parent); ++ rb_set_red(gparent); ++ node = gparent; ++ continue; ++ } ++ } ++ ++ if (parent->rb_left == node) ++ { ++ struct rb_node *tmp; ++ __rb_rotate_right(parent, root); ++ tmp = parent; ++ parent = node; ++ node = tmp; ++ } ++ ++ rb_set_black(parent); ++ rb_set_red(gparent); ++ __rb_rotate_left(gparent, root); ++ } ++ } ++ ++ rb_set_black(root->rb_node); ++} ++ ++static void __rb_erase_color(struct rb_node *node, struct rb_node *parent, ++ struct rb_root *root) ++{ ++ struct rb_node *other; ++ ++ while ((!node || rb_is_black(node)) && node != root->rb_node) ++ { ++ if (parent->rb_left == node) ++ { ++ other = parent->rb_right; ++ if (rb_is_red(other)) ++ { ++ rb_set_black(other); ++ rb_set_red(parent); ++ __rb_rotate_left(parent, root); ++ other = parent->rb_right; ++ } ++ if ((!other->rb_left || rb_is_black(other->rb_left)) && ++ (!other->rb_right || rb_is_black(other->rb_right))) ++ { ++ rb_set_red(other); ++ node = parent; ++ parent = rb_parent(node); ++ } ++ else ++ { ++ if (!other->rb_right || rb_is_black(other->rb_right)) ++ { ++ rb_set_black(other->rb_left); ++ rb_set_red(other); ++ __rb_rotate_right(other, root); ++ other = parent->rb_right; ++ } ++ rb_set_color(other, rb_color(parent)); ++ rb_set_black(parent); ++ rb_set_black(other->rb_right); ++ __rb_rotate_left(parent, root); ++ node = root->rb_node; ++ break; ++ } ++ } ++ else ++ { ++ other = parent->rb_left; ++ if (rb_is_red(other)) ++ { ++ rb_set_black(other); ++ rb_set_red(parent); ++ __rb_rotate_right(parent, root); ++ other = parent->rb_left; ++ } ++ if ((!other->rb_left || rb_is_black(other->rb_left)) && ++ (!other->rb_right || rb_is_black(other->rb_right))) ++ { ++ rb_set_red(other); ++ node = parent; ++ parent = rb_parent(node); ++ } ++ else ++ { ++ if (!other->rb_left || rb_is_black(other->rb_left)) ++ { ++ rb_set_black(other->rb_right); ++ rb_set_red(other); ++ __rb_rotate_left(other, root); ++ other = parent->rb_left; ++ } ++ rb_set_color(other, rb_color(parent)); ++ rb_set_black(parent); ++ rb_set_black(other->rb_left); ++ __rb_rotate_right(parent, root); ++ node = root->rb_node; ++ break; ++ } ++ } ++ } ++ if (node) ++ rb_set_black(node); ++} ++ ++void rb_erase(struct rb_node *node, struct rb_root *root) ++{ ++ struct rb_node *child, *parent; ++ int color; ++ ++ if (!node->rb_left) ++ child = node->rb_right; ++ else if (!node->rb_right) ++ child = node->rb_left; ++ else ++ { ++ struct rb_node *old = node, *left; ++ ++ node = node->rb_right; ++ while ((left = node->rb_left) != NULL) ++ node = left; ++ child = node->rb_right; ++ parent = rb_parent(node); ++ color = rb_color(node); ++ ++ if (child) ++ rb_set_parent(child, parent); ++ if (parent == old) { ++ parent->rb_right = child; ++ parent = node; ++ } else ++ parent->rb_left = child; ++ ++ node->rb_parent_color = old->rb_parent_color; ++ node->rb_right = old->rb_right; ++ node->rb_left = old->rb_left; ++ ++ if (rb_parent(old)) ++ { ++ if (rb_parent(old)->rb_left == old) ++ rb_parent(old)->rb_left = node; ++ else ++ rb_parent(old)->rb_right = node; ++ } else ++ root->rb_node = node; ++ ++ rb_set_parent(old->rb_left, node); ++ if (old->rb_right) ++ rb_set_parent(old->rb_right, node); ++ goto color; ++ } ++ ++ parent = rb_parent(node); ++ color = rb_color(node); ++ ++ if (child) ++ rb_set_parent(child, parent); ++ if (parent) ++ { ++ if (parent->rb_left == node) ++ parent->rb_left = child; ++ else ++ parent->rb_right = child; ++ } ++ else ++ root->rb_node = child; ++ ++ color: ++ if (color == RB_BLACK) ++ __rb_erase_color(child, parent, root); ++} ++ ++/* ++ * This function returns the first node (in sort order) of the tree. ++ */ ++struct rb_node *rb_first(const struct rb_root *root) ++{ ++ struct rb_node *n; ++ ++ n = root->rb_node; ++ if (!n) ++ return NULL; ++ while (n->rb_left) ++ n = n->rb_left; ++ return n; ++} ++ ++struct rb_node *rb_last(const struct rb_root *root) ++{ ++ struct rb_node *n; ++ ++ n = root->rb_node; ++ if (!n) ++ return NULL; ++ while (n->rb_right) ++ n = n->rb_right; ++ return n; ++} ++ ++struct rb_node *rb_next(const struct rb_node *node) ++{ ++ struct rb_node *parent; ++ ++ if (rb_parent(node) == node) ++ return NULL; ++ ++ /* If we have a right-hand child, go down and then left as far ++ as we can. */ ++ if (node->rb_right) { ++ node = node->rb_right; ++ while (node->rb_left) ++ node=node->rb_left; ++ return (struct rb_node *)node; ++ } ++ ++ /* No right-hand children. Everything down and left is ++ smaller than us, so any 'next' node must be in the general ++ direction of our parent. Go up the tree; any time the ++ ancestor is a right-hand child of its parent, keep going ++ up. First time it's a left-hand child of its parent, said ++ parent is our 'next' node. */ ++ while ((parent = rb_parent(node)) && node == parent->rb_right) ++ node = parent; ++ ++ return parent; ++} ++ ++struct rb_node *rb_prev(const struct rb_node *node) ++{ ++ struct rb_node *parent; ++ ++ if (rb_parent(node) == node) ++ return NULL; ++ ++ /* If we have a left-hand child, go down and then right as far ++ as we can. */ ++ if (node->rb_left) { ++ node = node->rb_left; ++ while (node->rb_right) ++ node=node->rb_right; ++ return (struct rb_node *)node; ++ } ++ ++ /* No left-hand children. Go up till we find an ancestor which ++ is a right-hand child of its parent */ ++ while ((parent = rb_parent(node)) && node == parent->rb_left) ++ node = parent; ++ ++ return parent; ++} ++ ++void rb_replace_node(struct rb_node *victim, struct rb_node *new, ++ struct rb_root *root) ++{ ++ struct rb_node *parent = rb_parent(victim); ++ ++ /* Set the surrounding nodes to point to the replacement */ ++ if (parent) { ++ if (victim == parent->rb_left) ++ parent->rb_left = new; ++ else ++ parent->rb_right = new; ++ } else { ++ root->rb_node = new; ++ } ++ if (victim->rb_left) ++ rb_set_parent(victim->rb_left, new); ++ if (victim->rb_right) ++ rb_set_parent(victim->rb_right, new); ++ ++ /* Copy the pointers/colour from the victim to the replacement */ ++ *new = *victim; ++} ++ +diff --git a/rbtree.h b/rbtree.h +new file mode 100644 +index 0000000..8f232ae +--- /dev/null ++++ b/rbtree.h +@@ -0,0 +1,166 @@ ++/* ++ Red Black Trees ++ (C) 1999 Andrea Arcangeli ++ Taken from the Linux 2.6.30 source. ++ ++ This program is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 2 of the License, or ++ (at your option) any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software ++ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ ++ linux/include/linux/rbtree.h ++ ++ To use rbtrees you'll have to implement your own insert and search cores. ++ This will avoid us to use callbacks and to drop drammatically performances. ++ I know it's not the cleaner way, but in C (not in C++) to get ++ performances and genericity... ++ ++ Some example of insert and search follows here. The search is a plain ++ normal search over an ordered tree. The insert instead must be implemented ++ int two steps: as first thing the code must insert the element in ++ order as a red leaf in the tree, then the support library function ++ rb_insert_color() must be called. Such function will do the ++ not trivial work to rebalance the rbtree if necessary. ++ ++----------------------------------------------------------------------- ++static inline struct page * rb_search_page_cache(struct inode * inode, ++ unsigned long offset) ++{ ++ struct rb_node * n = inode->i_rb_page_cache.rb_node; ++ struct page * page; ++ ++ while (n) ++ { ++ page = rb_entry(n, struct page, rb_page_cache); ++ ++ if (offset < page->offset) ++ n = n->rb_left; ++ else if (offset > page->offset) ++ n = n->rb_right; ++ else ++ return page; ++ } ++ return NULL; ++} ++ ++static inline struct page * __rb_insert_page_cache(struct inode * inode, ++ unsigned long offset, ++ struct rb_node * node) ++{ ++ struct rb_node ** p = &inode->i_rb_page_cache.rb_node; ++ struct rb_node * parent = NULL; ++ struct page * page; ++ ++ while (*p) ++ { ++ parent = *p; ++ page = rb_entry(parent, struct page, rb_page_cache); ++ ++ if (offset < page->offset) ++ p = &(*p)->rb_left; ++ else if (offset > page->offset) ++ p = &(*p)->rb_right; ++ else ++ return page; ++ } ++ ++ rb_link_node(node, parent, p); ++ ++ return NULL; ++} ++ ++static inline struct page * rb_insert_page_cache(struct inode * inode, ++ unsigned long offset, ++ struct rb_node * node) ++{ ++ struct page * ret; ++ if ((ret = __rb_insert_page_cache(inode, offset, node))) ++ goto out; ++ rb_insert_color(node, &inode->i_rb_page_cache); ++ out: ++ return ret; ++} ++----------------------------------------------------------------------- ++*/ ++ ++#ifndef _LINUX_RBTREE_H ++#define _LINUX_RBTREE_H ++ ++#include ++ ++#define container_of(ptr, type, member) ({ \ ++ const typeof( ((type *)0)->member ) *__mptr = (ptr); \ ++ (type *)( (char *)__mptr - offsetof(type,member) );}) ++ ++struct rb_node ++{ ++ unsigned long rb_parent_color; ++#define RB_RED 0 ++#define RB_BLACK 1 ++ struct rb_node *rb_right; ++ struct rb_node *rb_left; ++} __attribute__((aligned(sizeof(long)))); ++ /* The alignment might seem pointless, but allegedly CRIS needs it */ ++ ++struct rb_root ++{ ++ struct rb_node *rb_node; ++}; ++ ++ ++#define rb_parent(r) ((struct rb_node *)((r)->rb_parent_color & ~3)) ++#define rb_color(r) ((r)->rb_parent_color & 1) ++#define rb_is_red(r) (!rb_color(r)) ++#define rb_is_black(r) rb_color(r) ++#define rb_set_red(r) do { (r)->rb_parent_color &= ~1; } while (0) ++#define rb_set_black(r) do { (r)->rb_parent_color |= 1; } while (0) ++ ++static inline void rb_set_parent(struct rb_node *rb, struct rb_node *p) ++{ ++ rb->rb_parent_color = (rb->rb_parent_color & 3) | (unsigned long)p; ++} ++static inline void rb_set_color(struct rb_node *rb, int color) ++{ ++ rb->rb_parent_color = (rb->rb_parent_color & ~1) | color; ++} ++ ++#define RB_ROOT (struct rb_root) { NULL, } ++#define rb_entry(ptr, type, member) container_of(ptr, type, member) ++ ++#define RB_EMPTY_ROOT(root) ((root)->rb_node == NULL) ++#define RB_EMPTY_NODE(node) (rb_parent(node) == node) ++#define RB_CLEAR_NODE(node) (rb_set_parent(node, node)) ++ ++extern void rb_insert_color(struct rb_node *, struct rb_root *); ++extern void rb_erase(struct rb_node *, struct rb_root *); ++ ++/* Find logical next and previous nodes in a tree */ ++extern struct rb_node *rb_next(const struct rb_node *); ++extern struct rb_node *rb_prev(const struct rb_node *); ++extern struct rb_node *rb_first(const struct rb_root *); ++extern struct rb_node *rb_last(const struct rb_root *); ++ ++/* Fast replacement of a single node without remove/rebalance/add/rebalance */ ++extern void rb_replace_node(struct rb_node *victim, struct rb_node *new, ++ struct rb_root *root); ++ ++static inline void rb_link_node(struct rb_node * node, struct rb_node * parent, ++ struct rb_node ** rb_link) ++{ ++ node->rb_parent_color = (unsigned long )parent; ++ node->rb_left = node->rb_right = NULL; ++ ++ *rb_link = node; ++} ++ ++#endif /* _LINUX_RBTREE_H */ ++ +-- +2.19.1 + diff --git a/bugfix-fix-fd-check.patch b/bugfix-fix-fd-check.patch new file mode 100644 index 0000000..6c81cb8 --- /dev/null +++ b/bugfix-fix-fd-check.patch @@ -0,0 +1,18 @@ +From d59e4d224b3271cf7a7fe53cd7c5d539b58eac32 Mon Sep 17 00:00:00 2001 +From: lvying +Date: Sat, 26 Jan 2019 15:54:17 +0800 +Subject: [PATCH] rasdaemon:fix fd check + +reason:fix fd check + +--- rasdaemon-0.4.1/ras-events.c 2018-04-12 04:05:05.000000000 -0400 ++++ rasdaemon-0.4.1/ras-events.c 2018-04-12 04:11:44.000000000 -0400 +@@ -544,7 +544,7 @@ + + /* Select uptime tracing */ + fd = open_trace(ras, "trace_clock", O_WRONLY); +- if (!fd) { ++ if (fd < 0) { + log(TERM, LOG_ERR, + "Kernel didn't allow writing to trace_clock\n"); + return 0; diff --git a/bugfix-ras-events-memory-leak.patch b/bugfix-ras-events-memory-leak.patch new file mode 100644 index 0000000..e78651f --- /dev/null +++ b/bugfix-ras-events-memory-leak.patch @@ -0,0 +1,18 @@ +From d59e4d224b3271cf7a7fe53cd7c5d539b58eac32 Mon Sep 17 00:00:00 2001 +From: lvying +Date: Sat, 26 Jan 2019 15:54:17 +0800 +Subject: [PATCH] rasdaemon:fix ras events memory leak + +reason:fix ras events memory leak + +diff -uprN a/ras-events.c b/ras-events.c +--- a/ras-events.c 2018-06-22 14:20:42.880878700 +0800 ++++ b/ras-events.c 2018-06-22 14:38:24.420726900 +0800 +@@ -262,6 +262,7 @@ static void parse_ras_data(struct pthrea + fflush(stdout); + pevent_print_event(pdata->ras->pevent, &s, &record); + trace_seq_do_printf(&s); ++ trace_seq_destroy(&s); + printf("\n"); + } + diff --git a/bugfix-rasdaemon-wait-for-file-access.patch b/bugfix-rasdaemon-wait-for-file-access.patch new file mode 100644 index 0000000..2991e98 --- /dev/null +++ b/bugfix-rasdaemon-wait-for-file-access.patch @@ -0,0 +1,50 @@ +From d59e4d224b3271cf7a7fe53cd7c5d539b58eac32 Mon Sep 17 00:00:00 2001 +From: lvying +Date: Sat, 26 Jan 2019 15:54:17 +0800 +Subject: [PATCH] rasdaemon:fix rasdaemon wait for file access + +reason:fix fix rasdaemon wait for file access + +--- rasdaemon-0.4.1/ras-events.c 2018-04-08 04:05:18.755000000 -0400 ++++ rasdaemon-0.4.1/ras-events.c 2018-04-08 04:05:46.879000000 -0400 +@@ -89,15 +89,39 @@ + return ENOENT; + } + ++static int wait_access(char *path, int ms) ++{ ++ int i; ++ for (i = 0; i < ms; i++) { ++ if (access(path, F_OK) == 0) ++ return 0; ++ usleep(1000); ++ } ++ ++ log(ALL, LOG_WARNING, "wait_access() failed, %s not created in %d ms\n", path, ms); ++ return -1; ++} ++ + static int open_trace(struct ras_events *ras, char *name, int flags) + { ++ int ret = 0; + char fname[MAX_PATH + 1]; + + strcpy(fname, ras->tracing); + strcat(fname, "/"); + strcat(fname, name); + +- return open(fname, flags); ++ ret = wait_access(fname, 100); ++ if (ret != 0) { ++ /* use -1 to keep same error value with open() */ ++ return -1; ++ } ++ ++ ret = open(fname, flags); ++ if (ret == -1) ++ log(ALL, LOG_WARNING, "open_trace()->open() failed, fname=%s ret=%d errno=%d\n", fname, ret, errno); ++ ++ return ret; + } + + static int get_tracing_dir(struct ras_events *ras) diff --git a/feature-mc-support-page-isolation.patch b/feature-mc-support-page-isolation.patch new file mode 100644 index 0000000..80a5a1d --- /dev/null +++ b/feature-mc-support-page-isolation.patch @@ -0,0 +1,524 @@ +From 35b8410151f253f2c924ebd15feb1b601da9167c Mon Sep 17 00:00:00 2001 +From: lvying +Date: Sat, 26 Jan 2019 15:22:29 +0800 +Subject: [PATCH] rasdaemon:mc support page isolation + +reason: mc support page isolation +--- + Makefile.am | 4 +- + misc/rasdaemon.env | 29 ++++ + misc/rasdaemon.service.in | 1 + + ras-events.c | 4 + + ras-mc-handler.c | 5 + + ras-page-isolation.c | 308 ++++++++++++++++++++++++++++++++++++++ + ras-page-isolation.h | 68 +++++++++ + 7 files changed, 417 insertions(+), 2 deletions(-) + create mode 100644 misc/rasdaemon.env + create mode 100644 ras-page-isolation.c + create mode 100644 ras-page-isolation.h + +diff --git a/Makefile.am b/Makefile.am +index 2ff742d..6fc39f2 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -17,7 +17,7 @@ all-local: $(SYSTEMD_SERVICES) + + sbin_PROGRAMS = rasdaemon + rasdaemon_SOURCES = rasdaemon.c ras-events.c ras-mc-handler.c \ +- bitfield.c rbtree.c ++ bitfield.c rbtree.c ras-page-isolation.c + if WITH_SQLITE3 + rasdaemon_SOURCES += ras-record.c + endif +@@ -59,7 +59,7 @@ rasdaemon_LDADD = -lpthread $(SQLITE3_LIBS) libtrace/libtrace.a + include_HEADERS = config.h ras-events.h ras-logger.h ras-mc-handler.h \ + ras-aer-handler.h ras-mce-handler.h ras-record.h bitfield.h ras-report.h \ + ras-extlog-handler.h ras-arm-handler.h ras-non-standard-handler.h \ +- ras-devlink-handler.h ras-diskerror-handler.h rbtree.h ++ ras-devlink-handler.h ras-diskerror-handler.h rbtree.h ras-page-isolation.h + + # This rule can't be called with more than one Makefile job (like make -j8) + # I can't figure out a way to fix that +diff --git a/misc/rasdaemon.env b/misc/rasdaemon.env +new file mode 100644 +index 0000000..c327353 +--- /dev/null ++++ b/misc/rasdaemon.env +@@ -0,0 +1,29 @@ ++# Page Isolation ++# Note: Run-time configuration is unsupported, service restart needed. ++ ++# Specify the threshold of isolating buggy pages. ++# ++# Format: ++# [0-9]+[unit] ++# WARNING: please make sure perfectly match this format. ++# ++# Supported units: ++# PAGE_CE_REFRESH_CYCLE: D|d (day), H|h (hour), M|m (min), default is in hour ++# PAGE_CE_THRESHOLD: K|k (x1000), M|m (x1000k), default is none ++# ++# The two configs will only take no effect when PAGE_CE_ACTION is "off". ++PAGE_CE_REFRESH_CYCLE="24h" ++PAGE_CE_THRESHOLD="50" ++ ++# Specify the internal action in rasdaemon to exceeding a page error threshold. ++# ++# off no action ++# account only account errors ++# soft try to soft-offline page without killing any processes ++# This requires an uptodate kernel. Might not be successfull. ++# hard try to hard-offline page by killing processes ++# Requires an uptodate kernel. Might not be successfull. ++# soft-then-hard First try to soft offline, then try hard offlining. ++# Note: default offline choice is "soft". ++PAGE_CE_ACTION="soft" ++ +diff --git a/misc/rasdaemon.service.in b/misc/rasdaemon.service.in +index be9ad5a..e73a08a 100644 +--- a/misc/rasdaemon.service.in ++++ b/misc/rasdaemon.service.in +@@ -3,6 +3,7 @@ Description=RAS daemon to log the RAS events + After=syslog.target + + [Service] ++EnvironmentFile=/etc/sysconfig/rasdaemon + ExecStart=@sbindir@/rasdaemon -f -r + ExecStartPost=@sbindir@/rasdaemon --enable + ExecStop=@sbindir@/rasdaemon --disable +diff --git a/ras-events.c b/ras-events.c +index 4cc2cee..70b02e5 100644 +--- a/ras-events.c ++++ b/ras-events.c +@@ -37,6 +37,7 @@ + #include "ras-diskerror-handler.h" + #include "ras-record.h" + #include "ras-logger.h" ++#include "ras-page-isolation.h" + + /* + * Polling time, if read() doesn't block. Currently, trace_pipe_raw never +@@ -760,6 +761,9 @@ int handle_ras_events(int record_events) + ras->page_size = page_size; + ras->record_events = record_events; + ++ /* FIXME: enable memory isolation unconditionally */ ++ ras_page_account_init(); ++ + rc = add_event_handler(ras, pevent, page_size, "ras", "mc_event", + ras_mc_event_handler, NULL, MC_EVENT); + if (!rc) +diff --git a/ras-mc-handler.c b/ras-mc-handler.c +index deb7e05..bfbe1ef 100644 +--- a/ras-mc-handler.c ++++ b/ras-mc-handler.c +@@ -23,6 +23,7 @@ + #include "ras-mc-handler.h" + #include "ras-record.h" + #include "ras-logger.h" ++#include "ras-page-isolation.h" + #include "ras-report.h" + + int ras_mc_event_handler(struct trace_seq *s, +@@ -183,6 +184,10 @@ int ras_mc_event_handler(struct trace_seq *s, + + ras_store_mc_event(ras, &ev); + ++ /* Account page corrected errors */ ++ if (!strcmp(ev.error_type, "Corrected")) ++ ras_record_page_error(ev.address, ev.error_count, now); ++ + #ifdef HAVE_ABRT_REPORT + /* Report event to ABRT */ + ras_report_mc_event(ras, &ev); +diff --git a/ras-page-isolation.c b/ras-page-isolation.c +new file mode 100644 +index 0000000..1bd04e4 +--- /dev/null ++++ b/ras-page-isolation.c +@@ -0,0 +1,308 @@ ++/* ++ * Copyright (C) 2015 Yun Wu (Abel) ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++*/ ++ ++#include ++#include ++#include ++#include ++#include ++#include "ras-logger.h" ++#include "ras-page-isolation.h" ++ ++static const struct config threshold_units[] = { ++ { "m", 1000 }, ++ { "k", 1000 }, ++ { "", 1 }, ++ {} ++}; ++ ++static const struct config cycle_units[] = { ++ { "d", 24 }, ++ { "h", 60 }, ++ { "m", 60 }, ++ {} ++}; ++ ++static struct isolation threshold = { ++ .name = "PAGE_CE_THRESHOLD", ++ .units = threshold_units, ++ .env = "50", ++ .unit = "", ++}; ++ ++static struct isolation cycle = { ++ .name = "PAGE_CE_REFRESH_CYCLE", ++ .units = cycle_units, ++ .env = "24h", ++ .unit = "h", ++}; ++ ++static const char *kernel_offline[] = { ++ [OFFLINE_SOFT] = "/sys/devices/system/memory/soft_offline_page", ++ [OFFLINE_HARD] = "/sys/devices/system/memory/hard_offline_page", ++ [OFFLINE_SOFT_THEN_HARD] = "/sys/devices/system/memory/soft_offline_page", ++}; ++ ++static const struct config offline_choice[] = { ++ { "off", OFFLINE_OFF }, ++ { "account", OFFLINE_ACCOUNT }, ++ { "soft", OFFLINE_SOFT }, ++ { "hard", OFFLINE_HARD }, ++ { "soft-then-hard", OFFLINE_SOFT_THEN_HARD }, ++ {} ++}; ++ ++static const char *page_state[] = { ++ [PAGE_ONLINE] = "online", ++ [PAGE_OFFLINE] = "offlined", ++ [PAGE_OFFLINE_FAILED] = "offline-failed", ++}; ++ ++static enum otype offline = OFFLINE_SOFT; ++static struct rb_root page_records; ++ ++static void page_offline_init(void) ++{ ++ const char *env = "PAGE_CE_ACTION"; ++ char *choice = getenv(env); ++ const struct config *c = NULL; ++ int matched = 0; ++ ++ if (choice) { ++ for (c = offline_choice; c->name; c++) { ++ if (!strcasecmp(choice, c->name)) { ++ offline = c->val; ++ matched = 1; ++ break; ++ } ++ } ++ } ++ ++ if (!matched) ++ log(TERM, LOG_INFO, "Improper %s, set to default soft\n", env); ++ ++ if (offline > OFFLINE_ACCOUNT && access(kernel_offline[offline], W_OK)) { ++ log(TERM, LOG_INFO, "Kernel does not support page offline interface\n"); ++ offline = OFFLINE_ACCOUNT; ++ } ++ ++ log(TERM, LOG_INFO, "Page offline choice on Corrected Errors is %s\n", ++ offline_choice[offline].name); ++} ++ ++static void parse_isolation_env(struct isolation *config) ++{ ++ char *env = getenv(config->name), *unit = NULL; ++ const struct config *units = NULL; ++ unsigned long value; ++ int no_unit, unit_matched; ++ int last, i; ++ ++reparse: ++ /* Start a new round */ ++ no_unit = unit_matched = 0; ++ ++ /* Environments could be un-configured */ ++ if (!env || !strlen(env)) ++ goto use_default; ++ ++ /* Index of the last char of environment */ ++ last = strlen(env) - 1; ++ unit = env + last; ++ if (isdigit(*unit)) { ++ unit = config->unit; ++ no_unit = 1; ++ } ++ ++ /* Only decimal digit can be accepted */ ++ for (i = 0; i < last; i++) { ++ if (!isdigit(env[i])) ++ goto use_default; ++ } ++ ++ /* Check if value is valid or not */ ++ if (sscanf(env, "%lu", &value) < 1 || !value) ++ goto use_default; ++ ++ for (units = config->units; units->name; units++) { ++ if (!strcasecmp(unit, units->name)) ++ unit_matched = 1; ++ if (unit_matched) ++ value *= units->val; ++ } ++ ++ /* Improper unit */ ++ if (!unit_matched) ++ goto use_default; ++ ++ config->env = env; ++ config->val = value; ++ config->unit = no_unit ? unit : ""; ++ return; ++ ++use_default: ++ log(TERM, LOG_INFO, "Improper %s, set to default %s.\n", ++ config->name, config->env); ++ ++ env = config->env; ++ goto reparse; ++} ++ ++static void page_isolation_init(void) ++{ ++ /** ++ * It's unnecessary to parse threshold configuration when offline ++ * choice is off. ++ */ ++ if (offline == OFFLINE_OFF) ++ return; ++ ++ parse_isolation_env(&threshold); ++ parse_isolation_env(&cycle); ++ log(TERM, LOG_INFO, "Threshold of memory Corrected Errors is %s%s / %s%s\n", ++ threshold.env, threshold.unit, cycle.env, cycle.unit); ++} ++ ++void ras_page_account_init(void) ++{ ++ page_offline_init(); ++ page_isolation_init(); ++} ++ ++static int do_page_offline(unsigned long long addr, enum otype type) ++{ ++ FILE *offline_file; ++ int err; ++ ++ offline_file = fopen(kernel_offline[type], "w"); ++ if (!offline_file) ++ return -1; ++ ++ fprintf(offline_file, "%#llx", addr); ++ err = ferror(offline_file) ? -1 : 0; ++ fclose(offline_file); ++ ++ return err; ++} ++ ++static void page_offline(struct page_record *pr) ++{ ++ unsigned long long addr = pr->addr; ++ int ret; ++ ++ /* Offlining page is not required */ ++ if (offline <= OFFLINE_ACCOUNT) ++ return; ++ ++ /* Ignore offlined pages */ ++ if (pr->offlined != PAGE_ONLINE) ++ return; ++ ++ /* Time to silence this noisy page */ ++ if (offline == OFFLINE_SOFT_THEN_HARD) { ++ ret = do_page_offline(addr, OFFLINE_SOFT); ++ if (ret < 0) ++ ret = do_page_offline(addr, OFFLINE_HARD); ++ } else { ++ ret = do_page_offline(addr, offline); ++ } ++ ++ pr->offlined = ret < 0 ? PAGE_OFFLINE_FAILED : PAGE_OFFLINE; ++ ++ log(TERM, LOG_INFO, "Result of offlining page at %#llx: %s\n", ++ addr, page_state[pr->offlined]); ++} ++ ++static void page_record(struct page_record *pr, unsigned count, time_t time) ++{ ++ unsigned long period = time - pr->start; ++ unsigned long tolerate; ++ ++ if (period >= cycle.val) { ++ /** ++ * Since we don't refresh automatically, it is possible that the period ++ * between two occurences longer than the pre-configured refresh cycle. ++ * In this case, we tolerate the frequency of the whole period up to ++ * the pre-configured threshold. ++ */ ++ tolerate = (period / (double)cycle.val) * threshold.val; ++ pr->count -= (tolerate > pr->count) ? pr->count : tolerate; ++ pr->start = time; ++ pr->excess = 0; ++ } ++ ++ pr->count += count; ++ if (pr->count >= threshold.val) { ++ log(TERM, LOG_INFO, "Corrected Errors at %#llx exceed threshold\n", pr->addr); ++ ++ /** ++ * Backup ce count of current cycle to enable next round, which actually ++ * should never happen if we can disable overflow completely in the same ++ * time unit (but sadly we can't). ++ */ ++ pr->excess += pr->count; ++ pr->count = 0; ++ page_offline(pr); ++ } ++} ++ ++static struct page_record *page_lookup_insert(unsigned long long addr) ++{ ++ struct rb_node **entry = &page_records.rb_node; ++ struct rb_node *parent = NULL; ++ struct page_record *pr = NULL, *find = NULL; ++ ++ while (*entry) { ++ parent = *entry; ++ pr = rb_entry(parent, struct page_record, entry); ++ if (addr == pr->addr) { ++ return pr; ++ } else if (addr < pr->addr) { ++ entry = &(*entry)->rb_left; ++ } else { ++ entry = &(*entry)->rb_right; ++ } ++ } ++ ++ find = calloc(1, sizeof(struct page_record)); ++ if (!find) { ++ log(TERM, LOG_ERR, "No memory for page records\n"); ++ return NULL; ++ } ++ ++ find->addr = addr; ++ rb_link_node(&find->entry, parent, entry); ++ rb_insert_color(&find->entry, &page_records); ++ ++ return find; ++} ++ ++void ras_record_page_error(unsigned long long addr, unsigned count, time_t time) ++{ ++ struct page_record *pr = NULL; ++ ++ if (offline == OFFLINE_OFF) ++ return; ++ ++ pr = page_lookup_insert(addr & PAGE_MASK); ++ if (pr) { ++ if (!pr->start) ++ pr->start = time; ++ page_record(pr, count, time); ++ } ++} +diff --git a/ras-page-isolation.h b/ras-page-isolation.h +new file mode 100644 +index 0000000..6aefa1e +--- /dev/null ++++ b/ras-page-isolation.h +@@ -0,0 +1,68 @@ ++/* ++ * Copyright (C) 2015 Yun Wu (Abel) ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++*/ ++ ++#ifndef __RAS_PAGE_ISOLATION_H ++#define __RAS_PAGE_ISOLATION_H ++ ++#include ++#include "rbtree.h" ++ ++#define PAGE_SHIFT 12 ++#define PAGE_SIZE (1 << PAGE_SHIFT) ++#define PAGE_MASK (~(PAGE_SIZE-1)) ++ ++struct config { ++ char *name; ++ int val; ++}; ++ ++enum otype { ++ OFFLINE_OFF, ++ OFFLINE_ACCOUNT, ++ OFFLINE_SOFT, ++ OFFLINE_HARD, ++ OFFLINE_SOFT_THEN_HARD, ++}; ++ ++enum pstate { ++ PAGE_ONLINE, ++ PAGE_OFFLINE, ++ PAGE_OFFLINE_FAILED, ++}; ++ ++struct page_record { ++ struct rb_node entry; ++ unsigned long long addr; ++ time_t start; ++ enum pstate offlined; ++ unsigned long count; ++ unsigned long excess; ++}; ++ ++struct isolation { ++ char *name; ++ char *env; ++ const struct config *units; ++ unsigned long val; ++ char *unit; ++}; ++ ++void ras_page_account_init(void); ++void ras_record_page_error(unsigned long long addr, unsigned count, time_t time); ++ ++#endif +-- +2.19.1 + diff --git a/feature-report-ARM-processor-info.patch b/feature-report-ARM-processor-info.patch new file mode 100644 index 0000000..0fde36b --- /dev/null +++ b/feature-report-ARM-processor-info.patch @@ -0,0 +1,367 @@ +From 5ae4ad1d71e931fa1639f605c83a0313f641c282 Mon Sep 17 00:00:00 2001 +From: lvying +Date: Wed, 24 Apr 2019 17:50:57 +0800 +Subject: [PATCH] rasdaemon:report ARM processor info + +reason: report ARM processor info + +Signed-off-by: lvying +--- + Makefile.am | 4 +- + ras-arm-ctx-handler.c | 75 ++++++++++++++++++++++++++++++ + ras-arm-ctx-handler.h | 23 +++++++++ + ras-arm-error-info-handler.c | 90 ++++++++++++++++++++++++++++++++++++ + ras-arm-error-info-handler.h | 23 +++++++++ + ras-events.c | 18 ++++++++ + ras-events.h | 2 + + ras-record.h | 19 ++++++++ + 8 files changed, 252 insertions(+), 2 deletions(-) + create mode 100644 ras-arm-ctx-handler.c + create mode 100644 ras-arm-ctx-handler.h + create mode 100644 ras-arm-error-info-handler.c + create mode 100644 ras-arm-error-info-handler.h + +diff --git a/Makefile.am b/Makefile.am +index 6fc39f2..52cd1a2 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -28,7 +28,7 @@ if WITH_NON_STANDARD + rasdaemon_SOURCES += ras-non-standard-handler.c + endif + if WITH_ARM +- rasdaemon_SOURCES += ras-arm-handler.c ++ rasdaemon_SOURCES += ras-arm-handler.c ras-arm-error-info-handler.c ras-arm-ctx-handler.c + endif + if WITH_MCE + rasdaemon_SOURCES += ras-mce-handler.c mce-intel.c mce-amd.c \ +@@ -59,7 +59,7 @@ rasdaemon_LDADD = -lpthread $(SQLITE3_LIBS) libtrace/libtrace.a + include_HEADERS = config.h ras-events.h ras-logger.h ras-mc-handler.h \ + ras-aer-handler.h ras-mce-handler.h ras-record.h bitfield.h ras-report.h \ + ras-extlog-handler.h ras-arm-handler.h ras-non-standard-handler.h \ +- ras-devlink-handler.h ras-diskerror-handler.h rbtree.h ras-page-isolation.h ++ ras-devlink-handler.h ras-diskerror-handler.h rbtree.h ras-page-isolation.h ras-arm-ctx-handler.h ras-arm-error-info-handler.h + + # This rule can't be called with more than one Makefile job (like make -j8) + # I can't figure out a way to fix that +diff --git a/ras-arm-ctx-handler.c b/ras-arm-ctx-handler.c +new file mode 100644 +index 0000000..4abe3a8 +--- /dev/null ++++ b/ras-arm-ctx-handler.c +@@ -0,0 +1,75 @@ ++/* ++ * Copyright (c) 2016, The Linux Foundation. All rights reserved. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 and ++ * only version 2 as published by the Free Software Foundation. ++ ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ */ ++ ++#include ++#include ++#include ++#include ++#include "libtrace/kbuffer.h" ++#include "ras-arm-ctx-handler.h" ++#include "ras-record.h" ++#include "ras-logger.h" ++#include "ras-report.h" ++ ++int ras_arm_ctx_handler(struct trace_seq *s, ++ struct pevent_record *record, ++ struct event_format *event, void *context) ++{ ++ unsigned long long val; ++ struct ras_events *ras = context; ++ struct ras_arm_ctx_event ev; ++ time_t now; ++ struct tm *tm = NULL; ++ int len; ++ ++ memset(&ev, 0, sizeof(ev)); ++ ++ /* ++ * Newer kernels (3.10-rc1 or upper) provide an uptime clock. ++ * On previous kernels, the way to properly generate an event would ++ * be to inject a fake one, measure its timestamp and diff it against ++ * gettimeofday. We won't do it here. Instead, let's use uptime, ++ * falling-back to the event report's time, if "uptime" clock is ++ * not available (legacy kernels). ++ */ ++ ++ if (ras->use_uptime) ++ now = record->ts/user_hz + ras->uptime_diff; ++ else ++ now = time(NULL); ++ ++ tm = localtime(&now); ++ if (tm) ++ strftime(ev.timestamp, sizeof(ev.timestamp), ++ "%Y-%m-%d %H:%M:%S %z", tm); ++ ++ if (pevent_get_field_val(s, event, "index", record, &val, 1) < 0) ++ return -1; ++ ev.index = val; ++ trace_seq_printf(s, " Context info structure %d:", ev.index); ++ ++ ev.processor_ctx_info = pevent_get_field_raw(s, event, "processor_ctx_info", record, &len, 1); ++ if (!ev.processor_ctx_info) ++ return -1; ++ ++ if (*ev.processor_ctx_info) { ++ trace_seq_puts(s, "\n"); ++ trace_seq_puts(s, ev.processor_ctx_info); ++ } ++ ++ // TODO: how to design this table: related to ARM event table or sperated table? ++ ++ // TODO: report to ABRT ++ ++ return 0; ++} +diff --git a/ras-arm-ctx-handler.h b/ras-arm-ctx-handler.h +new file mode 100644 +index 0000000..d23a142 +--- /dev/null ++++ b/ras-arm-ctx-handler.h +@@ -0,0 +1,23 @@ ++/* ++ * Copyright (c) 2016, The Linux Foundation. All rights reserved. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 and ++ * only version 2 as published by the Free Software Foundation. ++ ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ */ ++ ++#ifndef __RAS_ARM_CTX_HANDLER_H ++#define __RAS_ARM_CTX_HANDLER_H ++ ++#include "ras-events.h" ++#include "libtrace/event-parse.h" ++ ++int ras_arm_ctx_handler(struct trace_seq *s, ++ struct pevent_record *record, ++ struct event_format *event, void *context); ++#endif +diff --git a/ras-arm-error-info-handler.c b/ras-arm-error-info-handler.c +new file mode 100644 +index 0000000..afafe89 +--- /dev/null ++++ b/ras-arm-error-info-handler.c +@@ -0,0 +1,90 @@ ++/* ++ * Copyright (c) 2016, The Linux Foundation. All rights reserved. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 and ++ * only version 2 as published by the Free Software Foundation. ++ ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ */ ++ ++#include ++#include ++#include ++#include ++#include "libtrace/kbuffer.h" ++#include "ras-arm-error-info-handler.h" ++#include "ras-record.h" ++#include "ras-logger.h" ++#include "ras-report.h" ++ ++int ras_arm_error_info_handler(struct trace_seq *s, ++ struct pevent_record *record, ++ struct event_format *event, void *context) ++{ ++ unsigned long long val; ++ struct ras_events *ras = context; ++ struct ras_arm_err_info_event ev; ++ time_t now; ++ struct tm *tm = NULL; ++ int len; ++ ++ memset(&ev, 0, sizeof(ev)); ++ ++ /* ++ * Newer kernels (3.10-rc1 or upper) provide an uptime clock. ++ * On previous kernels, the way to properly generate an event would ++ * be to inject a fake one, measure its timestamp and diff it against ++ * gettimeofday. We won't do it here. Instead, let's use uptime, ++ * falling-back to the event report's time, if "uptime" clock is ++ * not available (legacy kernels). ++ */ ++ ++ if (ras->use_uptime) ++ now = record->ts/user_hz + ras->uptime_diff; ++ else ++ now = time(NULL); ++ ++ tm = localtime(&now); ++ if (tm) ++ strftime(ev.timestamp, sizeof(ev.timestamp), ++ "%Y-%m-%d %H:%M:%S %z", tm); ++ ++ if (pevent_get_field_val(s, event, "index", record, &val, 1) < 0) ++ return -1; ++ ev.index = val; ++ trace_seq_printf(s, " Error info structure %d:", ev.index); ++ ++ if (pevent_get_field_val(s, event, "multiplie_error", record, &val, 1) < 0) ++ return -1; ++ ev.multiplie_error = val; ++ trace_seq_printf(s, "\n num errors: %d", ev.multiplie_error); ++ ++ ev.processor_error_info = pevent_get_field_raw(s, event, "processor_error_info", record, &len, 1); ++ if (!ev.processor_error_info) ++ return -1; ++ ++ if (*ev.processor_error_info) { ++ trace_seq_puts(s, "\n"); ++ trace_seq_puts(s, ev.processor_error_info); ++ } ++ ++ if (pevent_get_field_val(s, event, "va", record, &val, 1) < 0) ++ return -1; ++ ev.va = val; ++ trace_seq_printf(s, "\n virtual fault address: 0x%lx", ev.va); ++ ++ if (pevent_get_field_val(s, event, "pa", record, &val, 1) < 0) ++ return -1; ++ ev.pa = val; ++ trace_seq_printf(s, "\n physical fault address: 0x%lx", ev.pa); ++ ++ // TODO: how to design this table: related to ARM event table or sperated table? ++ ++ // TODO: report to ABRT ++ ++ return 0; ++} +diff --git a/ras-arm-error-info-handler.h b/ras-arm-error-info-handler.h +new file mode 100644 +index 0000000..9680989 +--- /dev/null ++++ b/ras-arm-error-info-handler.h +@@ -0,0 +1,23 @@ ++/* ++ * Copyright (c) 2016, The Linux Foundation. All rights reserved. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 and ++ * only version 2 as published by the Free Software Foundation. ++ ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ */ ++ ++#ifndef __RAS_ARM_ERROR_INFO_HANDLER_H ++#define __RAS_ARM_ERROR_INFO_HANDLER_H ++ ++#include "ras-events.h" ++#include "libtrace/event-parse.h" ++ ++int ras_arm_error_info_handler(struct trace_seq *s, ++ struct pevent_record *record, ++ struct event_format *event, void *context); ++#endif +diff --git a/ras-events.c b/ras-events.c +index 70b02e5..a8f7fe9 100644 +--- a/ras-events.c ++++ b/ras-events.c +@@ -27,6 +27,8 @@ + #include + #include "libtrace/kbuffer.h" + #include "libtrace/event-parse.h" ++#include "ras-arm-error-info-handler.h" ++#include "ras-arm-ctx-handler.h" + #include "ras-mc-handler.h" + #include "ras-aer-handler.h" + #include "ras-non-standard-handler.h" +@@ -800,6 +802,22 @@ int handle_ras_events(int record_events) + else + log(ALL, LOG_ERR, "Can't get traces from %s:%s\n", + "ras", "arm_event"); ++ ++ rc = add_event_handler(ras, pevent, page_size, "ras", "arm_err_info_event", ++ ras_arm_error_info_handler, NULL, ARM_ERR_INFO_EVENT); ++ if (!rc) ++ num_events++; ++ else ++ log(ALL, LOG_ERR, "Can't get traces from %s:%s\n", ++ "ras", "arm_err_info_event"); ++ ++ rc = add_event_handler(ras, pevent, page_size, "ras", "arm_ctx_event", ++ ras_arm_ctx_handler, NULL, ARM_CTX_EVENT); ++ if (!rc) ++ num_events++; ++ else ++ log(ALL, LOG_ERR, "Can't get traces from %s:%s\n", ++ "ras", "arm_ctx_event"); + #endif + + cpus = get_num_cpus(ras); +diff --git a/ras-events.h b/ras-events.h +index f028741..6accdd1 100644 +--- a/ras-events.h ++++ b/ras-events.h +@@ -38,6 +38,8 @@ enum { + EXTLOG_EVENT, + DEVLINK_EVENT, + DISKERROR_EVENT, ++ ARM_ERR_INFO_EVENT, ++ ARM_CTX_EVENT, + NR_EVENTS + }; + +diff --git a/ras-record.h b/ras-record.h +index 5311c67..b7d7436 100644 +--- a/ras-record.h ++++ b/ras-record.h +@@ -94,11 +94,30 @@ struct diskerror_event { + const char *cmd; + }; + ++struct ras_arm_err_info_event ++{ ++ char timestamp[64]; ++ uint32_t index; ++ uint16_t multiplie_error; ++ uint64_t va; ++ uint64_t pa; ++ const char *processor_error_info; ++}; ++ ++struct ras_arm_ctx_event ++{ ++ char timestamp[64]; ++ uint32_t index; ++ const char *processor_ctx_info; ++}; ++ + struct ras_mc_event; + struct ras_aer_event; + struct ras_extlog_event; + struct ras_non_standard_event; + struct ras_arm_event; ++struct ras_arm_err_info_event; ++struct ras_arm_ctx_event; + struct mce_event; + struct devlink_event; + struct diskerror_event; +-- +2.19.1 + diff --git a/output-log-timely.patch b/output-log-timely.patch new file mode 100644 index 0000000..bd98453 --- /dev/null +++ b/output-log-timely.patch @@ -0,0 +1,27 @@ +From e426fef8949c4bd7a4e3ebca84db95a0c90fc918 Mon Sep 17 00:00:00 2001 +From: Ying Lv +Date: Mon, 13 May 2019 06:00:40 +0800 +Subject: [PATCH] rasdaemon:output log timely + +reason: output log timely + +Signed-off-by: Ying Lv +--- + ras-events.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/ras-events.c b/ras-events.c +index 615550c..f32d512 100644 +--- a/ras-events.c ++++ b/ras-events.c +@@ -301,6 +301,7 @@ static void parse_ras_data(struct pthread_data *pdata, struct kbuffer *kbuf, + trace_seq_do_printf(&s); + trace_seq_destroy(&s); + printf("\n"); ++ fflush(stdout); + } + + static int get_num_cpus(struct ras_events *ras) +-- +1.8.3.1 + diff --git a/rasdaemon-0.6.3.tar.gz b/rasdaemon-0.6.3.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..d3d9073581f9a589ad591f52c46d48725c7974a4 GIT binary patch literal 134127 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 z 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 RJd1~){|9Lqz77C*3IMC6d%gew literal 0 HcmV?d00001 diff --git a/rasdaemon.spec b/rasdaemon.spec new file mode 100644 index 0000000..0ce9cd0 --- /dev/null +++ b/rasdaemon.spec @@ -0,0 +1,77 @@ +Name: rasdaemon +Version: 0.6.3 +Release: 1 +License: GPLv2 +Summary: Utility to get Platform Reliability, Availability and Serviceability (RAS) reports via the Kernel tracing events +URL: https://github.com/mchehab/rasdaemon.git +Source0: %{name}-%{version}.tar.gz + +ExcludeArch: s390 s390x +BuildRequires: gcc, gettext-devel, perl-generators, sqlite-devel, systemd, git, libtool +Provides: bundled(kernel-event-lib) +Requires: hwdata +Requires: perl-DBD-SQLite +%ifarch %{ix86} x86_64 +Requires: dmidecode +%endif + +Requires(post): systemd +Requires(preun): systemd +Requires(postun): systemd + +Patch6000: add-rbtree-support-for-page-record.patch + +Patch9000: bugfix-ras-events-memory-leak.patch +Patch9001: bugfix-rasdaemon-wait-for-file-access.patch +Patch9002: bugfix-fix-fd-check.patch +Patch9003: feature-mc-support-page-isolation.patch +Patch9004: feature-report-ARM-processor-info.patch +Patch9005: output-log-timely.patch + +%description +The rasdaemon program is a daemon which monitors the platform +Reliablity, Availability and Serviceability (RAS) reports from the +Linux kernel trace events. These trace events are logged in +/sys/kernel/debug/tracing, reporting them via syslog/journald. + + +%prep +%autosetup -n %{name}-%{version} -S git + +%build +autoscan +aclocal +autoconf +autoheader +libtoolize --automake --copy --debug --force +automake --add-missing +%ifarch %{arm} aarch64 +%configure --enable-mce --enable-aer --enable-sqlite3 --enable-extlog --enable-abrt-report --enable-devlink --enable-diskerror --enable-non-standard --enable-hisi-ns-decode --enable-arm +%else +%configure --enable-mce --enable-aer --enable-sqlite3 --enable-extlog --enable-abrt-report --enable-devlink --enable-diskerror +%endif +make %{?_smp_mflags} + +%install +make install DESTDIR=%{buildroot} +install -D -p -m 0644 misc/rasdaemon.env %{buildroot}%{_sysconfdir}/sysconfig/%{name} +install -D -p -m 0644 misc/rasdaemon.service %{buildroot}/%{_unitdir}/rasdaemon.service +install -D -p -m 0644 misc/ras-mc-ctl.service %{buildroot}%{_unitdir}/ras-mc-ctl.service +rm INSTALL %{buildroot}/usr/include/*.h + +%files +%doc AUTHORS ChangeLog COPYING README TODO +%{_sbindir}/rasdaemon +%{_sbindir}/ras-mc-ctl +%{_mandir}/*/* +%{_unitdir}/*.service +%{_sharedstatedir}/rasdaemon +%{_sysconfdir}/ras/dimm_labels.d +%config(noreplace) %{_sysconfdir}/sysconfig/%{name} + +%post +/usr/bin/systemctl enable rasdaemon.service >/dev/null 2>&1 || : + +%changelog +* Wed Sep 18 2019 openEuler Buildteam - 0.6.3-1 +- Package init