device-dax: add an 'align' attribute (6d82120f) · Commits · 戴 / test

drivers/dax/bus.c

+83 −10

Original line number	Diff line number	Diff line
		@@ -230,14 +230,15 @@ static ssize_t region_size_show(struct device *dev,
		static struct device_attribute dev_attr_region_size = __ATTR(size, 0444,
		region_size_show, NULL);

		static ssize_t align_show(struct device *dev,
		static ssize_t region_align_show(struct device *dev,
		struct device_attribute attr, char buf)
		{
		struct dax_region *dax_region = dev_get_drvdata(dev);

		return sprintf(buf, "%u\n", dax_region->align);
		}
		static DEVICE_ATTR_RO(align);
		static struct device_attribute dev_attr_region_align =
		__ATTR(align, 0400, region_align_show, NULL);

		#define for_each_dax_region_resource(dax_region, res) \
		for (res = (dax_region)->res.child; res; res = res->sibling)
		@@ -488,7 +489,7 @@ static umode_t dax_region_visible(struct kobject kobj, struct attribute a,
		static struct attribute *dax_region_attributes[] = {
		&dev_attr_available_size.attr,
		&dev_attr_region_size.attr,
		&dev_attr_align.attr,
		&dev_attr_region_align.attr,
		&dev_attr_create.attr,
		&dev_attr_seed.attr,
		&dev_attr_delete.attr,
		@@ -858,15 +859,13 @@ static ssize_t size_show(struct device *dev,
		return sprintf(buf, "%llu\n", size);
		}

		static bool alloc_is_aligned(struct dax_region *dax_region,
		resource_size_t size)
		static bool alloc_is_aligned(struct dev_dax *dev_dax, resource_size_t size)
		{
		/*
		* The minimum mapping granularity for a device instance is a
		* single subsection, unless the arch says otherwise.
		*/
		return IS_ALIGNED(size, max_t(unsigned long, dax_region->align,
		memremap_compat_align()));
		return IS_ALIGNED(size, max_t(unsigned long, dev_dax->align, memremap_compat_align()));
		}

		static int dev_dax_shrink(struct dev_dax *dev_dax, resource_size_t size)
		@@ -961,7 +960,7 @@ static ssize_t dev_dax_resize(struct dax_region *dax_region,
		return dev_dax_shrink(dev_dax, size);

		to_alloc = size - dev_size;
		if (dev_WARN_ONCE(dev, !alloc_is_aligned(dax_region, to_alloc),
		if (dev_WARN_ONCE(dev, !alloc_is_aligned(dev_dax, to_alloc),
		"resize of %pa misaligned\n", &to_alloc))
		return -ENXIO;

		@@ -1025,7 +1024,7 @@ static ssize_t size_store(struct device dev, struct device_attribute attr,
		if (rc)
		return rc;

		if (!alloc_is_aligned(dax_region, val)) {
		if (!alloc_is_aligned(dev_dax, val)) {
		dev_dbg(dev, "%s: size: %lld misaligned\n", __func__, val);
		return -EINVAL;
		}
		@@ -1044,6 +1043,78 @@ static ssize_t size_store(struct device dev, struct device_attribute attr,
		}
		static DEVICE_ATTR_RW(size);

		static ssize_t align_show(struct device *dev,
		struct device_attribute attr, char buf)
		{
		struct dev_dax *dev_dax = to_dev_dax(dev);

		return sprintf(buf, "%d\n", dev_dax->align);
		}

		static ssize_t dev_dax_validate_align(struct dev_dax *dev_dax)
		{
		resource_size_t dev_size = dev_dax_size(dev_dax);
		struct device *dev = &dev_dax->dev;
		int i;

		if (dev_size > 0 && !alloc_is_aligned(dev_dax, dev_size)) {
		dev_dbg(dev, "%s: align %u invalid for size %pa\n",
		__func__, dev_dax->align, &dev_size);
		return -EINVAL;
		}

		for (i = 0; i < dev_dax->nr_range; i++) {
		size_t len = range_len(&dev_dax->ranges[i].range);

		if (!alloc_is_aligned(dev_dax, len)) {
		dev_dbg(dev, "%s: align %u invalid for range %d\n",
		__func__, dev_dax->align, i);
		return -EINVAL;
		}
		}

		return 0;
		}

		static ssize_t align_store(struct device dev, struct device_attribute attr,
		const char *buf, size_t len)
		{
		struct dev_dax *dev_dax = to_dev_dax(dev);
		struct dax_region *dax_region = dev_dax->region;
		unsigned long val, align_save;
		ssize_t rc;

		rc = kstrtoul(buf, 0, &val);
		if (rc)
		return -ENXIO;

		if (!dax_align_valid(val))
		return -EINVAL;

		device_lock(dax_region->dev);
		if (!dax_region->dev->driver) {
		device_unlock(dax_region->dev);
		return -ENXIO;
		}

		device_lock(dev);
		if (dev->driver) {
		rc = -EBUSY;
		goto out_unlock;
		}

		align_save = dev_dax->align;
		dev_dax->align = val;
		rc = dev_dax_validate_align(dev_dax);
		if (rc)
		dev_dax->align = align_save;
		out_unlock:
		device_unlock(dev);
		device_unlock(dax_region->dev);
		return rc == 0 ? len : rc;
		}
		static DEVICE_ATTR_RW(align);

		static int dev_dax_target_node(struct dev_dax *dev_dax)
		{
		struct dax_region *dax_region = dev_dax->region;
		@@ -1104,7 +1175,8 @@ static umode_t dev_dax_visible(struct kobject kobj, struct attribute a, int n)
		return 0;
		if (a == &dev_attr_numa_node.attr && !IS_ENABLED(CONFIG_NUMA))
		return 0;
		if (a == &dev_attr_size.attr && is_static(dax_region))
		if ((a == &dev_attr_align.attr \|\|
		a == &dev_attr_size.attr) && is_static(dax_region))
		return 0444;
		return a->mode;
		}
		@@ -1113,6 +1185,7 @@ static struct attribute *dev_dax_attributes[] = {
		&dev_attr_modalias.attr,
		&dev_attr_size.attr,
		&dev_attr_target_node.attr,
		&dev_attr_align.attr,
		&dev_attr_resource.attr,
		&dev_attr_numa_node.attr,
		NULL,

drivers/dax/dax-private.h

+18 −0

Original line number	Diff line number	Diff line
		@@ -87,4 +87,22 @@ static inline struct dax_mapping to_dax_mapping(struct device dev)
		}

		phys_addr_t dax_pgoff_to_phys(struct dev_dax *dev_dax, pgoff_t pgoff, unsigned long size);

		#ifdef CONFIG_TRANSPARENT_HUGEPAGE
		static inline bool dax_align_valid(unsigned long align)
		{
		if (align == PUD_SIZE && IS_ENABLED(CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD))
		return true;
		if (align == PMD_SIZE && has_transparent_hugepage())
		return true;
		if (align == PAGE_SIZE)
		return true;
		return false;
		}
		#else
		static inline bool dax_align_valid(unsigned long align)
		{
		return align == PAGE_SIZE;
		}
		#endif /* CONFIG_TRANSPARENT_HUGEPAGE */
		#endif

Admin message