// SPDX-License-Identifier: GPL-2.0-only

/*

* Copyright(c) 2013-2015 Intel Corporation. All rights reserved.

*/

#include <linux/kstrtox.h>

#include <linux/module.h>

#include <linux/device.h>

#include <linux/sort.h>

#include <linux/slab.h>

#include <linux/list.h>

#include <linux/nd.h>

#include "nd-core.h"

#include "pmem.h"

#include "pfn.h"

#include "nd.h"

static void namespace_io_release(struct device *dev)

{

struct nd_namespace_io *nsio = to_nd_namespace_io(dev);

kfree(nsio);

}

static void namespace_pmem_release(struct device *dev)

{

struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev);

struct nd_region *nd_region = to_nd_region(dev->parent);

if (nspm->id >= 0)

ida_free(&nd_region->ns_ida, nspm->id);

kfree(nspm->alt_name);

kfree(nspm->uuid);

kfree(nspm);

}

static bool is_namespace_pmem(const struct device *dev);

static bool is_namespace_io(const struct device *dev);

static int is_uuid_busy(struct device *dev, void *data)

{

uuid_t *uuid1 = data, *uuid2 = NULL;

if (is_namespace_pmem(dev)) {

struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev);

uuid2 = nspm->uuid;

} else if (is_nd_btt(dev)) {

struct nd_btt *nd_btt = to_nd_btt(dev);

uuid2 = nd_btt->uuid;

} else if (is_nd_pfn(dev)) {

struct nd_pfn *nd_pfn = to_nd_pfn(dev);

uuid2 = nd_pfn->uuid;

}

if (uuid2 && uuid_equal(uuid1, uuid2))

return -EBUSY;

return 0;

}

static int is_namespace_uuid_busy(struct device *dev, void *data)

{

if (is_nd_region(dev))

return device_for_each_child(dev, data, is_uuid_busy);

return 0;

}

/**

* nd_is_uuid_unique - verify that no other namespace has @uuid

* @dev: any device on a nvdimm_bus

* @uuid: uuid to check

*

* Returns: %true if the uuid is unique, %false if not

*/

bool nd_is_uuid_unique(struct device *dev, uuid_t *uuid)

{

struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);

if (!nvdimm_bus)

return false;

WARN_ON_ONCE(!is_nvdimm_bus_locked(&nvdimm_bus->dev));

if (device_for_each_child(&nvdimm_bus->dev, uuid,

is_namespace_uuid_busy) != 0)

return false;

return true;

}

bool pmem_should_map_pages(struct device *dev)

{

struct nd_region *nd_region = to_nd_region(dev->parent);

struct nd_namespace_common *ndns = to_ndns(dev);

struct nd_namespace_io *nsio;

if (!IS_ENABLED(CONFIG_ZONE_DEVICE))

return false;

if (!test_bit(ND_REGION_PAGEMAP, &nd_region->flags))

return false;

if (is_nd_pfn(dev) || is_nd_btt(dev))

return false;

if (ndns->force_raw)

return false;

nsio = to_nd_namespace_io(dev);

if (region_intersects(nsio->res.start, resource_size(&nsio->res),

IORESOURCE_SYSTEM_RAM,

IORES_DESC_NONE) == REGION_MIXED)

return false;

return ARCH_MEMREMAP_PMEM == MEMREMAP_WB;

}

EXPORT_SYMBOL(pmem_should_map_pages);

unsigned int pmem_sector_size(struct nd_namespace_common *ndns)

{

if (is_namespace_pmem(&ndns->dev)) {

struct nd_namespace_pmem *nspm;

nspm = to_nd_namespace_pmem(&ndns->dev);

if (nspm->lbasize == 0 || nspm->lbasize == 512)

/* default */;

else if (nspm->lbasize == 4096)

return 4096;

else

dev_WARN(&ndns->dev, "unsupported sector size: %ld\n",

nspm->lbasize);

}

/*

* There is no namespace label (is_namespace_io()), or the label

* indicates the default sector size.

*/

return 512;

}

EXPORT_SYMBOL(pmem_sector_size);

