mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-28 18:51:56 -04:00
libnvdimm for 4.15
* Introduce MAP_SYNC and MAP_SHARED_VALIDATE, a mechanism to enable
'userspace flush' of persistent memory updates via filesystem-dax
mappings. It arranges for any filesystem metadata updates that may be
required to satisfy a write fault to also be flushed ("on disk") before
the kernel returns to userspace from the fault handler. Effectively
every write-fault that dirties metadata completes an fsync() before
returning from the fault handler. The new MAP_SHARED_VALIDATE mapping
type guarantees that the MAP_SYNC flag is validated as supported by the
filesystem's ->mmap() file operation.
* Add support for the standard ACPI 6.2 label access methods that
replace the NVDIMM_FAMILY_INTEL (vendor specific) label methods. This
enables interoperability with environments that only implement the
standardized methods.
* Add support for the ACPI 6.2 NVDIMM media error injection methods.
* Add support for the NVDIMM_FAMILY_INTEL v1.6 DIMM commands for latch
last shutdown status, firmware update, SMART error injection, and
SMART alarm threshold control.
* Cleanup physical address information disclosures to be root-only.
* Fix revalidation of the DIMM "locked label area" status to support
dynamic unlock of the label area.
* Expand unit test infrastructure to mock the ACPI 6.2 Translate SPA
(system-physical-address) command and error injection commands.
Acknowledgements that came after the commits were pushed to -next:
957ac8c421 dax: fix PMD faults on zero-length files
Reviewed-by: Ross Zwisler <[email protected]>
a39e596baa xfs: support for synchronous DAX faults
Reviewed-by: Darrick J. Wong <[email protected]>
7b565c9f96 xfs: Implement xfs_filemap_pfn_mkwrite() using __xfs_filemap_fault()
Reviewed-by: Darrick J. Wong <[email protected]>
-----BEGIN PGP SIGNATURE-----
iQIcBAABAgAGBQJaDfvcAAoJEB7SkWpmfYgCk7sP/2qJhBH+VTTdg2osDnhAdAhI
co/AGEmsHFlUCMBb/Ek7UnMAmhBYiJU2q4ywPsNFBpusXpMlqNy5Iwo7k4/wQHE/
SJcIM0g4zg0ViFuUhwV+C2T0R5UzFR8JLd9EYWj/YS6aJpurtotm5l4UStaM0Hzo
AhxSXJLrBDuqCpbOxbctfiGEmdRL7aRfBEAARTNRKBn/iXxJUcYHlp62rtXQS+t4
I6LC/URCWTNTTMGmzW6TRsgSD9WMfd19xKcGzN3qL6ee0KFccxN4ctFqHA/sFGOh
iYLeR0XJUjJxyp+PkWGteXPVZL0Kj3bD/lSTG+Co5bm/ra8a/sh3TSFfgFyoBZD1
EqMN8Ryf80hGp3FabeH2Iw2SviYPZpHSWgjddjxLD0RA6OmpzINc+Wm8eqApjMME
sbZDTOijiab4QMQ0XamF4GuDHyQtawv5Y/w2Ehhl1tmiqW+5tKhsKqxkQt+/V3Yt
RTVSRe2Pkway66b+cD64IdQ6L2tyonPnmi5IzgkKOhlOEGomy+4/U2Jt2bMbhzq6
ymszKmXp2XI8P06wU8sHrIUeXO5I9qoKn/fZA73Eb8aIzgJe3tBE/5+Ab7RG6HB9
1OVfcMWoXU1gNgNktTs63X1Lsg4aW9kt/K4fPHHcqUcaliEJpJTlAbg9GLF2buoW
nQ+0fTRgMRihE3ZA0Fs3
=h2vZ
-----END PGP SIGNATURE-----
Merge tag 'libnvdimm-for-4.15' of git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm
Pull libnvdimm and dax updates from Dan Williams:
"Save for a few late fixes, all of these commits have shipped in -next
releases since before the merge window opened, and 0day has given a
build success notification.
The ext4 touches came from Jan, and the xfs touches have Darrick's
reviewed-by. An xfstest for the MAP_SYNC feature has been through
a few round of reviews and is on track to be merged.
- Introduce MAP_SYNC and MAP_SHARED_VALIDATE, a mechanism to enable
'userspace flush' of persistent memory updates via filesystem-dax
mappings. It arranges for any filesystem metadata updates that may
be required to satisfy a write fault to also be flushed ("on disk")
before the kernel returns to userspace from the fault handler.
Effectively every write-fault that dirties metadata completes an
fsync() before returning from the fault handler. The new
MAP_SHARED_VALIDATE mapping type guarantees that the MAP_SYNC flag
is validated as supported by the filesystem's ->mmap() file
operation.
- Add support for the standard ACPI 6.2 label access methods that
replace the NVDIMM_FAMILY_INTEL (vendor specific) label methods.
This enables interoperability with environments that only implement
the standardized methods.
- Add support for the ACPI 6.2 NVDIMM media error injection methods.
- Add support for the NVDIMM_FAMILY_INTEL v1.6 DIMM commands for
latch last shutdown status, firmware update, SMART error injection,
and SMART alarm threshold control.
- Cleanup physical address information disclosures to be root-only.
- Fix revalidation of the DIMM "locked label area" status to support
dynamic unlock of the label area.
- Expand unit test infrastructure to mock the ACPI 6.2 Translate SPA
(system-physical-address) command and error injection commands.
Acknowledgements that came after the commits were pushed to -next:
- 957ac8c421 ("dax: fix PMD faults on zero-length files"):
Reviewed-by: Ross Zwisler <[email protected]>
- a39e596baa ("xfs: support for synchronous DAX faults") and
7b565c9f96 ("xfs: Implement xfs_filemap_pfn_mkwrite() using __xfs_filemap_fault()")
Reviewed-by: Darrick J. Wong <[email protected]>"
* tag 'libnvdimm-for-4.15' of git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm: (49 commits)
acpi, nfit: add 'Enable Latch System Shutdown Status' command support
dax: fix general protection fault in dax_alloc_inode
dax: fix PMD faults on zero-length files
dax: stop requiring a live device for dax_flush()
brd: remove dax support
dax: quiet bdev_dax_supported()
fs, dax: unify IOMAP_F_DIRTY read vs write handling policy in the dax core
tools/testing/nvdimm: unit test clear-error commands
acpi, nfit: validate commands against the device type
tools/testing/nvdimm: stricter bounds checking for error injection commands
xfs: support for synchronous DAX faults
xfs: Implement xfs_filemap_pfn_mkwrite() using __xfs_filemap_fault()
ext4: Support for synchronous DAX faults
ext4: Simplify error handling in ext4_dax_huge_fault()
dax: Implement dax_finish_sync_fault()
dax, iomap: Add support for synchronous faults
mm: Define MAP_SYNC and VM_SYNC flags
dax: Allow tuning whether dax_insert_mapping_entry() dirties entry
dax: Allow dax_iomap_fault() to return pfn
dax: Fix comment describing dax_iomap_fault()
...
This commit is contained in:
Linus Torvalds
commit
a3841f94c7
48 changed files with 1405 additions and 560 deletions
|
|
@ -21,6 +21,7 @@ libnvdimm-y += region_devs.o
|
|||
libnvdimm-y += region.o
|
||||
libnvdimm-y += namespace_devs.o
|
||||
libnvdimm-y += label.o
|
||||
libnvdimm-y += badrange.o
|
||||
libnvdimm-$(CONFIG_ND_CLAIM) += claim.o
|
||||
libnvdimm-$(CONFIG_BTT) += btt_devs.o
|
||||
libnvdimm-$(CONFIG_NVDIMM_PFN) += pfn_devs.o
|
||||
|
|
|
|||
293
drivers/nvdimm/badrange.c
Normal file
293
drivers/nvdimm/badrange.c
Normal file
|
|
@ -0,0 +1,293 @@
|
|||
/*
|
||||
* Copyright(c) 2017 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/libnvdimm.h>
|
||||
#include <linux/badblocks.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>
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/io.h>
|
||||
#include "nd-core.h"
|
||||
#include "nd.h"
|
||||
|
||||
void badrange_init(struct badrange *badrange)
|
||||
{
|
||||
INIT_LIST_HEAD(&badrange->list);
|
||||
spin_lock_init(&badrange->lock);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(badrange_init);
|
||||
|
||||
static void append_badrange_entry(struct badrange *badrange,
|
||||
struct badrange_entry *bre, u64 addr, u64 length)
|
||||
{
|
||||
lockdep_assert_held(&badrange->lock);
|
||||
bre->start = addr;
|
||||
bre->length = length;
|
||||
list_add_tail(&bre->list, &badrange->list);
|
||||
}
|
||||
|
||||
static int alloc_and_append_badrange_entry(struct badrange *badrange,
|
||||
u64 addr, u64 length, gfp_t flags)
|
||||
{
|
||||
struct badrange_entry *bre;
|
||||
|
||||
bre = kzalloc(sizeof(*bre), flags);
|
||||
if (!bre)
|
||||
return -ENOMEM;
|
||||
|
||||
append_badrange_entry(badrange, bre, addr, length);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int add_badrange(struct badrange *badrange, u64 addr, u64 length)
|
||||
{
|
||||
struct badrange_entry *bre, *bre_new;
|
||||
|
||||
spin_unlock(&badrange->lock);
|
||||
bre_new = kzalloc(sizeof(*bre_new), GFP_KERNEL);
|
||||
spin_lock(&badrange->lock);
|
||||
|
||||
if (list_empty(&badrange->list)) {
|
||||
if (!bre_new)
|
||||
return -ENOMEM;
|
||||
append_badrange_entry(badrange, bre_new, addr, length);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* There is a chance this is a duplicate, check for those first.
|
||||
* This will be the common case as ARS_STATUS returns all known
|
||||
* errors in the SPA space, and we can't query it per region
|
||||
*/
|
||||
list_for_each_entry(bre, &badrange->list, list)
|
||||
if (bre->start == addr) {
|
||||
/* If length has changed, update this list entry */
|
||||
if (bre->length != length)
|
||||
bre->length = length;
|
||||
kfree(bre_new);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* If not a duplicate or a simple length update, add the entry as is,
|
||||
* as any overlapping ranges will get resolved when the list is consumed
|
||||
* and converted to badblocks
|
||||
*/
|
||||
if (!bre_new)
|
||||
return -ENOMEM;
|
||||
append_badrange_entry(badrange, bre_new, addr, length);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int badrange_add(struct badrange *badrange, u64 addr, u64 length)
|
||||
{
|
||||
int rc;
|
||||
|
||||
spin_lock(&badrange->lock);
|
||||
rc = add_badrange(badrange, addr, length);
|
||||
spin_unlock(&badrange->lock);
|
||||
|
||||
return rc;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(badrange_add);
|
||||
|
||||
void badrange_forget(struct badrange *badrange, phys_addr_t start,
|
||||
unsigned int len)
|
||||
{
|
||||
struct list_head *badrange_list = &badrange->list;
|
||||
u64 clr_end = start + len - 1;
|
||||
struct badrange_entry *bre, *next;
|
||||
|
||||
spin_lock(&badrange->lock);
|
||||
|
||||
/*
|
||||
* [start, clr_end] is the badrange interval being cleared.
|
||||
* [bre->start, bre_end] is the badrange_list entry we're comparing
|
||||
* the above interval against. The badrange list entry may need
|
||||
* to be modified (update either start or length), deleted, or
|
||||
* split into two based on the overlap characteristics
|
||||
*/
|
||||
|
||||
list_for_each_entry_safe(bre, next, badrange_list, list) {
|
||||
u64 bre_end = bre->start + bre->length - 1;
|
||||
|
||||
/* Skip intervals with no intersection */
|
||||
if (bre_end < start)
|
||||
continue;
|
||||
if (bre->start > clr_end)
|
||||
continue;
|
||||
/* Delete completely overlapped badrange entries */
|
||||
if ((bre->start >= start) && (bre_end <= clr_end)) {
|
||||
list_del(&bre->list);
|
||||
kfree(bre);
|
||||
continue;
|
||||
}
|
||||
/* Adjust start point of partially cleared entries */
|
||||
if ((start <= bre->start) && (clr_end > bre->start)) {
|
||||
bre->length -= clr_end - bre->start + 1;
|
||||
bre->start = clr_end + 1;
|
||||
continue;
|
||||
}
|
||||
/* Adjust bre->length for partial clearing at the tail end */
|
||||
if ((bre->start < start) && (bre_end <= clr_end)) {
|
||||
/* bre->start remains the same */
|
||||
bre->length = start - bre->start;
|
||||
continue;
|
||||
}
|
||||
/*
|
||||
* If clearing in the middle of an entry, we split it into
|
||||
* two by modifying the current entry to represent one half of
|
||||
* the split, and adding a new entry for the second half.
|
||||
*/
|
||||
if ((bre->start < start) && (bre_end > clr_end)) {
|
||||
u64 new_start = clr_end + 1;
|
||||
u64 new_len = bre_end - new_start + 1;
|
||||
|
||||
/* Add new entry covering the right half */
|
||||
alloc_and_append_badrange_entry(badrange, new_start,
|
||||
new_len, GFP_NOWAIT);
|
||||
/* Adjust this entry to cover the left half */
|
||||
bre->length = start - bre->start;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
spin_unlock(&badrange->lock);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(badrange_forget);
|
||||
|
||||
static void set_badblock(struct badblocks *bb, sector_t s, int num)
|
||||
{
|
||||
dev_dbg(bb->dev, "Found a bad range (0x%llx, 0x%llx)\n",
|
||||
(u64) s * 512, (u64) num * 512);
|
||||
/* this isn't an error as the hardware will still throw an exception */
|
||||
if (badblocks_set(bb, s, num, 1))
|
||||
dev_info_once(bb->dev, "%s: failed for sector %llx\n",
|
||||
__func__, (u64) s);
|
||||
}
|
||||
|
||||
/**
|
||||
* __add_badblock_range() - Convert a physical address range to bad sectors
|
||||
* @bb: badblocks instance to populate
|
||||
* @ns_offset: namespace offset where the error range begins (in bytes)
|
||||
* @len: number of bytes of badrange to be added
|
||||
*
|
||||
* This assumes that the range provided with (ns_offset, len) is within
|
||||
* the bounds of physical addresses for this namespace, i.e. lies in the
|
||||
* interval [ns_start, ns_start + ns_size)
|
||||
*/
|
||||
static void __add_badblock_range(struct badblocks *bb, u64 ns_offset, u64 len)
|
||||
{
|
||||
const unsigned int sector_size = 512;
|
||||
sector_t start_sector, end_sector;
|
||||
u64 num_sectors;
|
||||
u32 rem;
|
||||
|
||||
start_sector = div_u64(ns_offset, sector_size);
|
||||
end_sector = div_u64_rem(ns_offset + len, sector_size, &rem);
|
||||
if (rem)
|
||||
end_sector++;
|
||||
num_sectors = end_sector - start_sector;
|
||||
|
||||
if (unlikely(num_sectors > (u64)INT_MAX)) {
|
||||
u64 remaining = num_sectors;
|
||||
sector_t s = start_sector;
|
||||
|
||||
while (remaining) {
|
||||
int done = min_t(u64, remaining, INT_MAX);
|
||||
|
||||
set_badblock(bb, s, done);
|
||||
remaining -= done;
|
||||
s += done;
|
||||
}
|
||||
} else
|
||||
set_badblock(bb, start_sector, num_sectors);
|
||||
}
|
||||
|
||||
static void badblocks_populate(struct badrange *badrange,
|
||||
struct badblocks *bb, const struct resource *res)
|
||||
{
|
||||
struct badrange_entry *bre;
|
||||
|
||||
if (list_empty(&badrange->list))
|
||||
return;
|
||||
|
||||
list_for_each_entry(bre, &badrange->list, list) {
|
||||
u64 bre_end = bre->start + bre->length - 1;
|
||||
|
||||
/* Discard intervals with no intersection */
|
||||
if (bre_end < res->start)
|
||||
continue;
|
||||
if (bre->start > res->end)
|
||||
continue;
|
||||
/* Deal with any overlap after start of the namespace */
|
||||
if (bre->start >= res->start) {
|
||||
u64 start = bre->start;
|
||||
u64 len;
|
||||
|
||||
if (bre_end <= res->end)
|
||||
len = bre->length;
|
||||
else
|
||||
len = res->start + resource_size(res)
|
||||
- bre->start;
|
||||
__add_badblock_range(bb, start - res->start, len);
|
||||
continue;
|
||||
}
|
||||
/*
|
||||
* Deal with overlap for badrange starting before
|
||||
* the namespace.
|
||||
*/
|
||||
if (bre->start < res->start) {
|
||||
u64 len;
|
||||
|
||||
if (bre_end < res->end)
|
||||
len = bre->start + bre->length - res->start;
|
||||
else
|
||||
len = resource_size(res);
|
||||
__add_badblock_range(bb, 0, len);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* nvdimm_badblocks_populate() - Convert a list of badranges to badblocks
|
||||
* @region: parent region of the range to interrogate
|
||||
* @bb: badblocks instance to populate
|
||||
* @res: resource range to consider
|
||||
*
|
||||
* The badrange list generated during bus initialization may contain
|
||||
* multiple, possibly overlapping physical address ranges. Compare each
|
||||
* of these ranges to the resource range currently being initialized,
|
||||
* and add badblocks entries for all matching sub-ranges
|
||||
*/
|
||||
void nvdimm_badblocks_populate(struct nd_region *nd_region,
|
||||
struct badblocks *bb, const struct resource *res)
|
||||
{
|
||||
struct nvdimm_bus *nvdimm_bus;
|
||||
|
||||
if (!is_memory(&nd_region->dev)) {
|
||||
dev_WARN_ONCE(&nd_region->dev, 1,
|
||||
"%s only valid for pmem regions\n", __func__);
|
||||
return;
|
||||
}
|
||||
nvdimm_bus = walk_to_nvdimm_bus(&nd_region->dev);
|
||||
|
||||
nvdimm_bus_lock(&nvdimm_bus->dev);
|
||||
badblocks_populate(&nvdimm_bus->badrange, bb, res);
|
||||
nvdimm_bus_unlock(&nvdimm_bus->dev);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(nvdimm_badblocks_populate);
|
||||
|
|
@ -11,6 +11,7 @@
|
|||
* General Public License for more details.
|
||||
*/
|
||||
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
||||
#include <linux/libnvdimm.h>
|
||||
#include <linux/sched/mm.h>
|
||||
#include <linux/vmalloc.h>
|
||||
#include <linux/uaccess.h>
|
||||
|
|
@ -221,7 +222,7 @@ static void nvdimm_account_cleared_poison(struct nvdimm_bus *nvdimm_bus,
|
|||
phys_addr_t phys, u64 cleared)
|
||||
{
|
||||
if (cleared > 0)
|
||||
nvdimm_forget_poison(nvdimm_bus, phys, cleared);
|
||||
badrange_forget(&nvdimm_bus->badrange, phys, cleared);
|
||||
|
||||
if (cleared > 0 && cleared / 512)
|
||||
nvdimm_clear_badblocks_regions(nvdimm_bus, phys, cleared);
|
||||
|
|
@ -344,11 +345,10 @@ struct nvdimm_bus *nvdimm_bus_register(struct device *parent,
|
|||
return NULL;
|
||||
INIT_LIST_HEAD(&nvdimm_bus->list);
|
||||
INIT_LIST_HEAD(&nvdimm_bus->mapping_list);
|
||||
INIT_LIST_HEAD(&nvdimm_bus->poison_list);
|
||||
init_waitqueue_head(&nvdimm_bus->probe_wait);
|
||||
nvdimm_bus->id = ida_simple_get(&nd_ida, 0, 0, GFP_KERNEL);
|
||||
mutex_init(&nvdimm_bus->reconfig_mutex);
|
||||
spin_lock_init(&nvdimm_bus->poison_lock);
|
||||
badrange_init(&nvdimm_bus->badrange);
|
||||
if (nvdimm_bus->id < 0) {
|
||||
kfree(nvdimm_bus);
|
||||
return NULL;
|
||||
|
|
@ -395,15 +395,15 @@ static int child_unregister(struct device *dev, void *data)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void free_poison_list(struct list_head *poison_list)
|
||||
static void free_badrange_list(struct list_head *badrange_list)
|
||||
{
|
||||
struct nd_poison *pl, *next;
|
||||
struct badrange_entry *bre, *next;
|
||||
|
||||
list_for_each_entry_safe(pl, next, poison_list, list) {
|
||||
list_del(&pl->list);
|
||||
kfree(pl);
|
||||
list_for_each_entry_safe(bre, next, badrange_list, list) {
|
||||
list_del(&bre->list);
|
||||
kfree(bre);
|
||||
}
|
||||
list_del_init(poison_list);
|
||||
list_del_init(badrange_list);
|
||||
}
|
||||
|
||||
static int nd_bus_remove(struct device *dev)
|
||||
|
|
@ -417,9 +417,9 @@ static int nd_bus_remove(struct device *dev)
|
|||
nd_synchronize();
|
||||
device_for_each_child(&nvdimm_bus->dev, NULL, child_unregister);
|
||||
|
||||
spin_lock(&nvdimm_bus->poison_lock);
|
||||
free_poison_list(&nvdimm_bus->poison_list);
|
||||
spin_unlock(&nvdimm_bus->poison_lock);
|
||||
spin_lock(&nvdimm_bus->badrange.lock);
|
||||
free_badrange_list(&nvdimm_bus->badrange.list);
|
||||
spin_unlock(&nvdimm_bus->badrange.lock);
|
||||
|
||||
nvdimm_bus_destroy_ndctl(nvdimm_bus);
|
||||
|
||||
|
|
|
|||
|
|
@ -398,265 +398,11 @@ struct attribute_group nvdimm_bus_attribute_group = {
|
|||
};
|
||||
EXPORT_SYMBOL_GPL(nvdimm_bus_attribute_group);
|
||||
|
||||
static void set_badblock(struct badblocks *bb, sector_t s, int num)
|
||||
int nvdimm_bus_add_badrange(struct nvdimm_bus *nvdimm_bus, u64 addr, u64 length)
|
||||
{
|
||||
dev_dbg(bb->dev, "Found a poison range (0x%llx, 0x%llx)\n",
|
||||
(u64) s * 512, (u64) num * 512);
|
||||
/* this isn't an error as the hardware will still throw an exception */
|
||||
if (badblocks_set(bb, s, num, 1))
|
||||
dev_info_once(bb->dev, "%s: failed for sector %llx\n",
|
||||
__func__, (u64) s);
|
||||
return badrange_add(&nvdimm_bus->badrange, addr, length);
|
||||
}
|
||||
|
||||
/**
|
||||
* __add_badblock_range() - Convert a physical address range to bad sectors
|
||||
* @bb: badblocks instance to populate
|
||||
* @ns_offset: namespace offset where the error range begins (in bytes)
|
||||
* @len: number of bytes of poison to be added
|
||||
*
|
||||
* This assumes that the range provided with (ns_offset, len) is within
|
||||
* the bounds of physical addresses for this namespace, i.e. lies in the
|
||||
* interval [ns_start, ns_start + ns_size)
|
||||
*/
|
||||
static void __add_badblock_range(struct badblocks *bb, u64 ns_offset, u64 len)
|
||||
{
|
||||
const unsigned int sector_size = 512;
|
||||
sector_t start_sector, end_sector;
|
||||
u64 num_sectors;
|
||||
u32 rem;
|
||||
|
||||
start_sector = div_u64(ns_offset, sector_size);
|
||||
end_sector = div_u64_rem(ns_offset + len, sector_size, &rem);
|
||||
if (rem)
|
||||
end_sector++;
|
||||
num_sectors = end_sector - start_sector;
|
||||
|
||||
if (unlikely(num_sectors > (u64)INT_MAX)) {
|
||||
u64 remaining = num_sectors;
|
||||
sector_t s = start_sector;
|
||||
|
||||
while (remaining) {
|
||||
int done = min_t(u64, remaining, INT_MAX);
|
||||
|
||||
set_badblock(bb, s, done);
|
||||
remaining -= done;
|
||||
s += done;
|
||||
}
|
||||
} else
|
||||
set_badblock(bb, start_sector, num_sectors);
|
||||
}
|
||||
|
||||
static void badblocks_populate(struct list_head *poison_list,
|
||||
struct badblocks *bb, const struct resource *res)
|
||||
{
|
||||
struct nd_poison *pl;
|
||||
|
||||
if (list_empty(poison_list))
|
||||
return;
|
||||
|
||||
list_for_each_entry(pl, poison_list, list) {
|
||||
u64 pl_end = pl->start + pl->length - 1;
|
||||
|
||||
/* Discard intervals with no intersection */
|
||||
if (pl_end < res->start)
|
||||
continue;
|
||||
if (pl->start > res->end)
|
||||
continue;
|
||||
/* Deal with any overlap after start of the namespace */
|
||||
if (pl->start >= res->start) {
|
||||
u64 start = pl->start;
|
||||
u64 len;
|
||||
|
||||
if (pl_end <= res->end)
|
||||
len = pl->length;
|
||||
else
|
||||
len = res->start + resource_size(res)
|
||||
- pl->start;
|
||||
__add_badblock_range(bb, start - res->start, len);
|
||||
continue;
|
||||
}
|
||||
/* Deal with overlap for poison starting before the namespace */
|
||||
if (pl->start < res->start) {
|
||||
u64 len;
|
||||
|
||||
if (pl_end < res->end)
|
||||
len = pl->start + pl->length - res->start;
|
||||
else
|
||||
len = resource_size(res);
|
||||
__add_badblock_range(bb, 0, len);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* nvdimm_badblocks_populate() - Convert a list of poison ranges to badblocks
|
||||
* @region: parent region of the range to interrogate
|
||||
* @bb: badblocks instance to populate
|
||||
* @res: resource range to consider
|
||||
*
|
||||
* The poison list generated during bus initialization may contain
|
||||
* multiple, possibly overlapping physical address ranges. Compare each
|
||||
* of these ranges to the resource range currently being initialized,
|
||||
* and add badblocks entries for all matching sub-ranges
|
||||
*/
|
||||
void nvdimm_badblocks_populate(struct nd_region *nd_region,
|
||||
struct badblocks *bb, const struct resource *res)
|
||||
{
|
||||
struct nvdimm_bus *nvdimm_bus;
|
||||
struct list_head *poison_list;
|
||||
|
||||
if (!is_memory(&nd_region->dev)) {
|
||||
dev_WARN_ONCE(&nd_region->dev, 1,
|
||||
"%s only valid for pmem regions\n", __func__);
|
||||
return;
|
||||
}
|
||||
nvdimm_bus = walk_to_nvdimm_bus(&nd_region->dev);
|
||||
poison_list = &nvdimm_bus->poison_list;
|
||||
|
||||
nvdimm_bus_lock(&nvdimm_bus->dev);
|
||||
badblocks_populate(poison_list, bb, res);
|
||||
nvdimm_bus_unlock(&nvdimm_bus->dev);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(nvdimm_badblocks_populate);
|
||||
|
||||
static void append_poison_entry(struct nvdimm_bus *nvdimm_bus,
|
||||
struct nd_poison *pl, u64 addr, u64 length)
|
||||
{
|
||||
lockdep_assert_held(&nvdimm_bus->poison_lock);
|
||||
pl->start = addr;
|
||||
pl->length = length;
|
||||
list_add_tail(&pl->list, &nvdimm_bus->poison_list);
|
||||
}
|
||||
|
||||
static int add_poison(struct nvdimm_bus *nvdimm_bus, u64 addr, u64 length,
|
||||
gfp_t flags)
|
||||
{
|
||||
struct nd_poison *pl;
|
||||
|
||||
pl = kzalloc(sizeof(*pl), flags);
|
||||
if (!pl)
|
||||
return -ENOMEM;
|
||||
|
||||
append_poison_entry(nvdimm_bus, pl, addr, length);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int bus_add_poison(struct nvdimm_bus *nvdimm_bus, u64 addr, u64 length)
|
||||
{
|
||||
struct nd_poison *pl, *pl_new;
|
||||
|
||||
spin_unlock(&nvdimm_bus->poison_lock);
|
||||
pl_new = kzalloc(sizeof(*pl_new), GFP_KERNEL);
|
||||
spin_lock(&nvdimm_bus->poison_lock);
|
||||
|
||||
if (list_empty(&nvdimm_bus->poison_list)) {
|
||||
if (!pl_new)
|
||||
return -ENOMEM;
|
||||
append_poison_entry(nvdimm_bus, pl_new, addr, length);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* There is a chance this is a duplicate, check for those first.
|
||||
* This will be the common case as ARS_STATUS returns all known
|
||||
* errors in the SPA space, and we can't query it per region
|
||||
*/
|
||||
list_for_each_entry(pl, &nvdimm_bus->poison_list, list)
|
||||
if (pl->start == addr) {
|
||||
/* If length has changed, update this list entry */
|
||||
if (pl->length != length)
|
||||
pl->length = length;
|
||||
kfree(pl_new);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* If not a duplicate or a simple length update, add the entry as is,
|
||||
* as any overlapping ranges will get resolved when the list is consumed
|
||||
* and converted to badblocks
|
||||
*/
|
||||
if (!pl_new)
|
||||
return -ENOMEM;
|
||||
append_poison_entry(nvdimm_bus, pl_new, addr, length);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int nvdimm_bus_add_poison(struct nvdimm_bus *nvdimm_bus, u64 addr, u64 length)
|
||||
{
|
||||
int rc;
|
||||
|
||||
spin_lock(&nvdimm_bus->poison_lock);
|
||||
rc = bus_add_poison(nvdimm_bus, addr, length);
|
||||
spin_unlock(&nvdimm_bus->poison_lock);
|
||||
|
||||
return rc;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(nvdimm_bus_add_poison);
|
||||
|
||||
void nvdimm_forget_poison(struct nvdimm_bus *nvdimm_bus, phys_addr_t start,
|
||||
unsigned int len)
|
||||
{
|
||||
struct list_head *poison_list = &nvdimm_bus->poison_list;
|
||||
u64 clr_end = start + len - 1;
|
||||
struct nd_poison *pl, *next;
|
||||
|
||||
spin_lock(&nvdimm_bus->poison_lock);
|
||||
WARN_ON_ONCE(list_empty(poison_list));
|
||||
|
||||
/*
|
||||
* [start, clr_end] is the poison interval being cleared.
|
||||
* [pl->start, pl_end] is the poison_list entry we're comparing
|
||||
* the above interval against. The poison list entry may need
|
||||
* to be modified (update either start or length), deleted, or
|
||||
* split into two based on the overlap characteristics
|
||||
*/
|
||||
|
||||
list_for_each_entry_safe(pl, next, poison_list, list) {
|
||||
u64 pl_end = pl->start + pl->length - 1;
|
||||
|
||||
/* Skip intervals with no intersection */
|
||||
if (pl_end < start)
|
||||
continue;
|
||||
if (pl->start > clr_end)
|
||||
continue;
|
||||
/* Delete completely overlapped poison entries */
|
||||
if ((pl->start >= start) && (pl_end <= clr_end)) {
|
||||
list_del(&pl->list);
|
||||
kfree(pl);
|
||||
continue;
|
||||
}
|
||||
/* Adjust start point of partially cleared entries */
|
||||
if ((start <= pl->start) && (clr_end > pl->start)) {
|
||||
pl->length -= clr_end - pl->start + 1;
|
||||
pl->start = clr_end + 1;
|
||||
continue;
|
||||
}
|
||||
/* Adjust pl->length for partial clearing at the tail end */
|
||||
if ((pl->start < start) && (pl_end <= clr_end)) {
|
||||
/* pl->start remains the same */
|
||||
pl->length = start - pl->start;
|
||||
continue;
|
||||
}
|
||||
/*
|
||||
* If clearing in the middle of an entry, we split it into
|
||||
* two by modifying the current entry to represent one half of
|
||||
* the split, and adding a new entry for the second half.
|
||||
*/
|
||||
if ((pl->start < start) && (pl_end > clr_end)) {
|
||||
u64 new_start = clr_end + 1;
|
||||
u64 new_len = pl_end - new_start + 1;
|
||||
|
||||
/* Add new entry covering the right half */
|
||||
add_poison(nvdimm_bus, new_start, new_len, GFP_NOWAIT);
|
||||
/* Adjust this entry to cover the left half */
|
||||
pl->length = start - pl->start;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
spin_unlock(&nvdimm_bus->poison_lock);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(nvdimm_forget_poison);
|
||||
EXPORT_SYMBOL_GPL(nvdimm_bus_add_badrange);
|
||||
|
||||
#ifdef CONFIG_BLK_DEV_INTEGRITY
|
||||
int nd_integrity_init(struct gendisk *disk, unsigned long meta_size)
|
||||
|
|
|
|||
|
|
@ -55,6 +55,8 @@ static int nvdimm_probe(struct device *dev)
|
|||
goto err;
|
||||
|
||||
rc = nvdimm_init_config_data(ndd);
|
||||
if (rc == -EACCES)
|
||||
nvdimm_set_locked(dev);
|
||||
if (rc)
|
||||
goto err;
|
||||
|
||||
|
|
@ -68,6 +70,7 @@ static int nvdimm_probe(struct device *dev)
|
|||
rc = nd_label_reserve_dpa(ndd);
|
||||
if (ndd->ns_current >= 0)
|
||||
nvdimm_set_aliasing(dev);
|
||||
nvdimm_clear_locked(dev);
|
||||
nvdimm_bus_unlock(dev);
|
||||
|
||||
if (rc)
|
||||
|
|
|
|||
|
|
@ -200,6 +200,13 @@ void nvdimm_set_locked(struct device *dev)
|
|||
set_bit(NDD_LOCKED, &nvdimm->flags);
|
||||
}
|
||||
|
||||
void nvdimm_clear_locked(struct device *dev)
|
||||
{
|
||||
struct nvdimm *nvdimm = to_nvdimm(dev);
|
||||
|
||||
clear_bit(NDD_LOCKED, &nvdimm->flags);
|
||||
}
|
||||
|
||||
static void nvdimm_release(struct device *dev)
|
||||
{
|
||||
struct nvdimm *nvdimm = to_nvdimm(dev);
|
||||
|
|
@ -324,6 +331,17 @@ static ssize_t commands_show(struct device *dev,
|
|||
}
|
||||
static DEVICE_ATTR_RO(commands);
|
||||
|
||||
static ssize_t flags_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct nvdimm *nvdimm = to_nvdimm(dev);
|
||||
|
||||
return sprintf(buf, "%s%s\n",
|
||||
test_bit(NDD_ALIASING, &nvdimm->flags) ? "alias " : "",
|
||||
test_bit(NDD_LOCKED, &nvdimm->flags) ? "lock " : "");
|
||||
}
|
||||
static DEVICE_ATTR_RO(flags);
|
||||
|
||||
static ssize_t state_show(struct device *dev, struct device_attribute *attr,
|
||||
char *buf)
|
||||
{
|
||||
|
|
@ -365,6 +383,7 @@ static DEVICE_ATTR_RO(available_slots);
|
|||
|
||||
static struct attribute *nvdimm_attributes[] = {
|
||||
&dev_attr_state.attr,
|
||||
&dev_attr_flags.attr,
|
||||
&dev_attr_commands.attr,
|
||||
&dev_attr_available_slots.attr,
|
||||
NULL,
|
||||
|
|
|
|||
|
|
@ -1050,7 +1050,7 @@ static int init_labels(struct nd_mapping *nd_mapping, int num_labels)
|
|||
nsindex = to_namespace_index(ndd, 0);
|
||||
memset(nsindex, 0, ndd->nsarea.config_size);
|
||||
for (i = 0; i < 2; i++) {
|
||||
int rc = nd_label_write_index(ndd, i, i*2, ND_NSINDEX_INIT);
|
||||
int rc = nd_label_write_index(ndd, i, 3 - i, ND_NSINDEX_INIT);
|
||||
|
||||
if (rc)
|
||||
return rc;
|
||||
|
|
|
|||
|
|
@ -1620,7 +1620,7 @@ static umode_t namespace_visible(struct kobject *kobj,
|
|||
if (a == &dev_attr_resource.attr) {
|
||||
if (is_namespace_blk(dev))
|
||||
return 0;
|
||||
return a->mode;
|
||||
return 0400;
|
||||
}
|
||||
|
||||
if (is_namespace_pmem(dev) || is_namespace_blk(dev)) {
|
||||
|
|
@ -1875,7 +1875,7 @@ static int select_pmem_id(struct nd_region *nd_region, u8 *pmem_id)
|
|||
* @nspm: target namespace to create
|
||||
* @nd_label: target pmem namespace label to evaluate
|
||||
*/
|
||||
struct device *create_namespace_pmem(struct nd_region *nd_region,
|
||||
static struct device *create_namespace_pmem(struct nd_region *nd_region,
|
||||
struct nd_namespace_index *nsindex,
|
||||
struct nd_namespace_label *nd_label)
|
||||
{
|
||||
|
|
@ -2186,7 +2186,7 @@ static int add_namespace_resource(struct nd_region *nd_region,
|
|||
return i;
|
||||
}
|
||||
|
||||
struct device *create_namespace_blk(struct nd_region *nd_region,
|
||||
static struct device *create_namespace_blk(struct nd_region *nd_region,
|
||||
struct nd_namespace_label *nd_label, int count)
|
||||
{
|
||||
|
||||
|
|
|
|||
|
|
@ -29,10 +29,9 @@ struct nvdimm_bus {
|
|||
struct list_head list;
|
||||
struct device dev;
|
||||
int id, probe_active;
|
||||
struct list_head poison_list;
|
||||
struct list_head mapping_list;
|
||||
struct mutex reconfig_mutex;
|
||||
spinlock_t poison_lock;
|
||||
struct badrange badrange;
|
||||
};
|
||||
|
||||
struct nvdimm {
|
||||
|
|
|
|||
|
|
@ -34,12 +34,6 @@ enum {
|
|||
NVDIMM_IO_ATOMIC = 1,
|
||||
};
|
||||
|
||||
struct nd_poison {
|
||||
u64 start;
|
||||
u64 length;
|
||||
struct list_head list;
|
||||
};
|
||||
|
||||
struct nvdimm_drvdata {
|
||||
struct device *dev;
|
||||
int nslabel_size;
|
||||
|
|
@ -254,6 +248,7 @@ long nvdimm_clear_poison(struct device *dev, phys_addr_t phys,
|
|||
unsigned int len);
|
||||
void nvdimm_set_aliasing(struct device *dev);
|
||||
void nvdimm_set_locked(struct device *dev);
|
||||
void nvdimm_clear_locked(struct device *dev);
|
||||
struct nd_btt *to_nd_btt(struct device *dev);
|
||||
|
||||
struct nd_gen_sb {
|
||||
|
|
|
|||
|
|
@ -282,8 +282,16 @@ static struct attribute *nd_pfn_attributes[] = {
|
|||
NULL,
|
||||
};
|
||||
|
||||
static umode_t pfn_visible(struct kobject *kobj, struct attribute *a, int n)
|
||||
{
|
||||
if (a == &dev_attr_resource.attr)
|
||||
return 0400;
|
||||
return a->mode;
|
||||
}
|
||||
|
||||
struct attribute_group nd_pfn_attribute_group = {
|
||||
.attrs = nd_pfn_attributes,
|
||||
.is_visible = pfn_visible,
|
||||
};
|
||||
|
||||
static const struct attribute_group *nd_pfn_attribute_groups[] = {
|
||||
|
|
|
|||
|
|
@ -562,8 +562,12 @@ static umode_t region_visible(struct kobject *kobj, struct attribute *a, int n)
|
|||
if (!is_nd_pmem(dev) && a == &dev_attr_badblocks.attr)
|
||||
return 0;
|
||||
|
||||
if (!is_nd_pmem(dev) && a == &dev_attr_resource.attr)
|
||||
return 0;
|
||||
if (a == &dev_attr_resource.attr) {
|
||||
if (is_nd_pmem(dev))
|
||||
return 0400;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (a == &dev_attr_deep_flush.attr) {
|
||||
int has_flush = nvdimm_has_flush(nd_region);
|
||||
|
|
|
|||
Loading…
Reference in a new issue