mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-12 13:55:32 +00:00
![Vishal Verma](/assets/img/avatar_default.png)
nsio_rw_bytes can clear media errors, but this cannot be done while we are in an atomic context due to locking within ACPI. From the BTT, ->rw_bytes may be called either from atomic or process context depending on whether the calls happen during initialization or during IO. During init, we want to ensure error clearing happens, and the flag marking process context allows nsio_rw_bytes to do that. When called during IO, we're in atomic context, and error clearing can be skipped. Cc: Dan Williams <dan.j.williams@intel.com> Signed-off-by: Vishal Verma <vishal.l.verma@intel.com> Signed-off-by: Dan Williams <dan.j.williams@intel.com>
172 lines
5.4 KiB
C
172 lines
5.4 KiB
C
/*
|
|
* 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.
|
|
*/
|
|
#ifndef __LINUX_ND_H__
|
|
#define __LINUX_ND_H__
|
|
#include <linux/fs.h>
|
|
#include <linux/ndctl.h>
|
|
#include <linux/device.h>
|
|
#include <linux/badblocks.h>
|
|
|
|
enum nvdimm_event {
|
|
NVDIMM_REVALIDATE_POISON,
|
|
};
|
|
|
|
struct nd_device_driver {
|
|
struct device_driver drv;
|
|
unsigned long type;
|
|
int (*probe)(struct device *dev);
|
|
int (*remove)(struct device *dev);
|
|
void (*shutdown)(struct device *dev);
|
|
void (*notify)(struct device *dev, enum nvdimm_event event);
|
|
};
|
|
|
|
static inline struct nd_device_driver *to_nd_device_driver(
|
|
struct device_driver *drv)
|
|
{
|
|
return container_of(drv, struct nd_device_driver, drv);
|
|
};
|
|
|
|
/**
|
|
* struct nd_namespace_common - core infrastructure of a namespace
|
|
* @force_raw: ignore other personalities for the namespace (e.g. btt)
|
|
* @dev: device model node
|
|
* @claim: when set a another personality has taken ownership of the namespace
|
|
* @rw_bytes: access the raw namespace capacity with byte-aligned transfers
|
|
*/
|
|
struct nd_namespace_common {
|
|
int force_raw;
|
|
struct device dev;
|
|
struct device *claim;
|
|
int (*rw_bytes)(struct nd_namespace_common *, resource_size_t offset,
|
|
void *buf, size_t size, int rw, unsigned long flags);
|
|
};
|
|
|
|
static inline struct nd_namespace_common *to_ndns(struct device *dev)
|
|
{
|
|
return container_of(dev, struct nd_namespace_common, dev);
|
|
}
|
|
|
|
/**
|
|
* struct nd_namespace_io - device representation of a persistent memory range
|
|
* @dev: namespace device created by the nd region driver
|
|
* @res: struct resource conversion of a NFIT SPA table
|
|
* @size: cached resource_size(@res) for fast path size checks
|
|
* @addr: virtual address to access the namespace range
|
|
* @bb: badblocks list for the namespace range
|
|
*/
|
|
struct nd_namespace_io {
|
|
struct nd_namespace_common common;
|
|
struct resource res;
|
|
resource_size_t size;
|
|
void *addr;
|
|
struct badblocks bb;
|
|
};
|
|
|
|
/**
|
|
* struct nd_namespace_pmem - namespace device for dimm-backed interleaved memory
|
|
* @nsio: device and system physical address range to drive
|
|
* @alt_name: namespace name supplied in the dimm label
|
|
* @uuid: namespace name supplied in the dimm label
|
|
* @id: ida allocated id
|
|
*/
|
|
struct nd_namespace_pmem {
|
|
struct nd_namespace_io nsio;
|
|
char *alt_name;
|
|
u8 *uuid;
|
|
int id;
|
|
};
|
|
|
|
/**
|
|
* struct nd_namespace_blk - namespace for dimm-bounded persistent memory
|
|
* @alt_name: namespace name supplied in the dimm label
|
|
* @uuid: namespace name supplied in the dimm label
|
|
* @id: ida allocated id
|
|
* @lbasize: blk namespaces have a native sector size when btt not present
|
|
* @size: sum of all the resource ranges allocated to this namespace
|
|
* @num_resources: number of dpa extents to claim
|
|
* @res: discontiguous dpa extents for given dimm
|
|
*/
|
|
struct nd_namespace_blk {
|
|
struct nd_namespace_common common;
|
|
char *alt_name;
|
|
u8 *uuid;
|
|
int id;
|
|
unsigned long lbasize;
|
|
resource_size_t size;
|
|
int num_resources;
|
|
struct resource **res;
|
|
};
|
|
|
|
static inline struct nd_namespace_io *to_nd_namespace_io(const struct device *dev)
|
|
{
|
|
return container_of(dev, struct nd_namespace_io, common.dev);
|
|
}
|
|
|
|
static inline struct nd_namespace_pmem *to_nd_namespace_pmem(const struct device *dev)
|
|
{
|
|
struct nd_namespace_io *nsio = to_nd_namespace_io(dev);
|
|
|
|
return container_of(nsio, struct nd_namespace_pmem, nsio);
|
|
}
|
|
|
|
static inline struct nd_namespace_blk *to_nd_namespace_blk(const struct device *dev)
|
|
{
|
|
return container_of(dev, struct nd_namespace_blk, common.dev);
|
|
}
|
|
|
|
/**
|
|
* nvdimm_read_bytes() - synchronously read bytes from an nvdimm namespace
|
|
* @ndns: device to read
|
|
* @offset: namespace-relative starting offset
|
|
* @buf: buffer to fill
|
|
* @size: transfer length
|
|
*
|
|
* @buf is up-to-date upon return from this routine.
|
|
*/
|
|
static inline int nvdimm_read_bytes(struct nd_namespace_common *ndns,
|
|
resource_size_t offset, void *buf, size_t size,
|
|
unsigned long flags)
|
|
{
|
|
return ndns->rw_bytes(ndns, offset, buf, size, READ, flags);
|
|
}
|
|
|
|
/**
|
|
* nvdimm_write_bytes() - synchronously write bytes to an nvdimm namespace
|
|
* @ndns: device to read
|
|
* @offset: namespace-relative starting offset
|
|
* @buf: buffer to drain
|
|
* @size: transfer length
|
|
*
|
|
* NVDIMM Namepaces disks do not implement sectors internally. Depending on
|
|
* the @ndns, 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 @ndns driver, if at all.
|
|
*/
|
|
static inline int nvdimm_write_bytes(struct nd_namespace_common *ndns,
|
|
resource_size_t offset, void *buf, size_t size,
|
|
unsigned long flags)
|
|
{
|
|
return ndns->rw_bytes(ndns, offset, buf, size, WRITE, flags);
|
|
}
|
|
|
|
#define MODULE_ALIAS_ND_DEVICE(type) \
|
|
MODULE_ALIAS("nd:t" __stringify(type) "*")
|
|
#define ND_DEVICE_MODALIAS_FMT "nd:t%d"
|
|
|
|
struct nd_region;
|
|
void nvdimm_region_notify(struct nd_region *nd_region, enum nvdimm_event event);
|
|
int __must_check __nd_driver_register(struct nd_device_driver *nd_drv,
|
|
struct module *module, const char *mod_name);
|
|
#define nd_driver_register(driver) \
|
|
__nd_driver_register(driver, THIS_MODULE, KBUILD_MODNAME)
|
|
#endif /* __LINUX_ND_H__ */
|