const char *nvdimm_namespace_disk_name(struct nd_namespace_common *ndns,

char *name)

{

struct nd_region *nd_region = to_nd_region(ndns->dev.parent);

const char *suffix = NULL;

if (ndns->claim && is_nd_btt(ndns->claim))

suffix = "s";

if (is_namespace_pmem(&ndns->dev) || is_namespace_io(&ndns->dev)) {

int nsidx = 0;

if (is_namespace_pmem(&ndns->dev)) {

struct nd_namespace_pmem *nspm;

nspm = to_nd_namespace_pmem(&ndns->dev);

nsidx = nspm->id;

}

if (nsidx)

sprintf(name, "pmem%d.%d%s", nd_region->id, nsidx,

suffix ? suffix : "");

else

sprintf(name, "pmem%d%s", nd_region->id,

suffix ? suffix : "");

} else {

return NULL;

}

return name;

}

EXPORT_SYMBOL(nvdimm_namespace_disk_name);

const uuid_t *nd_dev_to_uuid(struct device *dev)

{

if (dev && is_namespace_pmem(dev)) {

struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev);

return nspm->uuid;

}

return &uuid_null;

}

EXPORT_SYMBOL(nd_dev_to_uuid);

static ssize_t nstype_show(struct device *dev,

struct device_attribute *attr, char *buf)

{

struct nd_region *nd_region = to_nd_region(dev->parent);

return sprintf(buf, "%d\n", nd_region_to_nstype(nd_region));

}

static DEVICE_ATTR_RO(nstype);

static ssize_t __alt_name_store(struct device *dev, const char *buf,

const size_t len)

{

char *input, *pos, *alt_name, **ns_altname;

ssize_t rc;

if (is_namespace_pmem(dev)) {

struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev);

ns_altname = &nspm->alt_name;

} else

return -ENXIO;

if (dev->driver || to_ndns(dev)->claim)

return -EBUSY;

input = kstrndup(buf, len, GFP_KERNEL);

if (!input)

return -ENOMEM;

pos = strim(input);

if (strlen(pos) + 1 > NSLABEL_NAME_LEN) {

rc = -EINVAL;

goto out;

}

alt_name = kzalloc(NSLABEL_NAME_LEN, GFP_KERNEL);

if (!alt_name) {

rc = -ENOMEM;

goto out;

}

kfree(*ns_altname);

*ns_altname = alt_name;

sprintf(*ns_altname, "%s", pos);

rc = len;

out:

kfree(input);

return rc;

}

static int nd_namespace_label_update(struct nd_region *nd_region,

struct device *dev)

{

dev_WARN_ONCE(dev, dev->driver || to_ndns(dev)->claim,

"namespace must be idle during label update\n");

if (dev->driver || to_ndns(dev)->claim)

return 0;

/*

* Only allow label writes that will result in a valid namespace

* or deletion of an existing namespace.

*/

if (is_namespace_pmem(dev)) {

struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev);

resource_size_t size = resource_size(&nspm->nsio.res);

if (size == 0 && nspm->uuid)

/* delete allocation */;

else if (!nspm->uuid)

return 0;

return nd_pmem_namespace_label_update(nd_region, nspm, size);

} else

return -ENXIO;

}

static ssize_t alt_name_store(struct device *dev,

struct device_attribute *attr, const char *buf, size_t len)

{

struct nd_region *nd_region = to_nd_region(dev->parent);

ssize_t rc;

guard(device)(dev);

guard(nvdimm_bus)(dev);

wait_nvdimm_bus_probe_idle(dev);

rc = __alt_name_store(dev, buf, len);

if (rc >= 0)

rc = nd_namespace_label_update(nd_region, dev);

dev_dbg(dev, "%s(%zd)\n", rc < 0 ? "fail " : "", rc);

return rc < 0 ? rc : len;

}

static ssize_t alt_name_show(struct device *dev,

struct device_attribute *attr, char *buf)

{

char *ns_altname;

if (is_namespace_pmem(dev)) {

struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev);

ns_altname = nspm->alt_name;

} else

return -ENXIO;

