Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > linux.kernel > #1167489 > unrolled thread
| Started by | Dan Williams <dan.j.williams@intel.com> |
|---|---|
| First post | 2015-06-18 02:00 +0200 |
| Last post | 2015-06-21 16:50 +0200 |
| Articles | 20 on this page of 21 — 2 participants |
Back to article view | Back to linux.kernel
[PATCH 00/15] libnvdimm: ->rw_bytes(), BLK-mode, unit tests, and misc features Dan Williams <dan.j.williams@intel.com> - 2015-06-18 02:00 +0200
[PATCH 12/15] libnvdimm: enable iostat Dan Williams <dan.j.williams@intel.com> - 2015-06-18 02:00 +0200
Re: [PATCH 12/15] libnvdimm: enable iostat Christoph Hellwig <hch@lst.de> - 2015-06-19 10:40 +0200
Re: [PATCH 12/15] libnvdimm: enable iostat Dan Williams <dan.j.williams@intel.com> - 2015-06-19 11:10 +0200
Re: [PATCH 12/15] libnvdimm: enable iostat Christoph Hellwig <hch@lst.de> - 2015-06-21 12:20 +0200
[PATCH 07/15] fs/block_dev.c: skip rw_page if bdev has integrity Dan Williams <dan.j.williams@intel.com> - 2015-06-18 02:00 +0200
[PATCH 13/15] libnvdimm: flag libnvdimm block devices as non-rotational Dan Williams <dan.j.williams@intel.com> - 2015-06-18 02:00 +0200
[PATCH 01/15] block: introduce an ->rw_bytes() block device operation Dan Williams <dan.j.williams@intel.com> - 2015-06-18 02:00 +0200
Re: [PATCH 01/15] block: introduce an ->rw_bytes() block device operation Dan Williams <dan.j.williams@intel.com> - 2015-06-18 21:30 +0200
[PATCH 09/15] libnvdimm, blk: add support for blk integrity Dan Williams <dan.j.williams@intel.com> - 2015-06-18 02:00 +0200
[PATCH 15/15] libnvdimm, nfit: handle acpi_nfit_memory_map flags Dan Williams <dan.j.williams@intel.com> - 2015-06-18 02:00 +0200
[PATCH 11/15] libnvdimm: pmem, blk, and btt make_request cleanups Dan Williams <dan.j.williams@intel.com> - 2015-06-18 02:10 +0200
Re: [PATCH 11/15] libnvdimm: pmem, blk, and btt make_request cleanups Christoph Hellwig <hch@lst.de> - 2015-06-21 12:20 +0200
[PATCH 08/15] libnvdimm, btt: add support for blk integrity Dan Williams <dan.j.williams@intel.com> - 2015-06-18 02:10 +0200
[PATCH 02/15] libnvdimm: infrastructure for btt devices Dan Williams <dan.j.williams@intel.com> - 2015-06-18 02:10 +0200
[PATCH 10/15] libnvdimm: fix up max_hw_sectors Dan Williams <dan.j.williams@intel.com> - 2015-06-18 02:10 +0200
Re: [PATCH 10/15] libnvdimm: fix up max_hw_sectors Christoph Hellwig <hch@lst.de> - 2015-06-21 12:10 +0200
Re: [PATCH 03/15] nd_btt: atomic sector updates Christoph Hellwig <hch@lst.de> - 2015-06-21 12:10 +0200
Re: [PATCH 03/15] nd_btt: atomic sector updates Dan Williams <dan.j.williams@intel.com> - 2015-06-21 18:40 +0200
Re: [PATCH 04/15] libnvdimm, nfit, nd_blk: driver for BLK-mode access persistent memory Christoph Hellwig <hch@lst.de> - 2015-06-21 12:10 +0200
Re: [PATCH 04/15] libnvdimm, nfit, nd_blk: driver for BLK-mode access persistent memory Dan Williams <dan.j.williams@intel.com> - 2015-06-21 16:50 +0200
Page 1 of 2 [1] 2 Next page →
| From | Dan Williams <dan.j.williams@intel.com> |
|---|---|
| Date | 2015-06-18 02:00 +0200 |
| Subject | [PATCH 00/15] libnvdimm: ->rw_bytes(), BLK-mode, unit tests, and misc features |
| Message-ID | <pCvpn-8ib-9@gated-at.bofh.it> |
This patchset takes the position that a new block_device_operations op
is needed for nvdimm devices. Jens, see "[PATCH 01/15] block: introduce
an ->rw_bytes() block device operation", it gates the rest of the series
moving forward.
Aside from adding a compile-time check to tools/testing/nvdimm/Kbuild
for validating all libnvdimm objects are built as modules, patches 2 to
6 are otherwise unchanged from the v6 libnvdimm posting [1]. The
remaining patches are feature additions and other cleanups that were
being held back while the base patchset was polished.
Patch 5 has an updated changelog speaking to the potential maintenance
burden of carrying tools/testing/nvdimm/ in-tree. The benefits still
outweigh the risks in my opinion.
It should be noted that "[PATCH 14/15] libnvdimm: support read-only btt
backing devices" was developed in direct repsonse to working through the
implementation of unit tests for "[PATCH 15/15] libnvdimm, nfit: handle
acpi_nfit_memory_map flags" and its new "read-only by default" policy.
See the updates to the libndctl unit tests posted on the
linux-nvdimm@01.org mailing list.
[PATCH 01/15] block: introduce an ->rw_bytes() block device operation
[PATCH 02/15] libnvdimm: infrastructure for btt devices
[PATCH 03/15] nd_btt: atomic sector updates
[PATCH 04/15] libnvdimm, nfit, nd_blk: driver for BLK-mode access persistent memory
[PATCH 05/15] tools/testing/nvdimm: libnvdimm unit test infrastructure
[PATCH 06/15] libnvdimm: Non-Volatile Devices
[PATCH 07/15] fs/block_dev.c: skip rw_page if bdev has integrity
[PATCH 08/15] libnvdimm, btt: add support for blk integrity
[PATCH 09/15] libnvdimm, blk: add support for blk integrity
[PATCH 10/15] libnvdimm: fix up max_hw_sectors
[PATCH 11/15] libnvdimm: pmem, blk, and btt make_request cleanups
[PATCH 12/15] libnvdimm: enable iostat
[PATCH 13/15] libnvdimm: flag libnvdimm block devices as non-rotational
[PATCH 14/15] libnvdimm: support read-only btt backing devices
[PATCH 15/15] libnvdimm, nfit: handle acpi_nfit_memory_map flags
[1]: https://lists.01.org/pipermail/linux-nvdimm/2015-June/001166.html
---
Dan Williams (10):
block: introduce an ->rw_bytes() block device operation
libnvdimm: infrastructure for btt devices
tools/testing/nvdimm: libnvdimm unit test infrastructure
libnvdimm: Non-Volatile Devices
libnvdimm: fix up max_hw_sectors
libnvdimm: pmem, blk, and btt make_request cleanups
libnvdimm: enable iostat
libnvdimm: flag libnvdimm block devices as non-rotational
libnvdimm: support read-only btt backing devices
libnvdimm, nfit: handle acpi_nfit_memory_map flags
Ross Zwisler (1):
libnvdimm, nfit, nd_blk: driver for BLK-mode access persistent memory
Vishal Verma (4):
nd_btt: atomic sector updates
fs/block_dev.c: skip rw_page if bdev has integrity
libnvdimm, btt: add support for blk integrity
libnvdimm, blk: add support for blk integrity
Documentation/nvdimm/btt.txt | 273 ++++++
Documentation/nvdimm/nvdimm.txt | 805 +++++++++++++++++
MAINTAINERS | 39 +
drivers/acpi/nfit.c | 491 ++++++++++
drivers/acpi/nfit.h | 58 +
drivers/nvdimm/Kconfig | 54 +
drivers/nvdimm/Makefile | 7
drivers/nvdimm/blk.c | 368 ++++++++
drivers/nvdimm/btt.c | 1569 +++++++++++++++++++++++++++++++++
drivers/nvdimm/btt.h | 185 ++++
drivers/nvdimm/btt_devs.c | 473 ++++++++++
drivers/nvdimm/bus.c | 176 ++++
drivers/nvdimm/core.c | 99 ++
drivers/nvdimm/dimm_devs.c | 9
drivers/nvdimm/namespace_devs.c | 63 +
drivers/nvdimm/nd-core.h | 48 +
drivers/nvdimm/nd.h | 61 +
drivers/nvdimm/pmem.c | 58 +
drivers/nvdimm/region.c | 97 ++
drivers/nvdimm/region_devs.c | 106 ++
fs/block_dev.c | 4
include/linux/blkdev.h | 44 +
include/linux/libnvdimm.h | 30 +
include/uapi/linux/ndctl.h | 2
tools/testing/nvdimm/Kbuild | 40 +
tools/testing/nvdimm/Makefile | 7
tools/testing/nvdimm/config_check.c | 15
tools/testing/nvdimm/test/Kbuild | 8
tools/testing/nvdimm/test/iomap.c | 151 +++
tools/testing/nvdimm/test/nfit.c | 1115 +++++++++++++++++++++++
tools/testing/nvdimm/test/nfit_test.h | 29 +
31 files changed, 6422 insertions(+), 62 deletions(-)
create mode 100644 Documentation/nvdimm/btt.txt
create mode 100644 Documentation/nvdimm/nvdimm.txt
create mode 100644 drivers/nvdimm/blk.c
create mode 100644 drivers/nvdimm/btt.c
create mode 100644 drivers/nvdimm/btt.h
create mode 100644 drivers/nvdimm/btt_devs.c
create mode 100644 tools/testing/nvdimm/Kbuild
create mode 100644 tools/testing/nvdimm/Makefile
create mode 100644 tools/testing/nvdimm/config_check.c
create mode 100644 tools/testing/nvdimm/test/Kbuild
create mode 100644 tools/testing/nvdimm/test/iomap.c
create mode 100644 tools/testing/nvdimm/test/nfit.c
create mode 100644 tools/testing/nvdimm/test/nfit_test.h
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
[toc] | [next] | [standalone]
| From | Dan Williams <dan.j.williams@intel.com> |
|---|---|
| Date | 2015-06-18 02:00 +0200 |
| Subject | [PATCH 12/15] libnvdimm: enable iostat |
| Message-ID | <pCvpo-8ib-15@gated-at.bofh.it> |
| In reply to | #1167489 |
This is disabled by default as the overhead is prohibitive, but if the
user takes the action to turn it on we'll oblige.
Reviewed-by: Vishal Verma <vishal.l.verma@linux.intel.com>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/nvdimm/Kconfig | 14 ++++++++++++++
drivers/nvdimm/blk.c | 7 ++++++-
drivers/nvdimm/btt.c | 7 ++++++-
drivers/nvdimm/core.c | 31 +++++++++++++++++++++++++++++++
drivers/nvdimm/nd.h | 13 +++++++++++++
drivers/nvdimm/pmem.c | 5 +++++
6 files changed, 75 insertions(+), 2 deletions(-)
diff --git a/drivers/nvdimm/Kconfig b/drivers/nvdimm/Kconfig
index 912cb36b8435..9d72085a67c9 100644
--- a/drivers/nvdimm/Kconfig
+++ b/drivers/nvdimm/Kconfig
@@ -73,4 +73,18 @@ config ND_MAX_REGIONS
Leave the default of 64 if you are unsure.
+config ND_IOSTAT
+ bool "Enable iostat by default"
+ default n
+ ---help---
+ Persistent memory i/o has very low latency to the point
+ where the overhead to measure statistics can dramatically
+ impact the relative performance of the driver. Say y here
+ to trade off performance for statistics gathering that is
+ enabled by default. These statistics can always be
+ enabled/disabled at run time via the 'iostat' attribute of
+ the block device's queue in sysfs.
+
+ If unsure, say N
+
endif
diff --git a/drivers/nvdimm/blk.c b/drivers/nvdimm/blk.c
index 9d609ef95266..8a65e5a500d8 100644
--- a/drivers/nvdimm/blk.c
+++ b/drivers/nvdimm/blk.c
@@ -168,8 +168,10 @@ static void nd_blk_make_request(struct request_queue *q, struct bio *bio)
struct bio_integrity_payload *bip;
struct nd_blk_device *blk_dev;
struct bvec_iter iter;
+ unsigned long start;
struct bio_vec bvec;
int err = 0, rw;
+ bool do_acct;
if (unlikely(bio_end_sector(bio) > get_capacity(disk))) {
err = -EIO;
@@ -191,6 +193,7 @@ static void nd_blk_make_request(struct request_queue *q, struct bio *bio)
blk_dev = disk->private_data;
rw = bio_data_dir(bio);
+ do_acct = nd_iostat_start(bio, &start);
bio_for_each_segment(bvec, bio, iter) {
unsigned int len = bvec.bv_len;
@@ -202,9 +205,11 @@ static void nd_blk_make_request(struct request_queue *q, struct bio *bio)
"io error in %s sector %lld, len %d,\n",
(rw == READ) ? "READ" : "WRITE",
(unsigned long long) iter.bi_sector, len);
- goto out;
+ break;
}
}
+ if (do_acct)
+ nd_iostat_end(bio, start);
out:
bio_endio(bio, err);
diff --git a/drivers/nvdimm/btt.c b/drivers/nvdimm/btt.c
index 83b798dd2e68..67484633c322 100644
--- a/drivers/nvdimm/btt.c
+++ b/drivers/nvdimm/btt.c
@@ -1178,8 +1178,10 @@ static void btt_make_request(struct request_queue *q, struct bio *bio)
struct block_device *bdev = bio->bi_bdev;
struct btt *btt = q->queuedata;
struct bvec_iter iter;
+ unsigned long start;
struct bio_vec bvec;
int err = 0, rw;
+ bool do_acct;
if (bio_end_sector(bio) > get_capacity(bdev->bd_disk)) {
err = -EIO;
@@ -1199,6 +1201,7 @@ static void btt_make_request(struct request_queue *q, struct bio *bio)
goto out;
}
+ do_acct = nd_iostat_start(bio, &start);
bio_for_each_segment(bvec, bio, iter) {
unsigned int len = bvec.bv_len;
@@ -1215,9 +1218,11 @@ static void btt_make_request(struct request_queue *q, struct bio *bio)
"io error in %s sector %lld, len %d,\n",
(rw == READ) ? "READ" : "WRITE",
(unsigned long long) iter.bi_sector, len);
- goto out;
+ break;
}
}
+ if (do_acct)
+ nd_iostat_end(bio, start);
out:
bio_endio(bio, err);
diff --git a/drivers/nvdimm/core.c b/drivers/nvdimm/core.c
index d27b13357873..99cf95af5f24 100644
--- a/drivers/nvdimm/core.c
+++ b/drivers/nvdimm/core.c
@@ -218,9 +218,40 @@ void nd_blk_queue_init(struct request_queue *q)
{
blk_queue_max_hw_sectors(q, UINT_MAX);
blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
+ if (IS_ENABLED(CONFIG_ND_IOSTAT))
+ queue_flag_set_unlocked(QUEUE_FLAG_IO_STAT, q);
}
EXPORT_SYMBOL(nd_blk_queue_init);
+void __nd_iostat_start(struct bio *bio, unsigned long *start)
+{
+ struct gendisk *disk = bio->bi_bdev->bd_disk;
+ const int rw = bio_data_dir(bio);
+ int cpu = part_stat_lock();
+
+ *start = jiffies;
+ part_round_stats(cpu, &disk->part0);
+ part_stat_inc(cpu, &disk->part0, ios[rw]);
+ part_stat_add(cpu, &disk->part0, sectors[rw], bio_sectors(bio));
+ part_inc_in_flight(&disk->part0, rw);
+ part_stat_unlock();
+}
+EXPORT_SYMBOL(__nd_iostat_start);
+
+void nd_iostat_end(struct bio *bio, unsigned long start)
+{
+ struct gendisk *disk = bio->bi_bdev->bd_disk;
+ unsigned long duration = jiffies - start;
+ const int rw = bio_data_dir(bio);
+ int cpu = part_stat_lock();
+
+ part_stat_add(cpu, &disk->part0, ticks[rw], duration);
+ part_round_stats(cpu, &disk->part0);
+ part_dec_in_flight(&disk->part0, rw);
+ part_stat_unlock();
+}
+EXPORT_SYMBOL(nd_iostat_end);
+
static ssize_t commands_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
diff --git a/drivers/nvdimm/nd.h b/drivers/nvdimm/nd.h
index 2f20d5dca028..3c4c8b6c64ec 100644
--- a/drivers/nvdimm/nd.h
+++ b/drivers/nvdimm/nd.h
@@ -13,6 +13,7 @@
#ifndef __ND_H__
#define __ND_H__
#include <linux/libnvdimm.h>
+#include <linux/blkdev.h>
#include <linux/device.h>
#include <linux/genhd.h>
#include <linux/mutex.h>
@@ -172,5 +173,17 @@ struct resource *nvdimm_allocate_dpa(struct nvdimm_drvdata *ndd,
resource_size_t n);
int nd_blk_region_init(struct nd_region *nd_region);
void nd_blk_queue_init(struct request_queue *q);
+void __nd_iostat_start(struct bio *bio, unsigned long *start);
+static inline bool nd_iostat_start(struct bio *bio, unsigned long *start)
+{
+ struct gendisk *disk = bio->bi_bdev->bd_disk;
+
+ if (!blk_queue_io_stat(disk->queue))
+ return false;
+
+ __nd_iostat_start(bio, start);
+ return true;
+}
+void nd_iostat_end(struct bio *bio, unsigned long start);
resource_size_t nd_namespace_blk_validate(struct nd_namespace_blk *nsblk);
#endif /* __ND_H__ */
diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c
index 0337b00f5409..3fd854a78f09 100644
--- a/drivers/nvdimm/pmem.c
+++ b/drivers/nvdimm/pmem.c
@@ -59,6 +59,8 @@ static void pmem_do_bvec(struct pmem_device *pmem, struct page *page,
static void pmem_make_request(struct request_queue *q, struct bio *bio)
{
int err = 0;
+ bool do_acct;
+ unsigned long start;
struct bio_vec bvec;
struct bvec_iter iter;
struct block_device *bdev = bio->bi_bdev;
@@ -69,9 +71,12 @@ static void pmem_make_request(struct request_queue *q, struct bio *bio)
goto out;
}
+ do_acct = nd_iostat_start(bio, &start);
bio_for_each_segment(bvec, bio, iter)
pmem_do_bvec(pmem, bvec.bv_page, bvec.bv_len, bvec.bv_offset,
bio_data_dir(bio), iter.bi_sector);
+ if (do_acct)
+ nd_iostat_end(bio, start);
out:
bio_endio(bio, err);
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
| From | Christoph Hellwig <hch@lst.de> |
|---|---|
| Date | 2015-06-19 10:40 +0200 |
| Subject | Re: [PATCH 12/15] libnvdimm: enable iostat |
| Message-ID | <pD009-25F-1@gated-at.bofh.it> |
| In reply to | #1167492 |
On Wed, Jun 17, 2015 at 07:55:51PM -0400, Dan Williams wrote: > This is disabled by default as the overhead is prohibitive, but if the > user takes the action to turn it on we'll oblige. If you care about users a compile time selection doesn't make sense, why not always build it but require an opt-in? -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
| From | Dan Williams <dan.j.williams@intel.com> |
|---|---|
| Date | 2015-06-19 11:10 +0200 |
| Subject | Re: [PATCH 12/15] libnvdimm: enable iostat |
| Message-ID | <pD0tb-2Tl-1@gated-at.bofh.it> |
| In reply to | #1168611 |
On Fri, Jun 19, 2015 at 1:34 AM, Christoph Hellwig <hch@lst.de> wrote: > On Wed, Jun 17, 2015 at 07:55:51PM -0400, Dan Williams wrote: >> This is disabled by default as the overhead is prohibitive, but if the >> user takes the action to turn it on we'll oblige. > > If you care about users a compile time selection doesn't make sense, > why not always build it but require an opt-in? It's always built the Kconfig just selects the default initial state of QUEUE_FLAG_IO_STAT. They can always turn it on/off via block queue sysfs. -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
| From | Christoph Hellwig <hch@lst.de> |
|---|---|
| Date | 2015-06-21 12:20 +0200 |
| Subject | Re: [PATCH 12/15] libnvdimm: enable iostat |
| Message-ID | <pDKw2-29u-15@gated-at.bofh.it> |
| In reply to | #1168642 |
On Fri, Jun 19, 2015 at 02:02:39AM -0700, Dan Williams wrote: > On Fri, Jun 19, 2015 at 1:34 AM, Christoph Hellwig <hch@lst.de> wrote: > > On Wed, Jun 17, 2015 at 07:55:51PM -0400, Dan Williams wrote: > >> This is disabled by default as the overhead is prohibitive, but if the > >> user takes the action to turn it on we'll oblige. > > > > If you care about users a compile time selection doesn't make sense, > > why not always build it but require an opt-in? > > It's always built the Kconfig just selects the default initial state > of QUEUE_FLAG_IO_STAT. They can always turn it on/off via block queue > sysfs. Oh, missed that. Just drop the Kconfig option in that case. -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
| From | Dan Williams <dan.j.williams@intel.com> |
|---|---|
| Date | 2015-06-18 02:00 +0200 |
| Subject | [PATCH 07/15] fs/block_dev.c: skip rw_page if bdev has integrity |
| Message-ID | <pCvpp-8ib-23@gated-at.bofh.it> |
| In reply to | #1167489 |
From: Vishal Verma <vishal.l.verma@linux.intel.com>
If a block device has bio integrity enabled, rw_page will bypass the
integrity payload, which is undesirable. Skip rw_page if this is the
case.
Currently brd and zram provide rw_page, and the proposed 'nd' drivers
will too.
Cc: Jens Axboe <axboe@fb.com>
Cc: Martin K. Petersen <martin.petersen@oracle.com>
Suggested-by: Matthew Wilcox <matthew.r.wilcox@intel.com>
Signed-off-by: Vishal Verma <vishal.l.verma@linux.intel.com>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
---
fs/block_dev.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/fs/block_dev.c b/fs/block_dev.c
index c7e4163ede87..054ef1bbb821 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -376,7 +376,7 @@ int bdev_read_page(struct block_device *bdev, sector_t sector,
struct page *page)
{
const struct block_device_operations *ops = bdev->bd_disk->fops;
- if (!ops->rw_page)
+ if (!ops->rw_page || bdev_get_integrity(bdev))
return -EOPNOTSUPP;
return ops->rw_page(bdev, sector + get_start_sect(bdev), page, READ);
}
@@ -407,7 +407,7 @@ int bdev_write_page(struct block_device *bdev, sector_t sector,
int result;
int rw = (wbc->sync_mode == WB_SYNC_ALL) ? WRITE_SYNC : WRITE;
const struct block_device_operations *ops = bdev->bd_disk->fops;
- if (!ops->rw_page)
+ if (!ops->rw_page || bdev_get_integrity(bdev))
return -EOPNOTSUPP;
set_page_writeback(page);
result = ops->rw_page(bdev, sector + get_start_sect(bdev), page, rw);
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
| From | Dan Williams <dan.j.williams@intel.com> |
|---|---|
| Date | 2015-06-18 02:00 +0200 |
| Subject | [PATCH 13/15] libnvdimm: flag libnvdimm block devices as non-rotational |
| Message-ID | <pCvpp-8ib-25@gated-at.bofh.it> |
| In reply to | #1167489 |
...since they are effectively SSDs as far as userspace is concerned. Reviewed-by: Vishal Verma <vishal.l.verma@linux.intel.com> Signed-off-by: Dan Williams <dan.j.williams@intel.com> --- drivers/nvdimm/core.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/nvdimm/core.c b/drivers/nvdimm/core.c index 99cf95af5f24..fa82f215990d 100644 --- a/drivers/nvdimm/core.c +++ b/drivers/nvdimm/core.c @@ -220,6 +220,7 @@ void nd_blk_queue_init(struct request_queue *q) blk_queue_bounce_limit(q, BLK_BOUNCE_ANY); if (IS_ENABLED(CONFIG_ND_IOSTAT)) queue_flag_set_unlocked(QUEUE_FLAG_IO_STAT, q); + queue_flag_set_unlocked(QUEUE_FLAG_NONROT, q); } EXPORT_SYMBOL(nd_blk_queue_init); -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
| From | Dan Williams <dan.j.williams@intel.com> |
|---|---|
| Date | 2015-06-18 02:00 +0200 |
| Subject | [PATCH 01/15] block: introduce an ->rw_bytes() block device operation |
| Message-ID | <pCvpp-8ib-27@gated-at.bofh.it> |
| In reply to | #1167489 |
Why do we need a new method in block_device_operations?
The capacities of persistent memory make it too large to map as RAM (no
struct page coverage by default), so Linux arranges for it to be managed
as a block device. The bio interface to a block device enforces sector
at a time i/o and has infrastructure for asynchronous completion of i/o.
The ->rw_page() interface is closely tied to the page cache and also
carries asynchronous i/o completion assumptions. NVDIMM devices are
fast enough to complete i/o's synchronously (memcpy) and some in kernel
applications can take advantage of the byte-aligned (as opposed to
sector-aligned) nature of the media. The ->rw_bytes() operation is
added to fill this role that does not fit into any existing access
method.
It could be argued that a ->rw_bytes() method makes a struct
block_device not a *block* device. However, the applications for
persistent memory as storage devices makes them more "block" devices
than "character" devices.
The first consumer of the ->rw_bytes() capability is a stacked
block_device driver (BTT - block translation table) that adds atomic
sector update semantics on top of an nvdimm storage device.
Why enable drivers like BTT on top of a new globally visibly
block_device_operations op rather than an internal detail of nvdimm
drivers?
1/ We want ->rw_bytes() consumers to be enabled on either a per-disk or
per-partition basis. Consider the case of enabling DAX+XFS on a single
persistent memory disk whereby the metadata needs atomic sector update
guarantees, but the data would like to be DAX capable. Solution is to
create two partitions and enable BTT on the "metadata/XFS-logdev"
partition.
2/ We want this configuration topology to be visible to the sysfs device
model, and not an internal detail of nvdimm drivers requiring special
tooling. For example if you ever wanted to "fsck" BTT metadata that
could be carried out on the raw nvdimm device directly rather than
require custom tooling / mechanisms to access the raw media.
3/ It becomes trivial to add new BTT like drivers without touching the
nvdimm drivers to add is_btt_mode(), is_foo_mode(), etc... checks in the
fast path.
Cc: Jens Axboe <axboe@fb.com>
Cc: Andy Lutomirski <luto@amacapital.net>
Cc: Boaz Harrosh <boaz@plexistor.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ross Zwisler <ross.zwisler@linux.intel.com>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/nvdimm/pmem.c | 19 +++++++++++++++++++
include/linux/blkdev.h | 44 ++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 63 insertions(+)
diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c
index 90902a142e35..efa2cde7f6b6 100644
--- a/drivers/nvdimm/pmem.c
+++ b/drivers/nvdimm/pmem.c
@@ -96,6 +96,24 @@ static int pmem_rw_page(struct block_device *bdev, sector_t sector,
return 0;
}
+static int pmem_rw_bytes(struct gendisk *disk, resource_size_t offset,
+ void *buf, size_t size, int rw)
+{
+ struct pmem_device *pmem = disk->private_data;
+
+ if (unlikely(offset + size > pmem->size)) {
+ dev_WARN_ONCE(disk_to_dev(disk), 1, "request out of range\n");
+ return -EFAULT;
+ }
+
+ if (rw == READ)
+ memcpy(buf, pmem->virt_addr + offset, size);
+ else
+ memcpy(pmem->virt_addr + offset, buf, size);
+
+ return 0;
+}
+
static long pmem_direct_access(struct block_device *bdev, sector_t sector,
void **kaddr, unsigned long *pfn, long size)
{
@@ -114,6 +132,7 @@ static long pmem_direct_access(struct block_device *bdev, sector_t sector,
static const struct block_device_operations pmem_fops = {
.owner = THIS_MODULE,
.rw_page = pmem_rw_page,
+ .rw_bytes = pmem_rw_bytes,
.direct_access = pmem_direct_access,
};
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 7f9a516f24de..25d6034a2e62 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -1602,6 +1602,8 @@ struct block_device_operations {
int (*open) (struct block_device *, fmode_t);
void (*release) (struct gendisk *, fmode_t);
int (*rw_page)(struct block_device *, sector_t, struct page *, int rw);
+ int (*rw_bytes)(struct gendisk *, resource_size_t offset,
+ void *buf, size_t size, int rw);
int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
long (*direct_access)(struct block_device *, sector_t,
@@ -1625,6 +1627,48 @@ extern int bdev_write_page(struct block_device *, sector_t, struct page *,
struct writeback_control *);
extern long bdev_direct_access(struct block_device *, sector_t, void **addr,
unsigned long *pfn, long size);
+
+/**
+ * bdev_read_bytes() - synchronously read bytes from a memory-backed block dev
+ * @bdev: device to read
+ * @offset: bdev-relative starting offset
+ * @buf: buffer to fill
+ * @size: transfer length
+ *
+ * RAM and PMEM disks do not implement sectors internally. @buf is
+ * up-to-date upon return from this routine.
+ */
+static inline int bdev_read_bytes(struct block_device *bdev,
+ resource_size_t offset, void *buf, size_t size)
+{
+ struct gendisk *disk = bdev->bd_disk;
+ const struct block_device_operations *ops = disk->fops;
+
+ offset += get_start_sect(bdev) << 9;
+ return ops->rw_bytes(disk, offset, buf, size, READ);
+}
+
+/**
+ * bdev_write_bytes() - synchronously write bytes to a memory-backed block dev
+ * @bdev: device to read
+ * @offset: bdev-relative starting offset
+ * @buf: buffer to drain
+ * @size: transfer length
+ *
+ * RAM and PMEM disks do not implement sectors internally. Depending on
+ * the @bdev, the contents of @buf may be in cpu cache, platform buffers,
+ * or on backing memory media upon return from this routine. Flushing
+ * to media is handled internal to the @bdev driver, if at all.
+ */
+static inline int bdev_write_bytes(struct block_device *bdev,
+ resource_size_t offset, void *buf, size_t size)
+{
+ struct gendisk *disk = bdev->bd_disk;
+ const struct block_device_operations *ops = disk->fops;
+
+ offset += get_start_sect(bdev) << 9;
+ return ops->rw_bytes(disk, offset, buf, size, WRITE);
+}
#else /* CONFIG_BLOCK */
struct block_device;
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
| From | Dan Williams <dan.j.williams@intel.com> |
|---|---|
| Date | 2015-06-18 21:30 +0200 |
| Subject | Re: [PATCH 01/15] block: introduce an ->rw_bytes() block device operation |
| Message-ID | <pCNFF-10E-25@gated-at.bofh.it> |
| In reply to | #1167497 |
On Wed, Jun 17, 2015 at 4:54 PM, Dan Williams <dan.j.williams@intel.com> wrote: > Why do we need a new method in block_device_operations? > > The capacities of persistent memory make it too large to map as RAM (no > struct page coverage by default), so Linux arranges for it to be managed > as a block device. The bio interface to a block device enforces sector > at a time i/o and has infrastructure for asynchronous completion of i/o. > The ->rw_page() interface is closely tied to the page cache and also > carries asynchronous i/o completion assumptions. NVDIMM devices are > fast enough to complete i/o's synchronously (memcpy) and some in kernel > applications can take advantage of the byte-aligned (as opposed to > sector-aligned) nature of the media. The ->rw_bytes() operation is > added to fill this role that does not fit into any existing access > method. > > It could be argued that a ->rw_bytes() method makes a struct > block_device not a *block* device. However, the applications for > persistent memory as storage devices makes them more "block" devices > than "character" devices. > > The first consumer of the ->rw_bytes() capability is a stacked > block_device driver (BTT - block translation table) that adds atomic > sector update semantics on top of an nvdimm storage device. > > Why enable drivers like BTT on top of a new globally visibly > block_device_operations op rather than an internal detail of nvdimm > drivers? > > 1/ We want ->rw_bytes() consumers to be enabled on either a per-disk or > per-partition basis. Consider the case of enabling DAX+XFS on a single > persistent memory disk whereby the metadata needs atomic sector update > guarantees, but the data would like to be DAX capable. Solution is to > create two partitions and enable BTT on the "metadata/XFS-logdev" > partition. > > 2/ We want this configuration topology to be visible to the sysfs device > model, and not an internal detail of nvdimm drivers requiring special > tooling. For example if you ever wanted to "fsck" BTT metadata that > could be carried out on the raw nvdimm device directly rather than > require custom tooling / mechanisms to access the raw media. > > 3/ It becomes trivial to add new BTT like drivers without touching the > nvdimm drivers to add is_btt_mode(), is_foo_mode(), etc... checks in the > fast path. > Acked-by: Jens Axboe <axboe@fb.com> ...off list. Christoph, I assume that satisfies your primary concern with the BTT infrastructure and implementation? -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
| From | Dan Williams <dan.j.williams@intel.com> |
|---|---|
| Date | 2015-06-18 02:00 +0200 |
| Subject | [PATCH 09/15] libnvdimm, blk: add support for blk integrity |
| Message-ID | <pCvpo-8ib-21@gated-at.bofh.it> |
| In reply to | #1167489 |
From: Vishal Verma <vishal.l.verma@linux.intel.com>
Support multiple block sizes (sector + metadata) for nd_blk in the
same way as done for the BTT. Add the idea of an 'internal' lbasize,
which is properly aligned and padded, and store metadata in this space.
Signed-off-by: Vishal Verma <vishal.l.verma@linux.intel.com>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/nvdimm/blk.c | 168 ++++++++++++++++++++++++++++++++++-----
drivers/nvdimm/btt.h | 1
drivers/nvdimm/bus.c | 28 +++++--
drivers/nvdimm/core.c | 3 +
drivers/nvdimm/namespace_devs.c | 3 -
drivers/nvdimm/nd.h | 3 +
6 files changed, 174 insertions(+), 32 deletions(-)
diff --git a/drivers/nvdimm/blk.c b/drivers/nvdimm/blk.c
index a2749b5e43d7..feddad325f97 100644
--- a/drivers/nvdimm/blk.c
+++ b/drivers/nvdimm/blk.c
@@ -27,10 +27,17 @@ struct nd_blk_device {
struct nd_namespace_blk *nsblk;
struct nd_blk_region *ndbr;
size_t disk_size;
+ u32 sector_size;
+ u32 internal_lbasize;
};
static int nd_blk_major;
+static u32 nd_blk_meta_size(struct nd_blk_device *blk_dev)
+{
+ return blk_dev->nsblk->lbasize - blk_dev->sector_size;
+}
+
static resource_size_t to_dev_offset(struct nd_namespace_blk *nsblk,
resource_size_t ns_offset, unsigned int len)
{
@@ -52,13 +59,114 @@ static resource_size_t to_dev_offset(struct nd_namespace_blk *nsblk,
return SIZE_MAX;
}
+#ifdef CONFIG_BLK_DEV_INTEGRITY
+static int nd_blk_rw_integrity(struct nd_blk_device *blk_dev,
+ struct bio_integrity_payload *bip, u64 lba,
+ int rw)
+{
+ unsigned int len = nd_blk_meta_size(blk_dev);
+ resource_size_t dev_offset, ns_offset;
+ struct nd_namespace_blk *nsblk;
+ struct nd_blk_region *ndbr;
+ int err = 0;
+
+ nsblk = blk_dev->nsblk;
+ ndbr = blk_dev->ndbr;
+ ns_offset = lba * blk_dev->internal_lbasize + blk_dev->sector_size;
+ dev_offset = to_dev_offset(nsblk, ns_offset, len);
+ if (dev_offset == SIZE_MAX)
+ return -EIO;
+
+ while (len) {
+ unsigned int cur_len;
+ struct bio_vec bv;
+ void *iobuf;
+
+ bv = bvec_iter_bvec(bip->bip_vec, bip->bip_iter);
+ /*
+ * The 'bv' obtained from bvec_iter_bvec has its .bv_len and
+ * .bv_offset already adjusted for iter->bi_bvec_done, and we
+ * can use those directly
+ */
+
+ cur_len = min(len, bv.bv_len);
+ iobuf = kmap_atomic(bv.bv_page);
+ err = ndbr->do_io(ndbr, dev_offset, iobuf + bv.bv_offset,
+ cur_len, rw);
+ kunmap_atomic(iobuf);
+ if (err)
+ return err;
+
+ len -= cur_len;
+ dev_offset += cur_len;
+ bvec_iter_advance(bip->bip_vec, &bip->bip_iter, cur_len);
+ }
+
+ return err;
+}
+
+#else /* CONFIG_BLK_DEV_INTEGRITY */
+static int nd_blk_rw_integrity(struct nd_blk_device *blk_dev,
+ struct bio_integrity_payload *bip, u64 lba,
+ int rw)
+{
+ return 0;
+}
+#endif
+
+static int nd_blk_do_bvec(struct nd_blk_device *blk_dev,
+ struct bio_integrity_payload *bip, struct page *page,
+ unsigned int len, unsigned int off, int rw,
+ sector_t sector)
+{
+ struct nd_blk_region *ndbr = blk_dev->ndbr;
+ resource_size_t dev_offset, ns_offset;
+ int err = 0;
+ void *iobuf;
+ u64 lba;
+
+ while (len) {
+ unsigned int cur_len;
+
+ /*
+ * If we don't have an integrity payload, we don't have to
+ * split the bvec into sectors, as this would cause unnecessary
+ * Block Window setup/move steps. the do_io routine is capable
+ * of handling len <= PAGE_SIZE.
+ */
+ cur_len = bip ? min(len, blk_dev->sector_size) : len;
+
+ lba = div_u64(sector << SECTOR_SHIFT, blk_dev->sector_size);
+ ns_offset = lba * blk_dev->internal_lbasize;
+ dev_offset = to_dev_offset(blk_dev->nsblk, ns_offset, cur_len);
+ if (dev_offset == SIZE_MAX)
+ return -EIO;
+
+ iobuf = kmap_atomic(page);
+ err = ndbr->do_io(ndbr, dev_offset, iobuf + off, cur_len, rw);
+ kunmap_atomic(iobuf);
+ if (err)
+ return err;
+
+ if (bip) {
+ err = nd_blk_rw_integrity(blk_dev, bip, lba, rw);
+ if (err)
+ return err;
+ }
+ len -= cur_len;
+ off += cur_len;
+ sector += blk_dev->sector_size >> SECTOR_SHIFT;
+ }
+
+ return err;
+}
+
static void nd_blk_make_request(struct request_queue *q, struct bio *bio)
{
struct block_device *bdev = bio->bi_bdev;
struct gendisk *disk = bdev->bd_disk;
- struct nd_namespace_blk *nsblk;
+ struct bio_integrity_payload *bip;
struct nd_blk_device *blk_dev;
- struct nd_blk_region *ndbr;
struct bvec_iter iter;
struct bio_vec bvec;
int err = 0, rw;
@@ -74,29 +182,33 @@ static void nd_blk_make_request(struct request_queue *q, struct bio *bio)
rw = bio_data_dir(bio);
+ /*
+ * bio_integrity_enabled also checks if the bio already has an
+ * integrity payload attached. If it does, we *don't* do a
+ * bio_integrity_prep here - the payload has been generated by
+ * another kernel subsystem, and we just pass it through.
+ */
+ if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {
+ err = -EIO;
+ goto out;
+ }
+
+ bip = bio_integrity(bio);
blk_dev = disk->private_data;
- nsblk = blk_dev->nsblk;
- ndbr = blk_dev->ndbr;
+
bio_for_each_segment(bvec, bio, iter) {
unsigned int len = bvec.bv_len;
- resource_size_t dev_offset;
- void *iobuf;
BUG_ON(len > PAGE_SIZE);
-
- dev_offset = to_dev_offset(nsblk, sector << SECTOR_SHIFT, len);
- if (dev_offset == SIZE_MAX) {
- err = -EIO;
+ err = nd_blk_do_bvec(blk_dev, bip, bvec.bv_page, len,
+ bvec.bv_offset, rw, sector);
+ if (err) {
+ dev_info(&blk_dev->nsblk->dev,
+ "io error in %s sector %lld, len %d,\n",
+ (rw == READ) ? "READ" : "WRITE",
+ (unsigned long long) sector, len);
goto out;
}
-
- iobuf = kmap_atomic(bvec.bv_page);
- err = ndbr->do_io(ndbr, dev_offset, iobuf + bvec.bv_offset,
- len, rw);
- kunmap_atomic(iobuf);
- if (err)
- goto out;
-
sector += len >> SECTOR_SHIFT;
}
@@ -135,7 +247,8 @@ static int nd_blk_probe(struct device *dev)
struct nd_namespace_blk *nsblk = to_nd_namespace_blk(dev);
struct nd_region *nd_region = to_nd_region(dev->parent);
struct nd_blk_device *blk_dev;
- resource_size_t disk_size;
+ resource_size_t disk_size, available_disk_size;
+ u64 internal_nlba;
struct gendisk *disk;
int err;
@@ -148,6 +261,9 @@ static int nd_blk_probe(struct device *dev)
return -ENOMEM;
blk_dev->disk_size = disk_size;
+ blk_dev->sector_size = ((nsblk->lbasize >= 4096) ? 4096 : 512);
+ blk_dev->internal_lbasize = roundup(nsblk->lbasize,
+ INT_LBASIZE_ALIGNMENT);
blk_dev->queue = blk_alloc_queue(GFP_KERNEL);
if (!blk_dev->queue) {
@@ -158,7 +274,7 @@ static int nd_blk_probe(struct device *dev)
blk_queue_make_request(blk_dev->queue, nd_blk_make_request);
blk_queue_max_hw_sectors(blk_dev->queue, 1024);
blk_queue_bounce_limit(blk_dev->queue, BLK_BOUNCE_ANY);
- blk_queue_logical_block_size(blk_dev->queue, nsblk->lbasize);
+ blk_queue_logical_block_size(blk_dev->queue, blk_dev->sector_size);
disk = blk_dev->disk = alloc_disk(0);
if (!disk) {
@@ -177,13 +293,21 @@ static int nd_blk_probe(struct device *dev)
disk->queue = blk_dev->queue;
disk->flags = GENHD_FL_EXT_DEVT;
sprintf(disk->disk_name, "ndblk%d.%d", nd_region->id, nsblk->id);
- set_capacity(disk, disk_size >> SECTOR_SHIFT);
+ set_capacity(disk, 0);
+ internal_nlba = div_u64(disk_size, blk_dev->internal_lbasize);
+ available_disk_size = internal_nlba * blk_dev->sector_size;
dev_set_drvdata(dev, blk_dev);
- nvdimm_bus_add_disk(disk);
+ err = nvdimm_bus_add_integrity_disk(disk, nd_blk_meta_size(blk_dev),
+ available_disk_size >> SECTOR_SHIFT);
+ if (err)
+ goto err_add_disk;
return 0;
+ err_add_disk:
+ del_gendisk(disk);
+ put_disk(disk);
err_alloc_disk:
blk_cleanup_queue(blk_dev->queue);
err_alloc_queue:
diff --git a/drivers/nvdimm/btt.h b/drivers/nvdimm/btt.h
index 2caa0ef7e67a..75b0d80a6bd9 100644
--- a/drivers/nvdimm/btt.h
+++ b/drivers/nvdimm/btt.h
@@ -31,7 +31,6 @@
#define ARENA_MAX_SIZE (1ULL << 39) /* 512 GB */
#define RTT_VALID (1UL << 31)
#define RTT_INVALID 0
-#define INT_LBASIZE_ALIGNMENT 64
#define BTT_PG_SIZE 4096
#define BTT_DEFAULT_NFREE ND_MAX_LANES
#define LOG_SEQ_INIT 1
diff --git a/drivers/nvdimm/bus.c b/drivers/nvdimm/bus.c
index 3c14fee5aff4..d4fbc48f5643 100644
--- a/drivers/nvdimm/bus.c
+++ b/drivers/nvdimm/bus.c
@@ -243,17 +243,13 @@ int __nd_driver_register(struct nd_device_driver *nd_drv, struct module *owner,
}
EXPORT_SYMBOL(__nd_driver_register);
-/**
- * nvdimm_bus_add_disk() - attach and run actions on an nvdimm block device
- * @disk: disk device being registered
- *
- * Note, that @disk must be a descendant of an nvdimm_bus
- */
-int nvdimm_bus_add_disk(struct gendisk *disk)
+int nvdimm_bus_add_integrity_disk(struct gendisk *disk, u32 lbasize,
+ sector_t size)
{
const struct block_device_operations *ops = disk->fops;
struct device *dev = disk->driverfs_dev;
struct nvdimm_bus *nvdimm_bus;
+ int rc;
nvdimm_bus = walk_to_nvdimm_bus(dev);
if (!nvdimm_bus || !ops->rw_bytes)
@@ -266,10 +262,25 @@ int nvdimm_bus_add_disk(struct gendisk *disk)
*/
nvdimm_bus_lock(&nvdimm_bus->dev);
add_disk(disk);
+ rc = nd_integrity_init(disk, lbasize);
+ if (size)
+ set_capacity(disk, size);
nd_btt_add_disk(nvdimm_bus, disk);
nvdimm_bus_unlock(&nvdimm_bus->dev);
- return 0;
+ return rc;
+}
+EXPORT_SYMBOL(nvdimm_bus_add_integrity_disk);
+
+/**
+ * nvdimm_bus_add_disk() - attach and run actions on an nvdimm block device
+ * @disk: disk device being registered
+ *
+ * Note, that @disk must be a descendant of an nvdimm_bus
+ */
+int nvdimm_bus_add_disk(struct gendisk *disk)
+{
+ return nvdimm_bus_add_integrity_disk(disk, 0, 0);
}
EXPORT_SYMBOL(nvdimm_bus_add_disk);
@@ -292,6 +303,7 @@ void nvdimm_bus_remove_disk(struct gendisk *disk)
*/
nd_synchronize();
+ blk_integrity_unregister(disk);
del_gendisk(disk);
put_disk(disk);
}
diff --git a/drivers/nvdimm/core.c b/drivers/nvdimm/core.c
index 36f112995c0c..8f466c384b30 100644
--- a/drivers/nvdimm/core.c
+++ b/drivers/nvdimm/core.c
@@ -399,6 +399,9 @@ int nd_integrity_init(struct gendisk *disk, unsigned long meta_size)
};
int ret;
+ if (meta_size == 0)
+ return 0;
+
ret = blk_integrity_register(disk, &integrity);
if (ret)
return ret;
diff --git a/drivers/nvdimm/namespace_devs.c b/drivers/nvdimm/namespace_devs.c
index 68780d768e7b..0fe541a1df49 100644
--- a/drivers/nvdimm/namespace_devs.c
+++ b/drivers/nvdimm/namespace_devs.c
@@ -1013,7 +1013,8 @@ static ssize_t resource_show(struct device *dev,
}
static DEVICE_ATTR_RO(resource);
-static const unsigned long ns_lbasize_supported[] = { 512, 0 };
+static const unsigned long ns_lbasize_supported[] = { 512, 520, 528,
+ 4096, 4104, 4160, 4224, 0 };
static ssize_t sector_size_show(struct device *dev,
struct device_attribute *attr, char *buf)
diff --git a/drivers/nvdimm/nd.h b/drivers/nvdimm/nd.h
index 1cea3f191a83..9b5fdb2215b1 100644
--- a/drivers/nvdimm/nd.h
+++ b/drivers/nvdimm/nd.h
@@ -29,6 +29,7 @@ enum {
*/
ND_MAX_LANES = 256,
SECTOR_SHIFT = 9,
+ INT_LBASIZE_ALIGNMENT = 64,
};
struct nvdimm_drvdata {
@@ -159,6 +160,8 @@ void nvdimm_bus_lock(struct device *dev);
void nvdimm_bus_unlock(struct device *dev);
bool is_nvdimm_bus_locked(struct device *dev);
int nvdimm_bus_add_disk(struct gendisk *disk);
+int nvdimm_bus_add_integrity_disk(struct gendisk *disk, u32 lbasize,
+ sector_t size);
void nvdimm_bus_remove_disk(struct gendisk *disk);
void nvdimm_drvdata_release(struct kref *kref);
void put_ndd(struct nvdimm_drvdata *ndd);
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
| From | Dan Williams <dan.j.williams@intel.com> |
|---|---|
| Date | 2015-06-18 02:00 +0200 |
| Subject | [PATCH 15/15] libnvdimm, nfit: handle acpi_nfit_memory_map flags |
| Message-ID | <pCvpp-8ib-31@gated-at.bofh.it> |
| In reply to | #1167489 |
The flags in this NFIT sub-structure indicate the state of the data on
the nvdimm relative to its energy source or last "flush to persistence".
For the most part there is nothing the driver can do but advertise the
state of these flags in sysfs and emit a message if firmware indicates
that the contents of the device may be corrupted. However, for the case
of ACPI_NFIT_MEM_ARMED, the driver can arrange for the block devices
incorporating that nvdimm to be marked read-only. This is a safe
default as the data is still available and new writes are held off until
the administrator either forces read-write mode, or the energy source
becomes armed.
A module parameter "force_rw" is added to allow the default to be
overridden.
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/acpi/nfit.c | 35 +++++++++++++++++++++++++++++++++++
drivers/acpi/nfit.h | 3 +++
drivers/nvdimm/blk.c | 1 +
drivers/nvdimm/bus.c | 27 +++++++++++++++++++++++++++
drivers/nvdimm/nd-core.h | 1 +
drivers/nvdimm/nd.h | 1 +
drivers/nvdimm/pmem.c | 1 +
drivers/nvdimm/region_devs.c | 13 +++++++++++++
include/linux/libnvdimm.h | 2 ++
tools/testing/nvdimm/test/nfit.c | 3 +++
10 files changed, 87 insertions(+)
diff --git a/drivers/acpi/nfit.c b/drivers/acpi/nfit.c
index 9363e4b0e6a7..5f645823d7d7 100644
--- a/drivers/acpi/nfit.c
+++ b/drivers/acpi/nfit.c
@@ -27,6 +27,10 @@ static bool force_enable_dimms;
module_param(force_enable_dimms, bool, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(force_enable_dimms, "Ignore _STA (ACPI DIMM device) status");
+static bool force_rw;
+module_param(force_rw, bool, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(force_rw, "Enable writes to DIMMs that failed to arm");
+
static u8 nfit_uuid[NFIT_UUID_MAX][16];
const u8 *to_nfit_uuid(enum nfit_uuids id)
@@ -664,6 +668,20 @@ static ssize_t serial_show(struct device *dev,
}
static DEVICE_ATTR_RO(serial);
+static ssize_t flags_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ u16 flags = to_nfit_memdev(dev)->flags;
+
+ return sprintf(buf, "%s%s%s%s%s\n",
+ flags & ACPI_NFIT_MEM_SAVE_FAILED ? "save " : "",
+ flags & ACPI_NFIT_MEM_RESTORE_FAILED ? "restore " : "",
+ flags & ACPI_NFIT_MEM_FLUSH_FAILED ? "flush " : "",
+ flags & ACPI_NFIT_MEM_ARMED ? "arm " : "",
+ flags & ACPI_NFIT_MEM_HEALTH_OBSERVED ? "smart " : "");
+}
+static DEVICE_ATTR_RO(flags);
+
static struct attribute *acpi_nfit_dimm_attributes[] = {
&dev_attr_handle.attr,
&dev_attr_phys_id.attr,
@@ -672,6 +690,7 @@ static struct attribute *acpi_nfit_dimm_attributes[] = {
&dev_attr_format.attr,
&dev_attr_serial.attr,
&dev_attr_rev_id.attr,
+ &dev_attr_flags.attr,
NULL,
};
@@ -764,6 +783,7 @@ static int acpi_nfit_register_dimms(struct acpi_nfit_desc *acpi_desc)
struct nvdimm *nvdimm;
unsigned long flags = 0;
u32 device_handle;
+ u16 mem_flags;
int rc;
device_handle = __to_nfit_memdev(nfit_mem)->device_handle;
@@ -781,6 +801,10 @@ static int acpi_nfit_register_dimms(struct acpi_nfit_desc *acpi_desc)
if (nfit_mem->bdw && nfit_mem->memdev_pmem)
flags |= NDD_ALIASING;
+ mem_flags = __to_nfit_memdev(nfit_mem)->flags;
+ if ((mem_flags & ACPI_NFIT_MEM_ARMED) && !force_rw)
+ flags |= NDD_UNARMED;
+
rc = acpi_nfit_add_dimm(acpi_desc, nfit_mem, device_handle);
if (rc)
continue;
@@ -793,6 +817,17 @@ static int acpi_nfit_register_dimms(struct acpi_nfit_desc *acpi_desc)
nfit_mem->nvdimm = nvdimm;
dimm_count++;
+
+ if ((mem_flags & ACPI_NFIT_MEM_FAILED_MASK) == 0)
+ continue;
+
+ dev_info(acpi_desc->dev, "%s: failed: %s%s%s%s\n",
+ nvdimm_name(nvdimm),
+ mem_flags & ACPI_NFIT_MEM_SAVE_FAILED ? "save " : "",
+ mem_flags & ACPI_NFIT_MEM_RESTORE_FAILED ? "restore " : "",
+ mem_flags & ACPI_NFIT_MEM_FLUSH_FAILED ? "flush " : "",
+ mem_flags & ACPI_NFIT_MEM_ARMED ? "arm " : "");
+
}
return nvdimm_bus_check_dimm_count(acpi_desc->nvdimm_bus, dimm_count);
diff --git a/drivers/acpi/nfit.h b/drivers/acpi/nfit.h
index c62fffea8423..81f2e8c5a79c 100644
--- a/drivers/acpi/nfit.h
+++ b/drivers/acpi/nfit.h
@@ -22,6 +22,9 @@
#define UUID_NFIT_BUS "2f10e7a4-9e91-11e4-89d3-123b93f75cba"
#define UUID_NFIT_DIMM "4309ac30-0d11-11e4-9191-0800200c9a66"
+#define ACPI_NFIT_MEM_FAILED_MASK (ACPI_NFIT_MEM_SAVE_FAILED \
+ | ACPI_NFIT_MEM_RESTORE_FAILED | ACPI_NFIT_MEM_FLUSH_FAILED \
+ | ACPI_NFIT_MEM_ARMED)
enum nfit_uuids {
NFIT_SPA_VOLATILE,
diff --git a/drivers/nvdimm/blk.c b/drivers/nvdimm/blk.c
index adacc27f04f1..0b359cb8aa9f 100644
--- a/drivers/nvdimm/blk.c
+++ b/drivers/nvdimm/blk.c
@@ -243,6 +243,7 @@ static const struct block_device_operations nd_blk_fops = {
#ifdef CONFIG_COMPAT
.compat_ioctl = nvdimm_bdev_compat_ioctl,
#endif
+ .revalidate_disk = nvdimm_revalidate_disk,
};
static int nd_blk_probe(struct device *dev)
diff --git a/drivers/nvdimm/bus.c b/drivers/nvdimm/bus.c
index 47260ca573e0..67525f995859 100644
--- a/drivers/nvdimm/bus.c
+++ b/drivers/nvdimm/bus.c
@@ -243,6 +243,32 @@ int __nd_driver_register(struct nd_device_driver *nd_drv, struct module *owner,
}
EXPORT_SYMBOL(__nd_driver_register);
+int nvdimm_revalidate_disk(struct gendisk *disk)
+{
+ int i;
+ struct device *dev = disk->driverfs_dev;
+ struct nd_region *nd_region = walk_to_nd_region(dev);
+
+ if (!nd_region)
+ return 0;
+
+ for (i = 0; i < nd_region->ndr_mappings; i++) {
+ struct nd_mapping *nd_mapping = &nd_region->mapping[i];
+ struct nvdimm *nvdimm = nd_mapping->nvdimm;
+
+ if ((nvdimm->flags & NDD_UNARMED) && !get_disk_ro(disk)) {
+ dev_dbg(dev, "%s: unarmed, marking disk %s ro\n",
+ dev_name(&nvdimm->dev),
+ dev_name(disk_to_dev(disk)));
+ set_disk_ro(disk, 1);
+ break;
+ }
+ }
+
+ return 0;
+}
+EXPORT_SYMBOL(nvdimm_revalidate_disk);
+
int nvdimm_bus_add_integrity_disk(struct gendisk *disk, u32 lbasize,
sector_t size)
{
@@ -265,6 +291,7 @@ int nvdimm_bus_add_integrity_disk(struct gendisk *disk, u32 lbasize,
rc = nd_integrity_init(disk, lbasize);
if (size)
set_capacity(disk, size);
+ revalidate_disk(disk);
nd_btt_add_disk(nvdimm_bus, disk);
nvdimm_bus_unlock(&nvdimm_bus->dev);
diff --git a/drivers/nvdimm/nd-core.h b/drivers/nvdimm/nd-core.h
index ba548d248b4e..0cac05aca8f5 100644
--- a/drivers/nvdimm/nd-core.h
+++ b/drivers/nvdimm/nd-core.h
@@ -110,6 +110,7 @@ bool nd_is_uuid_unique(struct device *dev, u8 *uuid);
struct nd_region;
struct nvdimm_drvdata;
struct nd_mapping;
+struct nd_region *walk_to_nd_region(struct device *nd_dev);
resource_size_t nd_pmem_available_dpa(struct nd_region *nd_region,
struct nd_mapping *nd_mapping, resource_size_t *overlap);
resource_size_t nd_blk_available_dpa(struct nd_mapping *nd_mapping);
diff --git a/drivers/nvdimm/nd.h b/drivers/nvdimm/nd.h
index 2786eb8456ec..011d7c51b5da 100644
--- a/drivers/nvdimm/nd.h
+++ b/drivers/nvdimm/nd.h
@@ -168,6 +168,7 @@ int nvdimm_bdev_ioctl(struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long arg);
int nvdimm_bdev_compat_ioctl(struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long arg);
+int nvdimm_revalidate_disk(struct gendisk *disk);
void nvdimm_drvdata_release(struct kref *kref);
void put_ndd(struct nvdimm_drvdata *ndd);
int nd_label_reserve_dpa(struct nvdimm_drvdata *ndd);
diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c
index 96964419b72d..b69278424dff 100644
--- a/drivers/nvdimm/pmem.c
+++ b/drivers/nvdimm/pmem.c
@@ -135,6 +135,7 @@ static const struct block_device_operations pmem_fops = {
#ifdef CONFIG_COMPAT
.compat_ioctl = nvdimm_bdev_ioctl,
#endif
+ .revalidate_disk = nvdimm_revalidate_disk,
};
static struct pmem_device *pmem_alloc(struct device *dev,
diff --git a/drivers/nvdimm/region_devs.c b/drivers/nvdimm/region_devs.c
index b16ec20dbba2..bb9f329c3b9f 100644
--- a/drivers/nvdimm/region_devs.c
+++ b/drivers/nvdimm/region_devs.c
@@ -83,6 +83,19 @@ struct nd_blk_region *to_nd_blk_region(struct device *dev)
}
EXPORT_SYMBOL_GPL(to_nd_blk_region);
+struct nd_region *walk_to_nd_region(struct device *nd_dev)
+{
+ struct device *dev;
+
+ for (dev = nd_dev; dev; dev = dev->parent)
+ if (dev->type->release == nd_region_release)
+ break;
+ dev_WARN_ONCE(nd_dev, !dev, "invalid dev, not an nd_region descendant\n");
+ if (dev)
+ return to_nd_region(dev);
+ return NULL;
+}
+
void *nd_region_provider_data(struct nd_region *nd_region)
{
return nd_region->provider_data;
diff --git a/include/linux/libnvdimm.h b/include/linux/libnvdimm.h
index 7fc1b25bdb5d..dc799a29ed1a 100644
--- a/include/linux/libnvdimm.h
+++ b/include/linux/libnvdimm.h
@@ -21,6 +21,8 @@
enum {
/* when a dimm supports both PMEM and BLK access a label is required */
NDD_ALIASING = 1 << 0,
+ /* unarmed memory devices may not persist writes */
+ NDD_UNARMED = 1 << 1,
/* need to set a limit somewhere, but yes, this is likely overkill */
ND_IOCTL_MAX_BUFLEN = SZ_4M,
diff --git a/tools/testing/nvdimm/test/nfit.c b/tools/testing/nvdimm/test/nfit.c
index 416f8fbf9881..c57ecb4e421d 100644
--- a/tools/testing/nvdimm/test/nfit.c
+++ b/tools/testing/nvdimm/test/nfit.c
@@ -873,6 +873,9 @@ static void nfit_test1_setup(struct nfit_test *t)
memdev->address = 0;
memdev->interleave_index = 0;
memdev->interleave_ways = 1;
+ memdev->flags = ACPI_NFIT_MEM_SAVE_FAILED | ACPI_NFIT_MEM_RESTORE_FAILED
+ | ACPI_NFIT_MEM_FLUSH_FAILED | ACPI_NFIT_MEM_HEALTH_OBSERVED
+ | ACPI_NFIT_MEM_ARMED;
offset += sizeof(*memdev);
/* dcr-descriptor0 */
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
| From | Dan Williams <dan.j.williams@intel.com> |
|---|---|
| Date | 2015-06-18 02:10 +0200 |
| Subject | [PATCH 11/15] libnvdimm: pmem, blk, and btt make_request cleanups |
| Message-ID | <pCvz3-gO-5@gated-at.bofh.it> |
| In reply to | #1167489 |
Various cleanups:
1/ kill the BUG_ONs since we've already told the block layer we don't
support DISCARD on all these drivers.
2/ Fix up use of 'rw'. No need to cache it in the pmem driver and for
btt using bio_data_dir() saves a check for READA.
3/ Kill the local 'sector' variables. bio_for_each_segment() is already
advancing the iterator's sector number by the bio_vec length.
Reviewed-by: Vishal Verma <vishal.l.verma@linux.intel.com>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/nvdimm/blk.c | 14 ++++----------
drivers/nvdimm/btt.c | 18 +++++-------------
drivers/nvdimm/pmem.c | 20 ++++++--------------
3 files changed, 15 insertions(+), 37 deletions(-)
diff --git a/drivers/nvdimm/blk.c b/drivers/nvdimm/blk.c
index 8a6345797a71..9d609ef95266 100644
--- a/drivers/nvdimm/blk.c
+++ b/drivers/nvdimm/blk.c
@@ -170,18 +170,12 @@ static void nd_blk_make_request(struct request_queue *q, struct bio *bio)
struct bvec_iter iter;
struct bio_vec bvec;
int err = 0, rw;
- sector_t sector;
- sector = bio->bi_iter.bi_sector;
- if (bio_end_sector(bio) > get_capacity(disk)) {
+ if (unlikely(bio_end_sector(bio) > get_capacity(disk))) {
err = -EIO;
goto out;
}
- BUG_ON(bio->bi_rw & REQ_DISCARD);
-
- rw = bio_data_dir(bio);
-
/*
* bio_integrity_enabled also checks if the bio already has an
* integrity payload attached. If it does, we *don't* do a
@@ -196,20 +190,20 @@ static void nd_blk_make_request(struct request_queue *q, struct bio *bio)
bip = bio_integrity(bio);
blk_dev = disk->private_data;
+ rw = bio_data_dir(bio);
bio_for_each_segment(bvec, bio, iter) {
unsigned int len = bvec.bv_len;
BUG_ON(len > PAGE_SIZE);
err = nd_blk_do_bvec(blk_dev, bip, bvec.bv_page, len,
- bvec.bv_offset, rw, sector);
+ bvec.bv_offset, rw, iter.bi_sector);
if (err) {
dev_info(&blk_dev->nsblk->dev,
"io error in %s sector %lld, len %d,\n",
(rw == READ) ? "READ" : "WRITE",
- (unsigned long long) sector, len);
+ (unsigned long long) iter.bi_sector, len);
goto out;
}
- sector += len >> SECTOR_SHIFT;
}
out:
diff --git a/drivers/nvdimm/btt.c b/drivers/nvdimm/btt.c
index 380e01cedd24..83b798dd2e68 100644
--- a/drivers/nvdimm/btt.c
+++ b/drivers/nvdimm/btt.c
@@ -1177,23 +1177,16 @@ static void btt_make_request(struct request_queue *q, struct bio *bio)
struct bio_integrity_payload *bip = bio_integrity(bio);
struct block_device *bdev = bio->bi_bdev;
struct btt *btt = q->queuedata;
- int rw;
- struct bio_vec bvec;
- sector_t sector;
struct bvec_iter iter;
- int err = 0;
+ struct bio_vec bvec;
+ int err = 0, rw;
- sector = bio->bi_iter.bi_sector;
if (bio_end_sector(bio) > get_capacity(bdev->bd_disk)) {
err = -EIO;
goto out;
}
- BUG_ON(bio->bi_rw & REQ_DISCARD);
-
- rw = bio_rw(bio);
- if (rw == READA)
- rw = READ;
+ rw = bio_data_dir(bio);
/*
* bio_integrity_enabled also checks if the bio already has an
@@ -1216,15 +1209,14 @@ static void btt_make_request(struct request_queue *q, struct bio *bio)
BUG_ON(len % btt->sector_size);
err = btt_do_bvec(btt, bip, bvec.bv_page, len, bvec.bv_offset,
- rw, sector);
+ rw, iter.bi_sector);
if (err) {
dev_info(&btt->nd_btt->dev,
"io error in %s sector %lld, len %d,\n",
(rw == READ) ? "READ" : "WRITE",
- (unsigned long long) sector, len);
+ (unsigned long long) iter.bi_sector, len);
goto out;
}
- sector += len >> SECTOR_SHIFT;
}
out:
diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c
index b825a2201aa8..0337b00f5409 100644
--- a/drivers/nvdimm/pmem.c
+++ b/drivers/nvdimm/pmem.c
@@ -58,28 +58,20 @@ static void pmem_do_bvec(struct pmem_device *pmem, struct page *page,
static void pmem_make_request(struct request_queue *q, struct bio *bio)
{
- struct block_device *bdev = bio->bi_bdev;
- struct pmem_device *pmem = bdev->bd_disk->private_data;
- int rw;
+ int err = 0;
struct bio_vec bvec;
- sector_t sector;
struct bvec_iter iter;
- int err = 0;
+ struct block_device *bdev = bio->bi_bdev;
+ struct pmem_device *pmem = bdev->bd_disk->private_data;
- if (bio_end_sector(bio) > get_capacity(bdev->bd_disk)) {
+ if (unlikely(bio_end_sector(bio) > get_capacity(bdev->bd_disk))) {
err = -EIO;
goto out;
}
- BUG_ON(bio->bi_rw & REQ_DISCARD);
-
- rw = bio_data_dir(bio);
- sector = bio->bi_iter.bi_sector;
- bio_for_each_segment(bvec, bio, iter) {
+ bio_for_each_segment(bvec, bio, iter)
pmem_do_bvec(pmem, bvec.bv_page, bvec.bv_len, bvec.bv_offset,
- rw, sector);
- sector += bvec.bv_len >> 9;
- }
+ bio_data_dir(bio), iter.bi_sector);
out:
bio_endio(bio, err);
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
| From | Christoph Hellwig <hch@lst.de> |
|---|---|
| Date | 2015-06-21 12:20 +0200 |
| Subject | Re: [PATCH 11/15] libnvdimm: pmem, blk, and btt make_request cleanups |
| Message-ID | <pDKw1-29u-1@gated-at.bofh.it> |
| In reply to | #1167501 |
One patch per driver please.
> diff --git a/drivers/nvdimm/blk.c b/drivers/nvdimm/blk.c
> index 8a6345797a71..9d609ef95266 100644
> --- a/drivers/nvdimm/blk.c
> +++ b/drivers/nvdimm/blk.c
> @@ -170,18 +170,12 @@ static void nd_blk_make_request(struct request_queue *q, struct bio *bio)
> struct bvec_iter iter;
> struct bio_vec bvec;
> int err = 0, rw;
> - sector_t sector;
>
> - sector = bio->bi_iter.bi_sector;
> - if (bio_end_sector(bio) > get_capacity(disk)) {
> + if (unlikely(bio_end_sector(bio) > get_capacity(disk))) {
> err = -EIO;
> goto out;
> }
>
> - BUG_ON(bio->bi_rw & REQ_DISCARD);
If you remove the DISCARD check you can kill the max sectors one
as well, given that generic_make_request_checks() takes care of it.
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
| From | Dan Williams <dan.j.williams@intel.com> |
|---|---|
| Date | 2015-06-18 02:10 +0200 |
| Subject | [PATCH 08/15] libnvdimm, btt: add support for blk integrity |
| Message-ID | <pCvz3-gO-7@gated-at.bofh.it> |
| In reply to | #1167489 |
From: Vishal Verma <vishal.l.verma@linux.intel.com>
Support multiple block sizes (sector + metadata) using the blk integrity
framework. This registers a new integrity template that defines the
protection information tuple size based on the configured metadata size,
and simply acts as a passthrough for protection information generated by
another layer. The metadata is written to the storage as-is, and read back
with each sector.
Signed-off-by: Vishal Verma <vishal.l.verma@linux.intel.com>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/nvdimm/btt.c | 126 +++++++++++++++++++++++++++++++++++++++------
drivers/nvdimm/btt.h | 2 -
drivers/nvdimm/btt_devs.c | 3 +
drivers/nvdimm/core.c | 37 +++++++++++++
drivers/nvdimm/nd.h | 1
5 files changed, 151 insertions(+), 18 deletions(-)
diff --git a/drivers/nvdimm/btt.c b/drivers/nvdimm/btt.c
index 58becbd69ae1..c337b7abfb43 100644
--- a/drivers/nvdimm/btt.c
+++ b/drivers/nvdimm/btt.c
@@ -837,6 +837,11 @@ static int btt_meta_init(struct btt *btt)
return ret;
}
+static u32 btt_meta_size(struct btt *btt)
+{
+ return btt->lbasize - btt->sector_size;
+}
+
/*
* This function calculates the arena in which the given LBA lies
* by doing a linear walk. This is acceptable since we expect only
@@ -921,8 +926,63 @@ static void zero_fill_data(struct page *page, unsigned int off, u32 len)
kunmap_atomic(mem);
}
-static int btt_read_pg(struct btt *btt, struct page *page, unsigned int off,
- sector_t sector, unsigned int len)
+#ifdef CONFIG_BLK_DEV_INTEGRITY
+static int btt_rw_integrity(struct btt *btt, struct bio_integrity_payload *bip,
+ struct arena_info *arena, u32 postmap, int rw)
+{
+ unsigned int len = btt_meta_size(btt);
+ u64 meta_nsoff;
+ int ret = 0;
+
+ if (bip == NULL)
+ return 0;
+
+ meta_nsoff = to_namespace_offset(arena, postmap) + btt->sector_size;
+
+ while (len) {
+ unsigned int cur_len;
+ struct bio_vec bv;
+ void *mem;
+
+ bv = bvec_iter_bvec(bip->bip_vec, bip->bip_iter);
+ /*
+ * The 'bv' obtained from bvec_iter_bvec has its .bv_len and
+ * .bv_offset already adjusted for iter->bi_bvec_done, and we
+ * can use those directly
+ */
+
+ cur_len = min(len, bv.bv_len);
+ mem = kmap_atomic(bv.bv_page);
+ if (rw)
+ ret = arena_write_bytes(arena, meta_nsoff,
+ mem + bv.bv_offset, cur_len);
+ else
+ ret = arena_read_bytes(arena, meta_nsoff,
+ mem + bv.bv_offset, cur_len);
+
+ kunmap_atomic(mem);
+ if (ret)
+ return ret;
+
+ len -= cur_len;
+ meta_nsoff += cur_len;
+ bvec_iter_advance(bip->bip_vec, &bip->bip_iter, cur_len);
+ }
+
+ return ret;
+}
+
+#else /* CONFIG_BLK_DEV_INTEGRITY */
+static int btt_rw_integrity(struct btt *btt, struct bio_integrity_payload *bip,
+ struct arena_info *arena, u32 postmap, int rw)
+{
+ return 0;
+}
+#endif
+
+static int btt_read_pg(struct btt *btt, struct bio_integrity_payload *bip,
+ struct page *page, unsigned int off, sector_t sector,
+ unsigned int len)
{
int ret = 0;
int t_flag, e_flag;
@@ -984,6 +1044,12 @@ static int btt_read_pg(struct btt *btt, struct page *page, unsigned int off,
if (ret)
goto out_rtt;
+ if (bip) {
+ ret = btt_rw_integrity(btt, bip, arena, postmap, READ);
+ if (ret)
+ goto out_rtt;
+ }
+
arena->rtt[lane] = RTT_INVALID;
nd_region_release_lane(btt->nd_region, lane);
@@ -1001,8 +1067,9 @@ static int btt_read_pg(struct btt *btt, struct page *page, unsigned int off,
return ret;
}
-static int btt_write_pg(struct btt *btt, sector_t sector, struct page *page,
- unsigned int off, unsigned int len)
+static int btt_write_pg(struct btt *btt, struct bio_integrity_payload *bip,
+ sector_t sector, struct page *page, unsigned int off,
+ unsigned int len)
{
int ret = 0;
struct arena_info *arena = NULL;
@@ -1036,12 +1103,19 @@ static int btt_write_pg(struct btt *btt, sector_t sector, struct page *page,
if (new_postmap >= arena->internal_nlba) {
ret = -EIO;
goto out_lane;
- } else
- ret = btt_data_write(arena, new_postmap, page,
- off, cur_len);
+ }
+
+ ret = btt_data_write(arena, new_postmap, page, off, cur_len);
if (ret)
goto out_lane;
+ if (bip) {
+ ret = btt_rw_integrity(btt, bip, arena, new_postmap,
+ WRITE);
+ if (ret)
+ goto out_lane;
+ }
+
lock_map(arena, premap);
ret = btt_map_read(arena, premap, &old_postmap, NULL, NULL);
if (ret)
@@ -1081,18 +1155,18 @@ static int btt_write_pg(struct btt *btt, sector_t sector, struct page *page,
return ret;
}
-static int btt_do_bvec(struct btt *btt, struct page *page,
- unsigned int len, unsigned int off, int rw,
- sector_t sector)
+static int btt_do_bvec(struct btt *btt, struct bio_integrity_payload *bip,
+ struct page *page, unsigned int len, unsigned int off,
+ int rw, sector_t sector)
{
int ret;
if (rw == READ) {
- ret = btt_read_pg(btt, page, off, sector, len);
+ ret = btt_read_pg(btt, bip, page, off, sector, len);
flush_dcache_page(page);
} else {
flush_dcache_page(page);
- ret = btt_write_pg(btt, sector, page, off, len);
+ ret = btt_write_pg(btt, bip, sector, page, off, len);
}
return ret;
@@ -1100,6 +1174,7 @@ static int btt_do_bvec(struct btt *btt, struct page *page,
static void btt_make_request(struct request_queue *q, struct bio *bio)
{
+ struct bio_integrity_payload *bip = bio_integrity(bio);
struct block_device *bdev = bio->bi_bdev;
struct btt *btt = q->queuedata;
int rw;
@@ -1120,6 +1195,17 @@ static void btt_make_request(struct request_queue *q, struct bio *bio)
if (rw == READA)
rw = READ;
+ /*
+ * bio_integrity_enabled also checks if the bio already has an
+ * integrity payload attached. If it does, we *don't* do a
+ * bio_integrity_prep here - the payload has been generated by
+ * another kernel subsystem, and we just pass it through.
+ */
+ if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {
+ err = -EIO;
+ goto out;
+ }
+
bio_for_each_segment(bvec, bio, iter) {
unsigned int len = bvec.bv_len;
@@ -1129,7 +1215,7 @@ static void btt_make_request(struct request_queue *q, struct bio *bio)
BUG_ON(len < btt->sector_size);
BUG_ON(len % btt->sector_size);
- err = btt_do_bvec(btt, bvec.bv_page, len, bvec.bv_offset,
+ err = btt_do_bvec(btt, bip, bvec.bv_page, len, bvec.bv_offset,
rw, sector);
if (err) {
dev_info(&btt->nd_btt->dev,
@@ -1150,7 +1236,7 @@ static int btt_rw_page(struct block_device *bdev, sector_t sector,
{
struct btt *btt = bdev->bd_disk->private_data;
- btt_do_bvec(btt, page, PAGE_CACHE_SIZE, 0, rw, sector);
+ btt_do_bvec(btt, NULL, page, PAGE_CACHE_SIZE, 0, rw, sector);
page_endio(page, rw & WRITE, 0);
return 0;
}
@@ -1204,10 +1290,17 @@ static int btt_blk_init(struct btt *btt)
blk_queue_logical_block_size(btt->btt_queue, btt->sector_size);
btt->btt_queue->queuedata = btt;
- set_capacity(btt->btt_disk,
- btt->nlba * btt->sector_size >> SECTOR_SHIFT);
+ set_capacity(btt->btt_disk, 0);
add_disk(btt->btt_disk);
+ if (btt_meta_size(btt)) {
+ ret = nd_integrity_init(btt->btt_disk, btt_meta_size(btt));
+ if (ret)
+ goto out_free_queue;
+ }
+
+ set_capacity(btt->btt_disk, btt->nlba * btt->sector_size >> 9);
+
return 0;
out_free_queue:
@@ -1217,6 +1310,7 @@ out_free_queue:
static void btt_blk_cleanup(struct btt *btt)
{
+ blk_integrity_unregister(btt->btt_disk);
del_gendisk(btt->btt_disk);
put_disk(btt->btt_disk);
blk_cleanup_queue(btt->btt_queue);
diff --git a/drivers/nvdimm/btt.h b/drivers/nvdimm/btt.h
index 8c95a7792c3e..2caa0ef7e67a 100644
--- a/drivers/nvdimm/btt.h
+++ b/drivers/nvdimm/btt.h
@@ -31,7 +31,7 @@
#define ARENA_MAX_SIZE (1ULL << 39) /* 512 GB */
#define RTT_VALID (1UL << 31)
#define RTT_INVALID 0
-#define INT_LBASIZE_ALIGNMENT 256
+#define INT_LBASIZE_ALIGNMENT 64
#define BTT_PG_SIZE 4096
#define BTT_DEFAULT_NFREE ND_MAX_LANES
#define LOG_SEQ_INIT 1
diff --git a/drivers/nvdimm/btt_devs.c b/drivers/nvdimm/btt_devs.c
index c03c854f892b..02e125b91e77 100644
--- a/drivers/nvdimm/btt_devs.c
+++ b/drivers/nvdimm/btt_devs.c
@@ -53,7 +53,8 @@ struct nd_btt *to_nd_btt(struct device *dev)
}
EXPORT_SYMBOL(to_nd_btt);
-static const unsigned long btt_lbasize_supported[] = { 512, 4096, 0 };
+static const unsigned long btt_lbasize_supported[] = { 512, 520, 528,
+ 4096, 4104, 4160, 4224, 0 };
static ssize_t sector_size_show(struct device *dev,
struct device_attribute *attr, char *buf)
diff --git a/drivers/nvdimm/core.c b/drivers/nvdimm/core.c
index 0fa9b6225450..36f112995c0c 100644
--- a/drivers/nvdimm/core.c
+++ b/drivers/nvdimm/core.c
@@ -13,6 +13,7 @@
#include <linux/libnvdimm.h>
#include <linux/export.h>
#include <linux/module.h>
+#include <linux/blkdev.h>
#include <linux/device.h>
#include <linux/ctype.h>
#include <linux/ndctl.h>
@@ -381,6 +382,42 @@ void nvdimm_bus_unregister(struct nvdimm_bus *nvdimm_bus)
}
EXPORT_SYMBOL_GPL(nvdimm_bus_unregister);
+#ifdef CONFIG_BLK_DEV_INTEGRITY
+static int nd_pi_nop_generate_verify(struct blk_integrity_iter *iter)
+{
+ return 0;
+}
+
+int nd_integrity_init(struct gendisk *disk, unsigned long meta_size)
+{
+ struct blk_integrity integrity = {
+ .name = "ND-PI-NOP",
+ .generate_fn = nd_pi_nop_generate_verify,
+ .verify_fn = nd_pi_nop_generate_verify,
+ .tuple_size = meta_size,
+ .tag_size = meta_size,
+ };
+ int ret;
+
+ ret = blk_integrity_register(disk, &integrity);
+ if (ret)
+ return ret;
+
+ blk_queue_max_integrity_segments(disk->queue, 1);
+
+ return 0;
+}
+EXPORT_SYMBOL(nd_integrity_init);
+
+#else /* CONFIG_BLK_DEV_INTEGRITY */
+int nd_integrity_init(struct gendisk *disk, unsigned long meta_size)
+{
+ return 0;
+}
+EXPORT_SYMBOL(nd_integrity_init);
+
+#endif
+
static __init int libnvdimm_init(void)
{
int rc;
diff --git a/drivers/nvdimm/nd.h b/drivers/nvdimm/nd.h
index 2b7746e798fb..1cea3f191a83 100644
--- a/drivers/nvdimm/nd.h
+++ b/drivers/nvdimm/nd.h
@@ -128,6 +128,7 @@ enum nd_async_mode {
ND_ASYNC,
};
+int nd_integrity_init(struct gendisk *disk, unsigned long meta_size);
void wait_nvdimm_bus_probe_idle(struct device *dev);
void nd_device_register(struct device *dev);
void nd_device_unregister(struct device *dev, enum nd_async_mode mode);
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
| From | Dan Williams <dan.j.williams@intel.com> |
|---|---|
| Date | 2015-06-18 02:10 +0200 |
| Subject | [PATCH 02/15] libnvdimm: infrastructure for btt devices |
| Message-ID | <pCvz3-gO-9@gated-at.bofh.it> |
| In reply to | #1167489 |
Block devices from an nd bus, in addition to accepting "struct bio"
based requests, also have the capability to perform byte-aligned
accesses. By default only the bio/block interface is used. However, if
another driver can make effective use of the byte-aligned capability it
can claim the block interface and use the byte-aligned ->rw_bytes()
interface.
The BTT driver is the initial first consumer of this mechanism to allow
layering atomic sector update guarantees on top of ->rw_bytes() capable
libnvdimm-block-devices, or their partitions.
Cc: Greg KH <gregkh@linuxfoundation.org>
Cc: Neil Brown <neilb@suse.de>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/nvdimm/Kconfig | 3
drivers/nvdimm/Makefile | 1
drivers/nvdimm/btt.h | 45 +++++
drivers/nvdimm/btt_devs.c | 431 ++++++++++++++++++++++++++++++++++++++++++++
drivers/nvdimm/bus.c | 82 ++++++++
drivers/nvdimm/core.c | 20 ++
drivers/nvdimm/nd-core.h | 34 +++
drivers/nvdimm/nd.h | 19 ++
drivers/nvdimm/pmem.c | 6 -
include/uapi/linux/ndctl.h | 2
10 files changed, 637 insertions(+), 6 deletions(-)
create mode 100644 drivers/nvdimm/btt.h
create mode 100644 drivers/nvdimm/btt_devs.c
diff --git a/drivers/nvdimm/Kconfig b/drivers/nvdimm/Kconfig
index 07a29113b870..f16ba9d14740 100644
--- a/drivers/nvdimm/Kconfig
+++ b/drivers/nvdimm/Kconfig
@@ -33,4 +33,7 @@ config BLK_DEV_PMEM
Say Y if you want to use an NVDIMM
+config ND_BTT_DEVS
+ def_bool y
+
endif
diff --git a/drivers/nvdimm/Makefile b/drivers/nvdimm/Makefile
index abce98f87f16..eb1bbce86592 100644
--- a/drivers/nvdimm/Makefile
+++ b/drivers/nvdimm/Makefile
@@ -11,3 +11,4 @@ libnvdimm-y += region_devs.o
libnvdimm-y += region.o
libnvdimm-y += namespace_devs.o
libnvdimm-y += label.o
+libnvdimm-$(CONFIG_ND_BTT_DEVS) += btt_devs.o
diff --git a/drivers/nvdimm/btt.h b/drivers/nvdimm/btt.h
new file mode 100644
index 000000000000..e8f6d8e0ddd3
--- /dev/null
+++ b/drivers/nvdimm/btt.h
@@ -0,0 +1,45 @@
+/*
+ * Block Translation Table library
+ * Copyright (c) 2014-2015, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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 _LINUX_BTT_H
+#define _LINUX_BTT_H
+
+#include <linux/types.h>
+
+#define BTT_SIG_LEN 16
+#define BTT_SIG "BTT_ARENA_INFO\0"
+
+struct btt_sb {
+ u8 signature[BTT_SIG_LEN];
+ u8 uuid[16];
+ u8 parent_uuid[16];
+ __le32 flags;
+ __le16 version_major;
+ __le16 version_minor;
+ __le32 external_lbasize;
+ __le32 external_nlba;
+ __le32 internal_lbasize;
+ __le32 internal_nlba;
+ __le32 nfree;
+ __le32 infosize;
+ __le64 nextoff;
+ __le64 dataoff;
+ __le64 mapoff;
+ __le64 logoff;
+ __le64 info2off;
+ u8 padding[3968];
+ __le64 checksum;
+};
+
+#endif
diff --git a/drivers/nvdimm/btt_devs.c b/drivers/nvdimm/btt_devs.c
new file mode 100644
index 000000000000..2148fd8f535b
--- /dev/null
+++ b/drivers/nvdimm/btt_devs.c
@@ -0,0 +1,431 @@
+/*
+ * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License 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 <linux/blkdev.h>
+#include <linux/device.h>
+#include <linux/genhd.h>
+#include <linux/sizes.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include "nd-core.h"
+#include "btt.h"
+#include "nd.h"
+
+static DEFINE_IDA(btt_ida);
+
+static void nd_btt_release(struct device *dev)
+{
+ struct nd_btt *nd_btt = to_nd_btt(dev);
+
+ dev_dbg(dev, "%s\n", __func__);
+ WARN_ON(nd_btt->backing_dev);
+ ida_simple_remove(&btt_ida, nd_btt->id);
+ kfree(nd_btt->uuid);
+ kfree(nd_btt);
+}
+
+static struct device_type nd_btt_device_type = {
+ .name = "nd_btt",
+ .release = nd_btt_release,
+};
+
+bool is_nd_btt(struct device *dev)
+{
+ return dev->type == &nd_btt_device_type;
+}
+
+struct nd_btt *to_nd_btt(struct device *dev)
+{
+ struct nd_btt *nd_btt = container_of(dev, struct nd_btt, dev);
+
+ WARN_ON(!is_nd_btt(dev));
+ return nd_btt;
+}
+EXPORT_SYMBOL(to_nd_btt);
+
+static const unsigned long btt_lbasize_supported[] = { 512, 4096, 0 };
+
+static ssize_t sector_size_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct nd_btt *nd_btt = to_nd_btt(dev);
+
+ return nd_sector_size_show(nd_btt->lbasize, btt_lbasize_supported, buf);
+}
+
+static ssize_t sector_size_store(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t len)
+{
+ struct nd_btt *nd_btt = to_nd_btt(dev);
+ ssize_t rc;
+
+ device_lock(dev);
+ nvdimm_bus_lock(dev);
+ rc = nd_sector_size_store(dev, buf, &nd_btt->lbasize,
+ btt_lbasize_supported);
+ dev_dbg(dev, "%s: result: %zd wrote: %s%s", __func__,
+ rc, buf, buf[len - 1] == '\n' ? "" : "\n");
+ nvdimm_bus_unlock(dev);
+ device_unlock(dev);
+
+ return rc ? rc : len;
+}
+static DEVICE_ATTR_RW(sector_size);
+
+static ssize_t uuid_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct nd_btt *nd_btt = to_nd_btt(dev);
+
+ if (nd_btt->uuid)
+ return sprintf(buf, "%pUb\n", nd_btt->uuid);
+ return sprintf(buf, "\n");
+}
+
+static ssize_t uuid_store(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t len)
+{
+ struct nd_btt *nd_btt = to_nd_btt(dev);
+ ssize_t rc;
+
+ device_lock(dev);
+ rc = nd_uuid_store(dev, &nd_btt->uuid, buf, len);
+ dev_dbg(dev, "%s: result: %zd wrote: %s%s", __func__,
+ rc, buf, buf[len - 1] == '\n' ? "" : "\n");
+ device_unlock(dev);
+
+ return rc ? rc : len;
+}
+static DEVICE_ATTR_RW(uuid);
+
+static ssize_t backing_dev_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct nd_btt *nd_btt = to_nd_btt(dev);
+ char name[BDEVNAME_SIZE];
+
+ if (nd_btt->backing_dev)
+ return sprintf(buf, "/dev/%s\n",
+ bdevname(nd_btt->backing_dev, name));
+ else
+ return sprintf(buf, "\n");
+}
+
+static const fmode_t nd_btt_devs_mode = FMODE_READ | FMODE_WRITE | FMODE_EXCL;
+
+static void nd_btt_remove_bdev(struct nd_btt *nd_btt, const char *caller)
+{
+ struct block_device *bdev = nd_btt->backing_dev;
+ char bdev_name[BDEVNAME_SIZE];
+
+ if (!nd_btt->backing_dev)
+ return;
+
+ WARN_ON_ONCE(!is_nvdimm_bus_locked(&nd_btt->dev));
+ dev_dbg(&nd_btt->dev, "%s: %s: release %s\n", caller, __func__,
+ bdevname(bdev, bdev_name));
+ blkdev_put(bdev, nd_btt_devs_mode);
+ nd_btt->backing_dev = NULL;
+
+ /*
+ * Once we've had our backing device removed we need to be fully
+ * reconfigured. The bus will have already created a new seed
+ * for this purpose, so now is a good time to clean up this
+ * stale nd_btt instance.
+ */
+ if (nd_btt->dev.driver)
+ nd_device_unregister(&nd_btt->dev, ND_ASYNC);
+}
+
+static int __nd_btt_remove_disk(struct device *dev, void *data)
+{
+ struct gendisk *disk = data;
+ struct block_device *bdev;
+ struct nd_btt *nd_btt;
+
+ if (!is_nd_btt(dev))
+ return 0;
+
+ nd_btt = to_nd_btt(dev);
+ bdev = nd_btt->backing_dev;
+ if (bdev && bdev->bd_disk == disk)
+ nd_btt_remove_bdev(nd_btt, __func__);
+ return 0;
+}
+
+void nd_btt_remove_disk(struct nvdimm_bus *nvdimm_bus, struct gendisk *disk)
+{
+ device_for_each_child(&nvdimm_bus->dev, disk, __nd_btt_remove_disk);
+}
+
+static ssize_t __backing_dev_store(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t len)
+{
+ struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
+ const struct block_device_operations *ops;
+ struct nd_btt *nd_btt = to_nd_btt(dev);
+ struct block_device *bdev;
+ char *path;
+
+ if (dev->driver) {
+ dev_dbg(dev, "%s: -EBUSY\n", __func__);
+ return -EBUSY;
+ }
+
+ path = kstrndup(buf, len, GFP_KERNEL);
+ if (!path)
+ return -ENOMEM;
+ strim(path);
+
+ /* detach the backing device */
+ if (strcmp(path, "") == 0) {
+ nd_btt_remove_bdev(nd_btt, __func__);
+ goto out;
+ } else if (nd_btt->backing_dev) {
+ dev_dbg(dev, "backing_dev already set\n");
+ len = -EBUSY;
+ goto out;
+ }
+
+ bdev = blkdev_get_by_path(path, nd_btt_devs_mode, nd_btt);
+ if (IS_ERR(bdev)) {
+ dev_dbg(dev, "open '%s' failed: %ld\n", path, PTR_ERR(bdev));
+ len = PTR_ERR(bdev);
+ goto out;
+ }
+
+ if (nvdimm_bus != walk_to_nvdimm_bus(disk_to_dev(bdev->bd_disk))) {
+ dev_dbg(dev, "%s not a descendant of %s\n", path,
+ dev_name(&nvdimm_bus->dev));
+ blkdev_put(bdev, nd_btt_devs_mode);
+ len = -EINVAL;
+ goto out;
+ }
+
+ if (get_capacity(bdev->bd_disk) < SZ_16M / 512) {
+ dev_dbg(dev, "%s too small to host btt\n", path);
+ blkdev_put(bdev, nd_btt_devs_mode);
+ len = -ENXIO;
+ goto out;
+ }
+
+ ops = bdev->bd_disk->fops;
+ if (!ops->rw_bytes) {
+ dev_dbg(dev, "%s does not implement ->rw_bytes()\n", path);
+ blkdev_put(bdev, nd_btt_devs_mode);
+ len = -EINVAL;
+ goto out;
+ }
+
+ WARN_ON_ONCE(!is_nvdimm_bus_locked(&nd_btt->dev));
+ nd_btt->backing_dev = bdev;
+
+ out:
+ kfree(path);
+ return len;
+}
+
+static ssize_t backing_dev_store(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t len)
+{
+ ssize_t rc;
+
+ nvdimm_bus_lock(dev);
+ device_lock(dev);
+ rc = __backing_dev_store(dev, attr, buf, len);
+ dev_dbg(dev, "%s: result: %zd wrote: %s%s", __func__,
+ rc, buf, buf[len - 1] == '\n' ? "" : "\n");
+ device_unlock(dev);
+ nvdimm_bus_unlock(dev);
+
+ return rc;
+}
+static DEVICE_ATTR_RW(backing_dev);
+
+static bool is_nd_btt_idle(struct device *dev)
+{
+ struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
+ struct nd_btt *nd_btt = to_nd_btt(dev);
+
+ if (nvdimm_bus->nd_btt == nd_btt || dev->driver || nd_btt->backing_dev)
+ return false;
+ return true;
+}
+
+static ssize_t delete_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ /* return 1 if can be deleted */
+ return sprintf(buf, "%d\n", is_nd_btt_idle(dev));
+}
+
+static ssize_t delete_store(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t len)
+{
+ unsigned long val;
+
+ /* write 1 to delete */
+ if (kstrtoul(buf, 0, &val) != 0 || val != 1)
+ return -EINVAL;
+
+ /* prevent deletion while this btt is active, or is the current seed */
+ if (!is_nd_btt_idle(dev))
+ return -EBUSY;
+
+ /*
+ * userspace raced itself if device goes active here and it gets
+ * to keep the pieces
+ */
+ nd_device_unregister(dev, ND_ASYNC);
+
+ return len;
+}
+static DEVICE_ATTR_RW(delete);
+
+static struct attribute *nd_btt_attributes[] = {
+ &dev_attr_sector_size.attr,
+ &dev_attr_backing_dev.attr,
+ &dev_attr_delete.attr,
+ &dev_attr_uuid.attr,
+ NULL,
+};
+
+static struct attribute_group nd_btt_attribute_group = {
+ .attrs = nd_btt_attributes,
+};
+
+static const struct attribute_group *nd_btt_attribute_groups[] = {
+ &nd_btt_attribute_group,
+ &nd_device_attribute_group,
+ NULL,
+};
+
+static struct nd_btt *__nd_btt_create(struct nvdimm_bus *nvdimm_bus,
+ unsigned long lbasize, u8 *uuid, struct block_device *bdev)
+{
+ struct nd_btt *nd_btt = kzalloc(sizeof(*nd_btt), GFP_KERNEL);
+ struct device *dev;
+
+ if (!nd_btt)
+ return NULL;
+ nd_btt->id = ida_simple_get(&btt_ida, 0, 0, GFP_KERNEL);
+ if (nd_btt->id < 0) {
+ kfree(nd_btt);
+ return NULL;
+ }
+
+ nd_btt->lbasize = lbasize;
+ if (uuid)
+ uuid = kmemdup(uuid, 16, GFP_KERNEL);
+ nd_btt->uuid = uuid;
+ nd_btt->backing_dev = bdev;
+ dev = &nd_btt->dev;
+ dev_set_name(dev, "btt%d", nd_btt->id);
+ dev->parent = &nvdimm_bus->dev;
+ dev->type = &nd_btt_device_type;
+ dev->groups = nd_btt_attribute_groups;
+ nd_device_register(&nd_btt->dev);
+ return nd_btt;
+}
+
+struct nd_btt *nd_btt_create(struct nvdimm_bus *nvdimm_bus)
+{
+ return __nd_btt_create(nvdimm_bus, 0, NULL, NULL);
+}
+
+/*
+ * nd_btt_sb_checksum: compute checksum for btt info block
+ *
+ * Returns a fletcher64 checksum of everything in the given info block
+ * except the last field (since that's where the checksum lives).
+ */
+u64 nd_btt_sb_checksum(struct btt_sb *btt_sb)
+{
+ u64 sum, sum_save;
+
+ sum_save = btt_sb->checksum;
+ btt_sb->checksum = 0;
+ sum = nd_fletcher64(btt_sb, sizeof(*btt_sb), 1);
+ btt_sb->checksum = sum_save;
+ return sum;
+}
+EXPORT_SYMBOL(nd_btt_sb_checksum);
+
+static struct nd_btt *__nd_btt_autodetect(struct nvdimm_bus *nvdimm_bus,
+ struct block_device *bdev, struct btt_sb *btt_sb)
+{
+ u64 checksum;
+ u32 lbasize;
+
+ if (!btt_sb || !bdev || !nvdimm_bus)
+ return NULL;
+
+ if (bdev_read_bytes(bdev, SZ_4K, btt_sb, sizeof(*btt_sb)))
+ return NULL;
+
+ if (get_capacity(bdev->bd_disk) < SZ_16M / 512)
+ return NULL;
+
+ if (memcmp(btt_sb->signature, BTT_SIG, BTT_SIG_LEN) != 0)
+ return NULL;
+
+ checksum = le64_to_cpu(btt_sb->checksum);
+ btt_sb->checksum = 0;
+ if (checksum != nd_btt_sb_checksum(btt_sb))
+ return NULL;
+ btt_sb->checksum = cpu_to_le64(checksum);
+
+ lbasize = le32_to_cpu(btt_sb->external_lbasize);
+ return __nd_btt_create(nvdimm_bus, lbasize, btt_sb->uuid, bdev);
+}
+
+static int nd_btt_autodetect(struct nvdimm_bus *nvdimm_bus,
+ struct block_device *bdev)
+{
+ char name[BDEVNAME_SIZE];
+ struct nd_btt *nd_btt;
+ struct btt_sb *btt_sb;
+
+ btt_sb = kzalloc(sizeof(*btt_sb), GFP_KERNEL);
+ nd_btt = __nd_btt_autodetect(nvdimm_bus, bdev, btt_sb);
+ kfree(btt_sb);
+ dev_dbg(&nvdimm_bus->dev, "%s: %s btt: %s\n", __func__,
+ bdevname(bdev, name), nd_btt
+ ? dev_name(&nd_btt->dev) : "<none>");
+ return nd_btt ? 0 : -ENODEV;
+}
+
+void nd_btt_add_disk(struct nvdimm_bus *nvdimm_bus, struct gendisk *disk)
+{
+ struct disk_part_iter piter;
+ struct hd_struct *part;
+
+ disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
+ while ((part = disk_part_iter_next(&piter))) {
+ struct block_device *bdev;
+ int rc;
+
+ bdev = bdget_disk(disk, part->partno);
+ if (!bdev)
+ continue;
+ if (blkdev_get(bdev, nd_btt_devs_mode, nvdimm_bus) != 0)
+ continue;
+ rc = nd_btt_autodetect(nvdimm_bus, bdev);
+ if (rc)
+ blkdev_put(bdev, nd_btt_devs_mode);
+ /* no need to scan further in the case of whole disk btt */
+ if (rc == 0 && part->partno == 0)
+ break;
+ }
+ disk_part_iter_exit(&piter);
+}
diff --git a/drivers/nvdimm/bus.c b/drivers/nvdimm/bus.c
index ca802702440e..3c14fee5aff4 100644
--- a/drivers/nvdimm/bus.c
+++ b/drivers/nvdimm/bus.c
@@ -14,8 +14,10 @@
#include <linux/vmalloc.h>
#include <linux/uaccess.h>
#include <linux/module.h>
+#include <linux/blkdev.h>
#include <linux/fcntl.h>
#include <linux/async.h>
+#include <linux/genhd.h>
#include <linux/ndctl.h>
#include <linux/sched.h>
#include <linux/slab.h>
@@ -40,6 +42,8 @@ static int to_nd_device_type(struct device *dev)
return ND_DEVICE_REGION_BLK;
else if (is_nd_pmem(dev->parent) || is_nd_blk(dev->parent))
return nd_region_to_nstype(to_nd_region(dev->parent));
+ else if (is_nd_btt(dev))
+ return ND_DEVICE_BTT;
return 0;
}
@@ -103,6 +107,21 @@ static int nvdimm_bus_probe(struct device *dev)
dev_dbg(&nvdimm_bus->dev, "%s.probe(%s) = %d\n", dev->driver->name,
dev_name(dev), rc);
+
+ /* check if our btt-seed has sprouted, and plant another */
+ if (rc == 0 && is_nd_btt(dev) && dev == &nvdimm_bus->nd_btt->dev) {
+ const char *sep = "", *name = "", *status = "failed";
+
+ nvdimm_bus->nd_btt = nd_btt_create(nvdimm_bus);
+ if (nvdimm_bus->nd_btt) {
+ status = "succeeded";
+ sep = ": ";
+ name = dev_name(&nvdimm_bus->nd_btt->dev);
+ }
+ dev_dbg(&nvdimm_bus->dev, "btt seed creation %s%s%s\n",
+ status, sep, name);
+ }
+
if (rc != 0)
module_put(provider);
return rc;
@@ -163,14 +182,19 @@ static void nd_async_device_unregister(void *d, async_cookie_t cookie)
put_device(dev);
}
-void nd_device_register(struct device *dev)
+void __nd_device_register(struct device *dev)
{
dev->bus = &nvdimm_bus_type;
- device_initialize(dev);
get_device(dev);
async_schedule_domain(nd_async_device_register, dev,
&nd_async_domain);
}
+
+void nd_device_register(struct device *dev)
+{
+ device_initialize(dev);
+ __nd_device_register(dev);
+}
EXPORT_SYMBOL(nd_device_register);
void nd_device_unregister(struct device *dev, enum nd_async_mode mode)
@@ -219,6 +243,60 @@ int __nd_driver_register(struct nd_device_driver *nd_drv, struct module *owner,
}
EXPORT_SYMBOL(__nd_driver_register);
+/**
+ * nvdimm_bus_add_disk() - attach and run actions on an nvdimm block device
+ * @disk: disk device being registered
+ *
+ * Note, that @disk must be a descendant of an nvdimm_bus
+ */
+int nvdimm_bus_add_disk(struct gendisk *disk)
+{
+ const struct block_device_operations *ops = disk->fops;
+ struct device *dev = disk->driverfs_dev;
+ struct nvdimm_bus *nvdimm_bus;
+
+ nvdimm_bus = walk_to_nvdimm_bus(dev);
+ if (!nvdimm_bus || !ops->rw_bytes)
+ return -EINVAL;
+
+ /*
+ * Take the bus lock here to prevent userspace racing to
+ * initiate actions on the newly availble block device while
+ * autodetect scanning is still in flight.
+ */
+ nvdimm_bus_lock(&nvdimm_bus->dev);
+ add_disk(disk);
+ nd_btt_add_disk(nvdimm_bus, disk);
+ nvdimm_bus_unlock(&nvdimm_bus->dev);
+
+ return 0;
+}
+EXPORT_SYMBOL(nvdimm_bus_add_disk);
+
+void nvdimm_bus_remove_disk(struct gendisk *disk)
+{
+ struct device *dev = disk_to_dev(disk);
+ struct nvdimm_bus *nvdimm_bus;
+
+ nvdimm_bus = walk_to_nvdimm_bus(dev);
+ if (!nvdimm_bus)
+ return;
+
+ nvdimm_bus_lock(&nvdimm_bus->dev);
+ nd_btt_remove_disk(nvdimm_bus, disk);
+ nvdimm_bus_unlock(&nvdimm_bus->dev);
+
+ /*
+ * Flush in case *_notify_remove() kicked off asynchronous
+ * device unregistration
+ */
+ nd_synchronize();
+
+ del_gendisk(disk);
+ put_disk(disk);
+}
+EXPORT_SYMBOL(nvdimm_bus_remove_disk);
+
static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
diff --git a/drivers/nvdimm/core.c b/drivers/nvdimm/core.c
index dd824d7c2669..0fa9b6225450 100644
--- a/drivers/nvdimm/core.c
+++ b/drivers/nvdimm/core.c
@@ -273,10 +273,28 @@ static ssize_t wait_probe_show(struct device *dev,
}
static DEVICE_ATTR_RO(wait_probe);
+static ssize_t btt_seed_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct nvdimm_bus *nvdimm_bus = to_nvdimm_bus(dev);
+ ssize_t rc;
+
+ nvdimm_bus_lock(dev);
+ if (nvdimm_bus->nd_btt)
+ rc = sprintf(buf, "%s\n", dev_name(&nvdimm_bus->nd_btt->dev));
+ else
+ rc = sprintf(buf, "\n");
+ nvdimm_bus_unlock(dev);
+
+ return rc;
+}
+static DEVICE_ATTR_RO(btt_seed);
+
static struct attribute *nvdimm_bus_attributes[] = {
&dev_attr_commands.attr,
&dev_attr_wait_probe.attr,
&dev_attr_provider.attr,
+ &dev_attr_btt_seed.attr,
NULL,
};
@@ -322,6 +340,8 @@ struct nvdimm_bus *__nvdimm_bus_register(struct device *parent,
list_add_tail(&nvdimm_bus->list, &nvdimm_bus_list);
mutex_unlock(&nvdimm_bus_list_mutex);
+ nvdimm_bus->nd_btt = nd_btt_create(nvdimm_bus);
+
return nvdimm_bus;
err:
put_device(&nvdimm_bus->dev);
diff --git a/drivers/nvdimm/nd-core.h b/drivers/nvdimm/nd-core.h
index 78d6c51f4bac..1375d30b3da5 100644
--- a/drivers/nvdimm/nd-core.h
+++ b/drivers/nvdimm/nd-core.h
@@ -23,6 +23,11 @@ extern struct list_head nvdimm_bus_list;
extern struct mutex nvdimm_bus_list_mutex;
extern int nvdimm_major;
+struct block_device;
+struct nd_io_claim;
+struct nd_btt;
+struct nd_io;
+
struct nvdimm_bus {
struct nvdimm_bus_descriptor *nd_desc;
wait_queue_head_t probe_wait;
@@ -31,6 +36,7 @@ struct nvdimm_bus {
struct device dev;
int id, probe_active;
struct mutex reconfig_mutex;
+ struct nd_btt *nd_btt;
};
struct nvdimm {
@@ -45,6 +51,33 @@ struct nvdimm {
bool is_nvdimm(struct device *dev);
bool is_nd_blk(struct device *dev);
bool is_nd_pmem(struct device *dev);
+struct gendisk;
+#if IS_ENABLED(CONFIG_ND_BTT_DEVS)
+bool is_nd_btt(struct device *dev);
+struct nd_btt *nd_btt_create(struct nvdimm_bus *nvdimm_bus);
+void nd_btt_add_disk(struct nvdimm_bus *nvdimm_bus, struct gendisk *disk);
+void nd_btt_remove_disk(struct nvdimm_bus *nvdimm_bus, struct gendisk *disk);
+#else
+static inline bool is_nd_btt(struct device *dev)
+{
+ return false;
+}
+
+static inline struct nd_btt *nd_btt_create(struct nvdimm_bus *nvdimm_bus)
+{
+ return NULL;
+}
+
+static inline void nd_btt_add_disk(struct nvdimm_bus *nvdimm_bus,
+ struct gendisk *disk)
+{
+}
+
+static inline void nd_btt_remove_disk(struct nvdimm_bus *nvdimm_bus,
+ struct gendisk *disk)
+{
+}
+#endif
struct nvdimm_bus *walk_to_nvdimm_bus(struct device *nd_dev);
int __init nvdimm_bus_init(void);
void nvdimm_bus_exit(void);
@@ -58,6 +91,7 @@ void nd_synchronize(void);
int nvdimm_bus_register_dimms(struct nvdimm_bus *nvdimm_bus);
int nvdimm_bus_register_regions(struct nvdimm_bus *nvdimm_bus);
int nvdimm_bus_init_interleave_sets(struct nvdimm_bus *nvdimm_bus);
+void __nd_device_register(struct device *dev);
int nd_match_dimm(struct device *dev, void *data);
struct nd_label_id;
char *nd_label_gen_id(struct nd_label_id *label_id, u8 *uuid, u32 flags);
diff --git a/drivers/nvdimm/nd.h b/drivers/nvdimm/nd.h
index bfa849617358..3bd8d650340e 100644
--- a/drivers/nvdimm/nd.h
+++ b/drivers/nvdimm/nd.h
@@ -14,11 +14,17 @@
#define __ND_H__
#include <linux/libnvdimm.h>
#include <linux/device.h>
+#include <linux/genhd.h>
#include <linux/mutex.h>
#include <linux/ndctl.h>
#include <linux/types.h>
+#include <linux/fs.h>
#include "label.h"
+enum {
+ SECTOR_SHIFT = 9,
+};
+
struct nvdimm_drvdata {
struct device *dev;
int nsindex_size;
@@ -94,6 +100,14 @@ static inline unsigned nd_inc_seq(unsigned seq)
return next[seq & 3];
}
+struct nd_btt {
+ struct device dev;
+ struct block_device *backing_dev;
+ unsigned long lbasize;
+ u8 *uuid;
+ int id;
+};
+
enum nd_async_mode {
ND_SYNC,
ND_ASYNC,
@@ -118,6 +132,9 @@ int nvdimm_init_nsarea(struct nvdimm_drvdata *ndd);
int nvdimm_init_config_data(struct nvdimm_drvdata *ndd);
int nvdimm_set_config_data(struct nvdimm_drvdata *ndd, size_t offset,
void *buf, size_t len);
+struct nd_btt *to_nd_btt(struct device *dev);
+struct btt_sb;
+u64 nd_btt_sb_checksum(struct btt_sb *btt_sb);
struct nd_region *to_nd_region(struct device *dev);
int nd_region_to_nstype(struct nd_region *nd_region);
int nd_region_register_namespaces(struct nd_region *nd_region, int *err);
@@ -125,6 +142,8 @@ u64 nd_region_interleave_set_cookie(struct nd_region *nd_region);
void nvdimm_bus_lock(struct device *dev);
void nvdimm_bus_unlock(struct device *dev);
bool is_nvdimm_bus_locked(struct device *dev);
+int nvdimm_bus_add_disk(struct gendisk *disk);
+void nvdimm_bus_remove_disk(struct gendisk *disk);
void nvdimm_drvdata_release(struct kref *kref);
void put_ndd(struct nvdimm_drvdata *ndd);
int nd_label_reserve_dpa(struct nvdimm_drvdata *ndd);
diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c
index efa2cde7f6b6..1f4767150975 100644
--- a/drivers/nvdimm/pmem.c
+++ b/drivers/nvdimm/pmem.c
@@ -190,8 +190,6 @@ static struct pmem_device *pmem_alloc(struct device *dev,
set_capacity(disk, pmem->size >> 9);
pmem->pmem_disk = disk;
- add_disk(disk);
-
return pmem;
out_free_queue:
@@ -208,8 +206,7 @@ out:
static void pmem_free(struct pmem_device *pmem)
{
- del_gendisk(pmem->pmem_disk);
- put_disk(pmem->pmem_disk);
+ nvdimm_bus_remove_disk(pmem->pmem_disk);
blk_cleanup_queue(pmem->pmem_queue);
iounmap(pmem->virt_addr);
release_mem_region(pmem->phys_addr, pmem->size);
@@ -244,6 +241,7 @@ static int nd_pmem_probe(struct device *dev)
return PTR_ERR(pmem);
dev_set_drvdata(dev, pmem);
+ nvdimm_bus_add_disk(pmem->pmem_disk);
return 0;
}
diff --git a/include/uapi/linux/ndctl.h b/include/uapi/linux/ndctl.h
index 2b94ea2287bb..4c2e3ff374b2 100644
--- a/include/uapi/linux/ndctl.h
+++ b/include/uapi/linux/ndctl.h
@@ -181,6 +181,7 @@ static inline const char *nvdimm_cmd_name(unsigned cmd)
#define ND_DEVICE_NAMESPACE_IO 4 /* legacy persistent memory */
#define ND_DEVICE_NAMESPACE_PMEM 5 /* PMEM namespace (may alias with BLK) */
#define ND_DEVICE_NAMESPACE_BLK 6 /* BLK namespace (may alias with PMEM) */
+#define ND_DEVICE_BTT 7 /* block-translation table device */
enum nd_driver_flags {
ND_DRIVER_DIMM = 1 << ND_DEVICE_DIMM,
@@ -189,6 +190,7 @@ enum nd_driver_flags {
ND_DRIVER_NAMESPACE_IO = 1 << ND_DEVICE_NAMESPACE_IO,
ND_DRIVER_NAMESPACE_PMEM = 1 << ND_DEVICE_NAMESPACE_PMEM,
ND_DRIVER_NAMESPACE_BLK = 1 << ND_DEVICE_NAMESPACE_BLK,
+ ND_DRIVER_BTT = 1 << ND_DEVICE_BTT,
};
enum {
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
| From | Dan Williams <dan.j.williams@intel.com> |
|---|---|
| Date | 2015-06-18 02:10 +0200 |
| Subject | [PATCH 10/15] libnvdimm: fix up max_hw_sectors |
| Message-ID | <pCvz4-gO-13@gated-at.bofh.it> |
| In reply to | #1167489 |
There is no hardware limit to enforce on the size of the i/o that can be
passed to nd block device, so set it to UINT_MAX. Do this centrally for
all nd block devices in nd_blk_queue_init();
Reviewed-by: Vishal Verma <vishal.l.verma@linux.intel.com>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
---
drivers/nvdimm/blk.c | 3 +--
drivers/nvdimm/btt.c | 3 +--
drivers/nvdimm/core.c | 7 +++++++
drivers/nvdimm/nd.h | 1 +
drivers/nvdimm/pmem.c | 3 +--
5 files changed, 11 insertions(+), 6 deletions(-)
diff --git a/drivers/nvdimm/blk.c b/drivers/nvdimm/blk.c
index feddad325f97..8a6345797a71 100644
--- a/drivers/nvdimm/blk.c
+++ b/drivers/nvdimm/blk.c
@@ -272,9 +272,8 @@ static int nd_blk_probe(struct device *dev)
}
blk_queue_make_request(blk_dev->queue, nd_blk_make_request);
- blk_queue_max_hw_sectors(blk_dev->queue, 1024);
- blk_queue_bounce_limit(blk_dev->queue, BLK_BOUNCE_ANY);
blk_queue_logical_block_size(blk_dev->queue, blk_dev->sector_size);
+ nd_blk_queue_init(blk_dev->queue);
disk = blk_dev->disk = alloc_disk(0);
if (!disk) {
diff --git a/drivers/nvdimm/btt.c b/drivers/nvdimm/btt.c
index c337b7abfb43..380e01cedd24 100644
--- a/drivers/nvdimm/btt.c
+++ b/drivers/nvdimm/btt.c
@@ -1285,9 +1285,8 @@ static int btt_blk_init(struct btt *btt)
btt->btt_disk->flags = GENHD_FL_EXT_DEVT;
blk_queue_make_request(btt->btt_queue, btt_make_request);
- blk_queue_max_hw_sectors(btt->btt_queue, 1024);
- blk_queue_bounce_limit(btt->btt_queue, BLK_BOUNCE_ANY);
blk_queue_logical_block_size(btt->btt_queue, btt->sector_size);
+ nd_blk_queue_init(btt->btt_queue);
btt->btt_queue->queuedata = btt;
set_capacity(btt->btt_disk, 0);
diff --git a/drivers/nvdimm/core.c b/drivers/nvdimm/core.c
index 8f466c384b30..d27b13357873 100644
--- a/drivers/nvdimm/core.c
+++ b/drivers/nvdimm/core.c
@@ -214,6 +214,13 @@ ssize_t nd_sector_size_store(struct device *dev, const char *buf,
}
}
+void nd_blk_queue_init(struct request_queue *q)
+{
+ blk_queue_max_hw_sectors(q, UINT_MAX);
+ blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
+}
+EXPORT_SYMBOL(nd_blk_queue_init);
+
static ssize_t commands_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
diff --git a/drivers/nvdimm/nd.h b/drivers/nvdimm/nd.h
index 9b5fdb2215b1..2f20d5dca028 100644
--- a/drivers/nvdimm/nd.h
+++ b/drivers/nvdimm/nd.h
@@ -171,5 +171,6 @@ struct resource *nvdimm_allocate_dpa(struct nvdimm_drvdata *ndd,
struct nd_label_id *label_id, resource_size_t start,
resource_size_t n);
int nd_blk_region_init(struct nd_region *nd_region);
+void nd_blk_queue_init(struct request_queue *q);
resource_size_t nd_namespace_blk_validate(struct nd_namespace_blk *nsblk);
#endif /* __ND_H__ */
diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c
index 1f4767150975..b825a2201aa8 100644
--- a/drivers/nvdimm/pmem.c
+++ b/drivers/nvdimm/pmem.c
@@ -172,8 +172,7 @@ static struct pmem_device *pmem_alloc(struct device *dev,
goto out_unmap;
blk_queue_make_request(pmem->pmem_queue, pmem_make_request);
- blk_queue_max_hw_sectors(pmem->pmem_queue, 1024);
- blk_queue_bounce_limit(pmem->pmem_queue, BLK_BOUNCE_ANY);
+ nd_blk_queue_init(pmem->pmem_queue);
disk = alloc_disk(0);
if (!disk)
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
| From | Christoph Hellwig <hch@lst.de> |
|---|---|
| Date | 2015-06-21 12:10 +0200 |
| Subject | Re: [PATCH 10/15] libnvdimm: fix up max_hw_sectors |
| Message-ID | <pDKmm-1Yl-1@gated-at.bofh.it> |
| In reply to | #1167504 |
> +void nd_blk_queue_init(struct request_queue *q)
> +{
> + blk_queue_max_hw_sectors(q, UINT_MAX);
> + blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
> +}
Please just add the calls to the drivers instead of this helper which
hides the intent.
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
| From | Christoph Hellwig <hch@lst.de> |
|---|---|
| Date | 2015-06-21 12:10 +0200 |
| Subject | Re: [PATCH 03/15] nd_btt: atomic sector updates |
| Message-ID | <pDKmm-1Yl-7@gated-at.bofh.it> |
| In reply to | #1167489 |
> +config ND_MAX_REGIONS > + int "Maximum number of regions supported by the sub-system" > + default 64 > + ---help--- > + A 'region' corresponds to an individual DIMM or an interleave > + set of DIMMs. A typical maximally configured system may have > + up to 32 DIMMs. > + > + Leave the default of 64 if you are unsure. Having static limits in Kconfig is a bad idea. What prevents you from handling any (reasonable) number dynamically? -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
| From | Dan Williams <dan.j.williams@intel.com> |
|---|---|
| Date | 2015-06-21 18:40 +0200 |
| Subject | Re: [PATCH 03/15] nd_btt: atomic sector updates |
| Message-ID | <pDQrL-24S-11@gated-at.bofh.it> |
| In reply to | #1169551 |
On Sun, Jun 21, 2015 at 3:03 AM, Christoph Hellwig <hch@lst.de> wrote: >> +config ND_MAX_REGIONS >> + int "Maximum number of regions supported by the sub-system" >> + default 64 >> + ---help--- >> + A 'region' corresponds to an individual DIMM or an interleave >> + set of DIMMs. A typical maximally configured system may have >> + up to 32 DIMMs. >> + >> + Leave the default of 64 if you are unsure. > > Having static limits in Kconfig is a bad idea. What prevents you > from handling any (reasonable) number dynamically? Hmm, yes, this was a bad holdover from before we were using percpu definitions for the lane locks. Now that it's converted we can kill the static definition of nd_percpu_lane and just do an alloc_percpu() for each region dynamically. Fixed in v2 and passing the test suite. -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
| From | Christoph Hellwig <hch@lst.de> |
|---|---|
| Date | 2015-06-21 12:10 +0200 |
| Subject | Re: [PATCH 04/15] libnvdimm, nfit, nd_blk: driver for BLK-mode access persistent memory |
| Message-ID | <pDKmm-1Yl-15@gated-at.bofh.it> |
| In reply to | #1167489 |
> +#include <asm-generic/io-64-nonatomic-hi-lo.h> As mentioned last time only arch asm/ headers may include asm-generic headers. -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [next] | [standalone]
Page 1 of 2 [1] 2 Next page →
Back to top | Article view | linux.kernel
csiph-web