tree dbe758d65ca8ca90cf5b614947f70a4edd313df8
parent df3093907ccc718459c54c99da29dd774af41186
author Carlos Maiolino <cmaiolino@redhat.com> 1463533604 +1000
committer Dave Chinner <david@fromorbit.com> 1463533604 +1000

xfs: introduce table-based init for error behaviors

Before we start expanding the number of error classes and errors we
can configure behaviour for, we need a simple and clear way to
define the default behaviour that we initialized each mount with.
Introduce a table based method for keeping the initial configuration
in, and apply that to the existing initialization code.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Carlos Maiolino <cmaiolino@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>