return sprintf(buf, "%s\n", ns_altname ? ns_altname : "");

}

static DEVICE_ATTR_RW(alt_name);

static int scan_free(struct nd_region *nd_region,

struct nd_mapping *nd_mapping, struct nd_label_id *label_id,

resource_size_t n)

{

struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);

int rc = 0;

while (n) {

struct resource *res, *last;

last = NULL;

for_each_dpa_resource(ndd, res)

if (strcmp(res->name, label_id->id) == 0)

last = res;

res = last;

if (!res)

return 0;

if (n >= resource_size(res)) {

n -= resource_size(res);

nd_dbg_dpa(nd_region, ndd, res, "delete %d\n", rc);

nvdimm_free_dpa(ndd, res);

/* retry with last resource deleted */

continue;

}

rc = adjust_resource(res, res->start, resource_size(res) - n);

if (rc == 0)

res->flags |= DPA_RESOURCE_ADJUSTED;

nd_dbg_dpa(nd_region, ndd, res, "shrink %d\n", rc);

break;

}

return rc;

}

/**

* shrink_dpa_allocation - for each dimm in region free n bytes for label_id

* @nd_region: the set of dimms to reclaim @n bytes from

* @label_id: unique identifier for the namespace consuming this dpa range

* @n: number of bytes per-dimm to release

*

* Assumes resources are ordered. Starting from the end try to

* adjust_resource() the allocation to @n, but if @n is larger than the

* allocation delete it and find the 'new' last allocation in the label

* set.

*

* Returns: %0 on success on -errno on error

*/

static int shrink_dpa_allocation(struct nd_region *nd_region,

struct nd_label_id *label_id, resource_size_t n)

{

int i;

for (i = 0; i < nd_region->ndr_mappings; i++) {

struct nd_mapping *nd_mapping = &nd_region->mapping[i];

int rc;

rc = scan_free(nd_region, nd_mapping, label_id, n);

if (rc)

return rc;

}

return 0;

}

static resource_size_t init_dpa_allocation(struct nd_label_id *label_id,

struct nd_region *nd_region, struct nd_mapping *nd_mapping,

resource_size_t n)

{

struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);

struct resource *res;

int rc = 0;

/* first resource allocation for this label-id or dimm */

res = nvdimm_allocate_dpa(ndd, label_id, nd_mapping->start, n);

if (!res)

rc = -EBUSY;

nd_dbg_dpa(nd_region, ndd, res, "init %d\n", rc);

return rc ? n : 0;

}

/**

* space_valid() - validate free dpa space against constraints

* @nd_region: hosting region of the free space

* @ndd: dimm device data for debug

* @label_id: namespace id to allocate space

* @prev: potential allocation that precedes free space

* @next: allocation that follows the given free space range

* @exist: first allocation with same id in the mapping

* @n: range that must satisfied for pmem allocations

* @valid: free space range to validate

*

* BLK-space is valid as long as it does not precede a PMEM

* allocation in a given region. PMEM-space must be contiguous

* and adjacent to an existing allocation (if one

* exists). If reserving PMEM any space is valid.

*/

static void space_valid(struct nd_region *nd_region, struct nvdimm_drvdata *ndd,

struct nd_label_id *label_id, struct resource *prev,

struct resource *next, struct resource *exist,

resource_size_t n, struct resource *valid)

{

bool is_reserve = strcmp(label_id->id, "pmem-reserve") == 0;

unsigned long align;

align = nd_region->align / nd_region->ndr_mappings;

valid->start = ALIGN(valid->start, align);

valid->end = ALIGN_DOWN(valid->end + 1, align) - 1;

if (valid->start >= valid->end)

goto invalid;

if (is_reserve)

return;

/* allocation needs to be contiguous, so this is all or nothing */

if (resource_size(valid) < n)

goto invalid;

/* we've got all the space we need and no existing allocation */

if (!exist)

return;

/* allocation needs to be contiguous with the existing namespace */

if (valid->start == exist->end + 1

|| valid->end == exist->start - 1)

return;

invalid:

/* truncate @valid size to 0 */

valid->end = valid->start - 1;

}

