[1] If you're curious enough, one legacy example of memories
implemented on a very different way was Fully Buffered DIMMs
where each DIMM had its own internal chipset to offload
certain tasks, including scrubbing and ECC implementation.
It ended not being succeeded long term, as it required
special DIMMs for server's market, reducing the production
scale, but it is an interesting example about how hardware
designs could be innovative breaking existing paradigms.
The FB-DIMM design actually forced a redesign at the EDAC
subsystem, as it was too centered on how an specific type
of memory controllers.
> +
> +What: /sys/bus/edac/devices/<dev-name>/scrub/name
> +Date: Oct 2024
> +KernelVersion: 6.12
> +Contact: linux-edac@xxxxxxxxxxxxxxx
> +Description:
> + (RO) name of the memory scrubber
> +
> +What: /sys/bus/edac/devices/<dev-name>/scrub/cycle_in_hours_available
> +Date: Oct 2024
> +KernelVersion: 6.12
> +Contact: linux-edac@xxxxxxxxxxxxxxx
> +Description:
> + (RO) Supported range for the scrub cycle in hours by the
> + memory scrubber.
> +
> +What: /sys/bus/edac/devices/<dev-name>/scrub/cycle_in_hours
> +Date: Oct 2024
> +KernelVersion: 6.12
> +Contact: linux-edac@xxxxxxxxxxxxxxx
> +Description:
> + (RW) The scrub cycle in hours specified and it must be with in the
> + supported range by the memory scrubber.
Why specifying it in hours? I would use seconds, as it is easy to
represent one hour as 3600 seconds, but you can't specify a cycle of,
let's say, 30min, if the minimum range value is one hour.
I mean, we never know how technology will evolve nor how manufacturers will
implement support for scrubbing cycle on their chipsets.
> diff --git a/drivers/edac/Makefile b/drivers/edac/Makefile
> index c532b57a6d8a..de56cbd039eb 100644
> --- a/drivers/edac/Makefile
> +++ b/drivers/edac/Makefile
> @@ -10,7 +10,7 @@ obj-$(CONFIG_EDAC) := edac_core.o
>
> edac_core-y := edac_mc.o edac_device.o edac_mc_sysfs.o
> edac_core-y += edac_module.o edac_device_sysfs.o wq.o
> -edac_core-y += edac_ras_feature.o
> +edac_core-y += edac_ras_feature.o edac_scrub.o
>
> edac_core-$(CONFIG_EDAC_DEBUG) += debugfs.o
>
> diff --git a/drivers/edac/edac_ras_feature.c b/drivers/edac/edac_ras_feature.c
> index 24a729fea66f..48927f868372 100755
> --- a/drivers/edac/edac_ras_feature.c
> +++ b/drivers/edac/edac_ras_feature.c
> @@ -36,6 +36,7 @@ static int edac_ras_feat_scrub_init(struct device *parent,
> {
> sdata->ops = sfeat->scrub_ops;
> sdata->private = sfeat->scrub_ctx;
> + attr_groups[0] = edac_scrub_get_desc();
>
> return 1;
> }
> diff --git a/drivers/edac/edac_scrub.c b/drivers/edac/edac_scrub.c
> new file mode 100755
> index 000000000000..0b07eafd3551
> --- /dev/null
> +++ b/drivers/edac/edac_scrub.c
> @@ -0,0 +1,312 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Generic EDAC scrub driver supports controlling the memory
> + * scrubbers in the system and the common sysfs scrub interface
> + * promotes unambiguous access from the userspace.
> + *
> + * Copyright (c) 2024 HiSilicon Limited.
> + */
> +
> +#define pr_fmt(fmt) "EDAC SCRUB: " fmt
> +
> +#include <linux/edac_ras_feature.h>
> +
> +static ssize_t addr_range_base_show(struct device *ras_feat_dev,
> + struct device_attribute *attr,
> + char *buf)
> +{
> + struct edac_ras_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);
> + const struct edac_scrub_ops *ops = ctx->scrub.ops;
> + u64 base, size;
> + int ret;
> +
> + ret = ops->read_range(ras_feat_dev->parent, ctx->scrub.private, &base, &size);
> + if (ret)
> + return ret;
Also a generic comment applied to all devnodes: what if ops->read_range
is NULL? Shouldn't it be checked? Btw, you could use read_range == NULL
if to implement error handling for unsupported features.
> +
> + return sysfs_emit(buf, "0x%llx\n", base);
> +}
> +
> +static ssize_t addr_range_size_show(struct device *ras_feat_dev,
> + struct device_attribute *attr,
> + char *buf)
> +{
> + struct edac_ras_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);
> + const struct edac_scrub_ops *ops = ctx->scrub.ops;
> + u64 base, size;
> + int ret;
> +
> + ret = ops->read_range(ras_feat_dev->parent, ctx->scrub.private, &base, &size);
> + if (ret)
> + return ret;
> +
> + return sysfs_emit(buf, "0x%llx\n", size);
> +}
> +
> +static ssize_t addr_range_base_store(struct device *ras_feat_dev,
> + struct device_attribute *attr,
> + const char *buf, size_t len)
> +{
> + struct edac_ras_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);
> + const struct edac_scrub_ops *ops = ctx->scrub.ops;
> + u64 base, size;
> + int ret;
> +
> + ret = ops->read_range(ras_feat_dev->parent, ctx->scrub.private, &base, &size);
> + if (ret)
> + return ret;
> +
> + ret = kstrtou64(buf, 16, &base);
I would use base 0, letting the parser expect "0x" for hexadecimal values.
Same for other *_store methods.
> + if (ret < 0)
> + return ret;
> +
> + ret = ops->write_range(ras_feat_dev->parent, ctx->scrub.private, base, size);
> + if (ret)
> + return ret;
> +
> + return len;
> +}
> +
> +static ssize_t addr_range_size_store(struct device *ras_feat_dev,
> + struct device_attribute *attr,
> + const char *buf,
> + size_t len)
> +{
> + struct edac_ras_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);
> + const struct edac_scrub_ops *ops = ctx->scrub.ops;
> + u64 base, size;
> + int ret;
> +
> + ret = ops->read_range(ras_feat_dev->parent, ctx->scrub.private, &base, &size);
> + if (ret)
> + return ret;
> +
> + ret = kstrtou64(buf, 16, &size);
> + if (ret < 0)
> + return ret;
> +
> + ret = ops->write_range(ras_feat_dev->parent, ctx->scrub.private, base, size);
> + if (ret)
> + return ret;
> +
> + return len;
> +}
> +
> +static ssize_t enable_background_store(struct device *ras_feat_dev,
> + struct device_attribute *attr,
> + const char *buf, size_t len)
> +{
> + struct edac_ras_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);
> + const struct edac_scrub_ops *ops = ctx->scrub.ops;
> + bool enable;
> + int ret;
> +
> + ret = kstrtobool(buf, &enable);
> + if (ret < 0)
> + return ret;
> +
> + ret = ops->set_enabled_bg(ras_feat_dev->parent, ctx->scrub.private, enable);
> + if (ret)
> + return ret;
> +
> + return len;
> +}
> +
> +static ssize_t enable_background_show(struct device *ras_feat_dev,
> + struct device_attribute *attr, char *buf)
> +{
> + struct edac_ras_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);
> + const struct edac_scrub_ops *ops = ctx->scrub.ops;
> + bool enable;
> + int ret;
> +
> + ret = ops->get_enabled_bg(ras_feat_dev->parent, ctx->scrub.private, &enable);
> + if (ret)
> + return ret;
> +
> + return sysfs_emit(buf, "%d\n", enable);
> +}
> +
> +static ssize_t enable_on_demand_show(struct device *ras_feat_dev,
> + struct device_attribute *attr, char *buf)
> +{
> + struct edac_ras_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);
> + const struct edac_scrub_ops *ops = ctx->scrub.ops;
> + bool enable;
> + int ret;
> +
> + ret = ops->get_enabled_od(ras_feat_dev->parent, ctx->scrub.private, &enable);
> + if (ret)
> + return ret;
> +
> + return sysfs_emit(buf, "%d\n", enable);
> +}
> +
> +static ssize_t enable_on_demand_store(struct device *ras_feat_dev,
> + struct device_attribute *attr,
> + const char *buf, size_t len)
> +{
> + struct edac_ras_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);
> + const struct edac_scrub_ops *ops = ctx->scrub.ops;
> + bool enable;
> + int ret;
> +
> + ret = kstrtobool(buf, &enable);
> + if (ret < 0)
> + return ret;
> +
> + ret = ops->set_enabled_od(ras_feat_dev->parent, ctx->scrub.private, enable);
> + if (ret)
> + return ret;
> +
> + return len;
> +}
> +
> +static ssize_t name_show(struct device *ras_feat_dev,
> + struct device_attribute *attr, char *buf)
> +{
> + struct edac_ras_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);
> + const struct edac_scrub_ops *ops = ctx->scrub.ops;
> + int ret;
> +
> + ret = ops->get_name(ras_feat_dev->parent, ctx->scrub.private, buf);
> + if (ret)
> + return ret;
> +
> + return strlen(buf);
> +}
> +
> +static ssize_t cycle_in_hours_show(struct device *ras_feat_dev, struct device_attribute *attr,
> + char *buf)
> +{
> + struct edac_ras_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);
> + const struct edac_scrub_ops *ops = ctx->scrub.ops;
> + u64 val;
> + int ret;
> +
> + ret = ops->cycle_in_hours_read(ras_feat_dev->parent, ctx->scrub.private, &val);
> + if (ret)
> + return ret;
> +
> + return sysfs_emit(buf, "0x%llx\n", val);
> +}
> +
> +static ssize_t cycle_in_hours_store(struct device *ras_feat_dev, struct device_attribute *attr,
> + const char *buf, size_t len)
> +{
> + struct edac_ras_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);
> + const struct edac_scrub_ops *ops = ctx->scrub.ops;
> + long val;
> + int ret;
> +
> + ret = kstrtol(buf, 10, &val);
Even here, I would be using base=0, but if you only want to support base
10, please document it at the sysfs ABI.
> + if (ret < 0)
> + return ret;
> +
> + ret = ops->cycle_in_hours_write(ras_feat_dev->parent, ctx->scrub.private, val);
> + if (ret)
> + return ret;
> +
> + return len;
> +}
> +
> +static ssize_t cycle_in_hours_range_show(struct device *ras_feat_dev,
> + struct device_attribute *attr,
> + char *buf)
> +{
> + struct edac_ras_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);
> + const struct edac_scrub_ops *ops = ctx->scrub.ops;
> + u64 min_schrs, max_schrs;
> + int ret;
> +
> + ret = ops->cycle_in_hours_range(ras_feat_dev->parent, ctx->scrub.private,
> + &min_schrs, &max_schrs);
> + if (ret)
> + return ret;
> +
> + return sysfs_emit(buf, "0x%llx-0x%llx\n", min_schrs, max_schrs);
Hmm... you added the store in decimal, but here you're showing in
hexa...
Btw, don't group multiple values on a single sysfs node. Instead,
implement two separate devnodes:
min-scrub-cycle
max-scrub-cycle
(see the note above about "hours")
> +}
> +
> +static DEVICE_ATTR_RW(addr_range_base);
> +static DEVICE_ATTR_RW(addr_range_size);
> +static DEVICE_ATTR_RW(enable_background);
> +static DEVICE_ATTR_RW(enable_on_demand);
> +static DEVICE_ATTR_RO(name);
> +static DEVICE_ATTR_RW(cycle_in_hours);
> +static DEVICE_ATTR_RO(cycle_in_hours_range);
> +
> +static struct attribute *scrub_attrs[] = {
> + &dev_attr_addr_range_base.attr,
> + &dev_attr_addr_range_size.attr,
> + &dev_attr_enable_background.attr,
> + &dev_attr_enable_on_demand.attr,
> + &dev_attr_name.attr,
> + &dev_attr_cycle_in_hours.attr,
> + &dev_attr_cycle_in_hours_range.attr,
> + NULL
> +};
> +
> +static umode_t scrub_attr_visible(struct kobject *kobj,
> + struct attribute *a, int attr_id)
> +{
> + struct device *ras_feat_dev = kobj_to_dev(kobj);
> + struct edac_ras_feat_ctx *ctx;
> + const struct edac_scrub_ops *ops;
> +
> + ctx = dev_get_drvdata(ras_feat_dev);
> + if (!ctx)
> + return 0;
> +
> + ops = ctx->scrub.ops;
> + if (a == &dev_attr_addr_range_base.attr ||
> + a == &dev_attr_addr_range_size.attr) {
> + if (ops->read_range && ops->write_range)
> + return a->mode;
> + if (ops->read_range)
> + return 0444;
> + return 0;
> + }
> + if (a == &dev_attr_enable_background.attr) {
> + if (ops->set_enabled_bg && ops->get_enabled_bg)
> + return a->mode;
> + if (ops->get_enabled_bg)
> + return 0444;
> + return 0;
> + }
> + if (a == &dev_attr_enable_on_demand.attr) {
> + if (ops->set_enabled_od && ops->get_enabled_od)
> + return a->mode;
> + if (ops->get_enabled_od)
> + return 0444;
> + return 0;
> + }
> + if (a == &dev_attr_name.attr)
> + return ops->get_name ? a->mode : 0;
> + if (a == &dev_attr_cycle_in_hours_range.attr)
> + return ops->cycle_in_hours_range ? a->mode : 0;
> + if (a == &dev_attr_cycle_in_hours.attr) { /* Write only makes little sense */
> + if (ops->cycle_in_hours_read && ops->cycle_in_hours_write)
> + return a->mode;
> + if (ops->cycle_in_hours_read)
> + return 0444;
> + return 0;
> + }
> +
> + return 0;
> +}
> +
> +static const struct attribute_group scrub_attr_group = {
> + .name = "scrub",
> + .attrs = scrub_attrs,
> + .is_visible = scrub_attr_visible,
> +};
> +
> +/**
> + * edac_scrub_get_desc - get edac scrub's attr descriptor
> + *
> + * Returns attribute_group for the scrub feature.
> + */
> +const struct attribute_group *edac_scrub_get_desc(void)
> +{
> + return &scrub_attr_group;
> +}
> diff --git a/include/linux/edac_ras_feature.h b/include/linux/edac_ras_feature.h
> index 000e99141023..462f9ecbf9d4 100755
> --- a/include/linux/edac_ras_feature.h
> +++ b/include/linux/edac_ras_feature.h
> @@ -19,6 +19,34 @@ enum edac_ras_feat {
> ras_feat_max
> };
>
> +/**
> + * struct scrub_ops - scrub device operations (all elements optional)
> + * @read_range: read base and offset of scrubbing range.
> + * @write_range: set the base and offset of the scrubbing range.
> + * @get_enabled_bg: check if currently performing background scrub.
> + * @set_enabled_bg: start or stop a bg-scrub.
> + * @get_enabled_od: check if currently performing on-demand scrub.
> + * @set_enabled_od: start or stop an on-demand scrub.
> + * @cycle_in_hours_range: retrieve limits on supported cycle in hours.
> + * @cycle_in_hours_read: read the scrub cycle in hours.
> + * @cycle_in_hours_write: set the scrub cycle in hours.
> + * @get_name: get the memory scrubber's name.
> + */
> +struct edac_scrub_ops {
> + int (*read_range)(struct device *dev, void *drv_data, u64 *base, u64 *size);
> + int (*write_range)(struct device *dev, void *drv_data, u64 base, u64 size);
> + int (*get_enabled_bg)(struct device *dev, void *drv_data, bool *enable);
> + int (*set_enabled_bg)(struct device *dev, void *drv_data, bool enable);
> + int (*get_enabled_od)(struct device *dev, void *drv_data, bool *enable);
> + int (*set_enabled_od)(struct device *dev, void *drv_data, bool enable);
> + int (*cycle_in_hours_range)(struct device *dev, void *drv_data, u64 *min, u64 *max);
> + int (*cycle_in_hours_read)(struct device *dev, void *drv_data, u64 *schrs);
> + int (*cycle_in_hours_write)(struct device *dev, void *drv_data, u64 schrs);
> + int (*get_name)(struct device *dev, void *drv_data, char *buf);
> +};
> +
> +const struct attribute_group *edac_scrub_get_desc(void);
> +
> struct edac_ecs_ex_info {
> u16 num_media_frus;
> };
Thanks,
Mauro