enum alloc_loc {

ALLOC_ERR = 0, ALLOC_BEFORE, ALLOC_MID, ALLOC_AFTER,

};

static resource_size_t scan_allocate(struct nd_region *nd_region,

struct nd_mapping *nd_mapping, struct nd_label_id *label_id,

resource_size_t n)

{

resource_size_t mapping_end = nd_mapping->start + nd_mapping->size - 1;

struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);

struct resource *res, *exist = NULL, valid;

const resource_size_t to_allocate = n;

int first;

for_each_dpa_resource(ndd, res)

if (strcmp(label_id->id, res->name) == 0)

exist = res;

valid.start = nd_mapping->start;

valid.end = mapping_end;

valid.name = "free space";

retry:

first = 0;

for_each_dpa_resource(ndd, res) {

struct resource *next = res->sibling, *new_res = NULL;

resource_size_t allocate, available = 0;

enum alloc_loc loc = ALLOC_ERR;

const char *action;

int rc = 0;

/* ignore resources outside this nd_mapping */

if (res->start > mapping_end)

continue;

if (res->end < nd_mapping->start)

continue;

/* space at the beginning of the mapping */

if (!first++ && res->start > nd_mapping->start) {

valid.start = nd_mapping->start;

valid.end = res->start - 1;

space_valid(nd_region, ndd, label_id, NULL, next, exist,

to_allocate, &valid);

available = resource_size(&valid);

if (available)

loc = ALLOC_BEFORE;

}

/* space between allocations */

if (!loc && next) {

valid.start = res->start + resource_size(res);

valid.end = min(mapping_end, next->start - 1);

space_valid(nd_region, ndd, label_id, res, next, exist,

to_allocate, &valid);

available = resource_size(&valid);

if (available)

loc = ALLOC_MID;

}

/* space at the end of the mapping */

if (!loc && !next) {

valid.start = res->start + resource_size(res);

valid.end = mapping_end;

space_valid(nd_region, ndd, label_id, res, next, exist,

to_allocate, &valid);

available = resource_size(&valid);

if (available)

loc = ALLOC_AFTER;

}

if (!loc || !available)

continue;

allocate = min(available, n);

switch (loc) {

case ALLOC_BEFORE:

if (strcmp(res->name, label_id->id) == 0) {

/* adjust current resource up */

rc = adjust_resource(res, res->start - allocate,

resource_size(res) + allocate);

action = "cur grow up";

} else

action = "allocate";

break;

case ALLOC_MID:

if (strcmp(next->name, label_id->id) == 0) {

/* adjust next resource up */

rc = adjust_resource(next, next->start

- allocate, resource_size(next)

+ allocate);

new_res = next;

action = "next grow up";

} else if (strcmp(res->name, label_id->id) == 0) {

action = "grow down";

} else

action = "allocate";

break;

case ALLOC_AFTER:

if (strcmp(res->name, label_id->id) == 0)

action = "grow down";

else

action = "allocate";

break;

default:

return n;

}

if (strcmp(action, "allocate") == 0) {

new_res = nvdimm_allocate_dpa(ndd, label_id,

valid.start, allocate);

if (!new_res)

rc = -EBUSY;

} else if (strcmp(action, "grow down") == 0) {

/* adjust current resource down */

rc = adjust_resource(res, res->start, resource_size(res)

+ allocate);

if (rc == 0)

res->flags |= DPA_RESOURCE_ADJUSTED;

}

if (!new_res)

new_res = res;

nd_dbg_dpa(nd_region, ndd, new_res, "%s(%d) %d\n",

action, loc, rc);

if (rc)

return n;

n -= allocate;

if (n) {

/*

* Retry scan with newly inserted resources.

* For example, if we did an ALLOC_BEFORE

* insertion there may also have been space

* available for an ALLOC_AFTER insertion, so we

* need to check this same resource again

*/

goto retry;

} else

return 0;

}

if (n == to_allocate)

return init_dpa_allocation(label_id, nd_region, nd_mapping, n);

return n;

}

static int merge_dpa(struct nd_region *nd_region,

struct nd_mapping *nd_mapping, struct nd_label_id *label_id)

{

struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);

struct resource *res;

if (strncmp("pmem", label_id->id, 4) == 0)

return 0;

retry:

for_each_dpa_resource(ndd, res) {

int rc;

struct resource *next = res->sibling;

resource_size_t end = res->start + resource_size(res);

if (!next || strcmp(res->name, label_id->id) != 0

|| strcmp(next->name, label_id->id) != 0

|| end != next->start)

continue;

end += resource_size(next);

nvdimm_free_dpa(ndd, next);

rc = adjust_resource(res, res->start, end - res->start);

nd_dbg_dpa(nd_region, ndd, res, "merge %d\n", rc);

if (rc)

return rc;

res->flags |= DPA_RESOURCE_ADJUSTED;

goto retry;

}

return 0;

}

int __reserve_free_pmem(struct device *dev, void *data)

{

struct nvdimm *nvdimm = data;

struct nd_region *nd_region;

struct nd_label_id label_id;

int i;

if (!is_memory(dev))

return 0;

nd_region = to_nd_region(dev);

if (nd_region->ndr_mappings == 0)

return 0;

memset(&label_id, 0, sizeof(label_id));

strcat(label_id.id, "pmem-reserve");

for (i = 0; i < nd_region->ndr_mappings; i++) {

struct nd_mapping *nd_mapping = &nd_region->mapping[i];

resource_size_t n, rem = 0;

if (nd_mapping->nvdimm != nvdimm)

continue;

n = nd_pmem_available_dpa(nd_region, nd_mapping);

if (n == 0)

return 0;

rem = scan_allocate(nd_region, nd_mapping, &label_id, n);

dev_WARN_ONCE(&nd_region->dev, rem,

"pmem reserve underrun: %#llx of %#llx bytes\n",

(unsigned long long) n - rem,

(unsigned long long) n);

return rem ? -ENXIO : 0;

}

return 0;

}

void release_free_pmem(struct nvdimm_bus *nvdimm_bus,

struct nd_mapping *nd_mapping)

{

struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);

struct resource *res, *_res;

for_each_dpa_resource_safe(ndd, res, _res)

if (strcmp(res->name, "pmem-reserve") == 0)

nvdimm_free_dpa(ndd, res);

}

/**

* grow_dpa_allocation - for each dimm allocate n bytes for @label_id

* @nd_region: the set of dimms to allocate @n more bytes from

* @label_id: unique identifier for the namespace consuming this dpa range

* @n: number of bytes per-dimm to add to the existing allocation

*

* Assumes resources are ordered. For BLK regions, first consume

* BLK-only available DPA free space, then consume PMEM-aliased DPA

* space starting at the highest DPA. For PMEM regions start

* allocations from the start of an interleave set and end at the first

* BLK allocation or the end of the interleave set, whichever comes

* first.

*

* Returns: %0 on success on -errno on error

*/

static int grow_dpa_allocation(struct nd_region *nd_region,

struct nd_label_id *label_id, resource_size_t n)

{

int i;

for (i = 0; i < nd_region->ndr_mappings; i++) {

struct nd_mapping *nd_mapping = &nd_region->mapping[i];

resource_size_t rem = n;

int rc;

rem = scan_allocate(nd_region, nd_mapping, label_id, rem);

dev_WARN_ONCE(&nd_region->dev, rem,

"allocation underrun: %#llx of %#llx bytes\n",

(unsigned long long) n - rem,

(unsigned long long) n);

if (rem)

return -ENXIO;

rc = merge_dpa(nd_region, nd_mapping, label_id);

if (rc)

return rc;

}

return 0;

}

static void nd_namespace_pmem_set_resource(struct nd_region *nd_region,

struct nd_namespace_pmem *nspm, resource_size_t size)

{

struct resource *res = &nspm->nsio.res;

resource_size_t offset = 0;

if (size && !nspm->uuid) {

WARN_ON_ONCE(1);

size = 0;

}

if (size && nspm->uuid) {

struct nd_mapping *nd_mapping = &nd_region->mapping[0];

struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);

struct nd_label_id label_id;

struct resource *res;

if (!ndd) {

size = 0;

goto out;

}

nd_label_gen_id(&label_id, nspm->uuid, 0);

/* calculate a spa offset from the dpa allocation offset */

for_each_dpa_resource(ndd, res)

if (strcmp(res->name, label_id.id) == 0) {

offset = (res->start - nd_mapping->start)

* nd_region->ndr_mappings;

goto out;

}

WARN_ON_ONCE(1);

size = 0;

}

out:

res->start = nd_region->ndr_start + offset;

res->end = res->start + size - 1;

}

static bool uuid_not_set(const uuid_t *uuid, struct device *dev,

const char *where)

{

if (!uuid) {

dev_dbg(dev, "%s: uuid not set\n", where);

return true;

}

return false;

}

static ssize_t __size_store(struct device *dev, unsigned long long val)

{

resource_size_t allocated = 0, available = 0;

struct nd_region *nd_region = to_nd_region(dev->parent);

struct nd_namespace_common *ndns = to_ndns(dev);

struct nd_mapping *nd_mapping;

struct nvdimm_drvdata *ndd;

struct nd_label_id label_id;

u32 flags = 0, remainder;

int rc, i, id = -1;

uuid_t *uuid = NULL;

if (dev->driver || ndns->claim)

return -EBUSY;

if (is_namespace_pmem(dev)) {

struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev);

uuid = nspm->uuid;

id = nspm->id;

}

/*

* We need a uuid for the allocation-label and dimm(s) on which

* to store the label.

*/

if (uuid_not_set(uuid, dev, __func__))

return -ENXIO;

if (nd_region->ndr_mappings == 0) {

dev_dbg(dev, "not associated with dimm(s)\n");

return -ENXIO;

}

div_u64_rem(val, nd_region->align, &remainder);

if (remainder) {

dev_dbg(dev, "%llu is not %ldK aligned\n", val,

nd_region->align / SZ_1K);

return -EINVAL;

}

nd_label_gen_id(&label_id, uuid, flags);

for (i = 0; i < nd_region->ndr_mappings; i++) {

nd_mapping = &nd_region->mapping[i];

ndd = to_ndd(nd_mapping);

/*

* All dimms in an interleave set, need to be enabled

* for the size to be changed.

*/

if (!ndd)

return -ENXIO;

allocated += nvdimm_allocated_dpa(ndd, &label_id);

}

available = nd_region_allocatable_dpa(nd_region);

if (val > available + allocated)

return -ENOSPC;

if (val == allocated)

return 0;

val = div_u64(val, nd_region->ndr_mappings);

allocated = div_u64(allocated, nd_region->ndr_mappings);

if (val < allocated)

rc = shrink_dpa_allocation(nd_region, &label_id,

allocated - val);

else

rc = grow_dpa_allocation(nd_region, &label_id, val - allocated);

if (rc)

return rc;

if (is_namespace_pmem(dev)) {

struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev);

nd_namespace_pmem_set_resource(nd_region, nspm,

val * nd_region->ndr_mappings);

}

/*

* Try to delete the namespace if we deleted all of its

* allocation, this is not the seed or 0th device for the

* region, and it is not actively claimed by a btt, pfn, or dax

* instance.

*/

if (val == 0 && id != 0 && nd_region->ns_seed != dev && !ndns->claim)

nd_device_unregister(dev, ND_ASYNC);

return rc;

}

static ssize_t size_store(struct device *dev,

struct device_attribute *attr, const char *buf, size_t len)

{

struct nd_region *nd_region = to_nd_region(dev->parent);

unsigned long long val;

int rc;

rc = kstrtoull(buf, 0, &val);

if (rc)

return rc;

guard(device)(dev);

guard(nvdimm_bus)(dev);

wait_nvdimm_bus_probe_idle(dev);

rc = __size_store(dev, val);

if (rc >= 0)

rc = nd_namespace_label_update(nd_region, dev);

/* setting size zero == 'delete namespace' */

if (rc == 0 && val == 0 && is_namespace_pmem(dev)) {

struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev);

kfree(nspm->uuid);

nspm->uuid = NULL;

}

dev_dbg(dev, "%llx %s (%d)\n", val, rc < 0 ? "fail" : "success", rc);

return rc < 0 ? rc : len;

}

resource_size_t __nvdimm_namespace_capacity(struct nd_namespace_common *ndns)

{

struct device *dev = &ndns->dev;

if (is_namespace_pmem(dev)) {

struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev);

return resource_size(&nspm->nsio.res);

} else if (is_namespace_io(dev)) {

struct nd_namespace_io *nsio = to_nd_namespace_io(dev);

return resource_size(&nsio->res);

} else

WARN_ONCE(1, "unknown namespace type\n");

return 0;

}

resource_size_t nvdimm_namespace_capacity(struct nd_namespace_common *ndns)

{

guard(nvdimm_bus)(&ndns->dev);

return __nvdimm_namespace_capacity(ndns);

}

EXPORT_SYMBOL(nvdimm_namespace_capacity);

bool nvdimm_namespace_locked(struct nd_namespace_common *ndns)

{

int i;

bool locked = false;

struct device *dev = &ndns->dev;

struct nd_region *nd_region = to_nd_region(dev->parent);

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 (test_bit(NDD_LOCKED, &nvdimm->flags)) {

dev_dbg(dev, "%s locked\n", nvdimm_name(nvdimm));

locked = true;

}

}

return locked;

}

EXPORT_SYMBOL(nvdimm_namespace_locked);

static ssize_t size_show(struct device *dev,

struct device_attribute *attr, char *buf)

{

return sprintf(buf, "%llu\n", (unsigned long long)

nvdimm_namespace_capacity(to_ndns(dev)));

}

static DEVICE_ATTR(size, 0444, size_show, size_store);

static uuid_t *namespace_to_uuid(struct device *dev)

{

if (is_namespace_pmem(dev)) {

struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev);

return nspm->uuid;

}

return ERR_PTR(-ENXIO);

}

static ssize_t uuid_show(struct device *dev, struct device_attribute *attr,

char *buf)

{

uuid_t *uuid = namespace_to_uuid(dev);

if (IS_ERR(uuid))

return PTR_ERR(uuid);

if (uuid)

return sprintf(buf, "%pUb\n", uuid);

return sprintf(buf, "\n");

}

/**

* namespace_update_uuid - check for a unique uuid and whether we're "renaming"

* @nd_region: parent region so we can updates all dimms in the set

* @dev: namespace type for generating label_id

* @new_uuid: incoming uuid

* @old_uuid: reference to the uuid storage location in the namespace object

*

* Returns: %0 on success on -errno on error

*/

static int namespace_update_uuid(struct nd_region *nd_region,

struct device *dev, uuid_t *new_uuid,

uuid_t **old_uuid)

{

struct nd_label_id old_label_id;

struct nd_label_id new_label_id;

int i;

if (!nd_is_uuid_unique(dev, new_uuid))

return -EINVAL;

if (*old_uuid == NULL)

goto out;

/*

* If we've already written a label with this uuid, then it's

* too late to rename because we can't reliably update the uuid

* without losing the old namespace. Userspace must delete this

* namespace to abandon the old uuid.

*/

for (i = 0; i < nd_region->ndr_mappings; i++) {

struct nd_mapping *nd_mapping = &nd_region->mapping[i];

/*

* This check by itself is sufficient because old_uuid

* would be NULL above if this uuid did not exist in the

* currently written set.

*

* FIXME: can we delete uuid with zero dpa allocated?

*/

if (list_empty(&nd_mapping->labels))

return -EBUSY;

}

nd_label_gen_id(&old_label_id, *old_uuid, 0);

nd_label_gen_id(&new_label_id, new_uuid, 0);

for (i = 0; i < nd_region->ndr_mappings; i++) {

struct nd_mapping *nd_mapping = &nd_region->mapping[i];

struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);

struct nd_label_ent *label_ent;

struct resource *res;

for_each_dpa_resource(ndd, res)

if (strcmp(res->name, old_label_id.id) == 0)

sprintf((void *) res->name, "%s",

new_label_id.id);

mutex_lock(&nd_mapping->lock);