LXR linux/drivers/nvdimm/region.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
   4 */
   5#include <linux/cpumask.h>
   6#include <linux/module.h>
   7#include <linux/device.h>
   8#include <linux/nd.h>
   9#include "nd-core.h"
  10#include "nd.h"
  11
  12static int nd_region_probe(struct device *dev)
  13{
  14        int err, rc;
  15        static unsigned long once;
  16        struct nd_region_data *ndrd;
  17        struct nd_region *nd_region = to_nd_region(dev);
  18
  19        if (nd_region->num_lanes > num_online_cpus()
  20                        && nd_region->num_lanes < num_possible_cpus()
  21                        && !test_and_set_bit(0, &once)) {
  22                dev_dbg(dev, "online cpus (%d) < concurrent i/o lanes (%d) < possible cpus (%d)\n",
  23                                num_online_cpus(), nd_region->num_lanes,
  24                                num_possible_cpus());
  25                dev_dbg(dev, "setting nr_cpus=%d may yield better libnvdimm device performance\n",
  26                                nd_region->num_lanes);
  27        }
  28
  29        rc = nd_region_activate(nd_region);
  30        if (rc)
  31                return rc;
  32
  33        rc = nd_blk_region_init(nd_region);
  34        if (rc)
  35                return rc;
  36
  37        if (is_memory(&nd_region->dev)) {
  38                struct range range = {
  39                        .start = nd_region->ndr_start,
  40                        .end = nd_region->ndr_start + nd_region->ndr_size - 1,
  41                };
  42
  43                if (devm_init_badblocks(dev, &nd_region->bb))
  44                        return -ENODEV;
  45                nd_region->bb_state = sysfs_get_dirent(nd_region->dev.kobj.sd,
  46                                                       "badblocks");
  47                if (!nd_region->bb_state)
  48                        dev_warn(&nd_region->dev,
  49                                        "'badblocks' notification disabled\n");
  50                nvdimm_badblocks_populate(nd_region, &nd_region->bb, &range);
  51        }
  52
  53        rc = nd_region_register_namespaces(nd_region, &err);
  54        if (rc < 0)
  55                return rc;
  56
  57        ndrd = dev_get_drvdata(dev);
  58        ndrd->ns_active = rc;
  59        ndrd->ns_count = rc + err;
  60
  61        if (rc && err && rc == err)
  62                return -ENODEV;
  63
  64        nd_region->btt_seed = nd_btt_create(nd_region);
  65        nd_region->pfn_seed = nd_pfn_create(nd_region);
  66        nd_region->dax_seed = nd_dax_create(nd_region);
  67        if (err == 0)
  68                return 0;
  69
  70        /*
  71         * Given multiple namespaces per region, we do not want to
  72         * disable all the successfully registered peer namespaces upon
  73         * a single registration failure.  If userspace is missing a
  74         * namespace that it expects it can disable/re-enable the region
  75         * to retry discovery after correcting the failure.
  76         * <regionX>/namespaces returns the current
  77         * "<async-registered>/<total>" namespace count.
  78         */
  79        dev_err(dev, "failed to register %d namespace%s, continuing...\n",
  80                        err, err == 1 ? "" : "s");
  81        return 0;
  82}
  83
  84static int child_unregister(struct device *dev, void *data)
  85{
  86        nd_device_unregister(dev, ND_SYNC);
  87        return 0;
  88}
  89
  90static int nd_region_remove(struct device *dev)
  91{
  92        struct nd_region *nd_region = to_nd_region(dev);
  93
  94        device_for_each_child(dev, NULL, child_unregister);
  95
  96        /* flush attribute readers and disable */
  97        nvdimm_bus_lock(dev);
  98        nd_region->ns_seed = NULL;
  99        nd_region->btt_seed = NULL;
 100        nd_region->pfn_seed = NULL;
 101        nd_region->dax_seed = NULL;
 102        dev_set_drvdata(dev, NULL);
 103        nvdimm_bus_unlock(dev);
 104
 105        /*
 106         * Note, this assumes nd_device_lock() context to not race
 107         * nd_region_notify()
 108         */
 109        sysfs_put(nd_region->bb_state);
 110        nd_region->bb_state = NULL;
 111
 112        return 0;
 113}
 114
 115static int child_notify(struct device *dev, void *data)
 116{
 117        nd_device_notify(dev, *(enum nvdimm_event *) data);
 118        return 0;
 119}
 120
 121static void nd_region_notify(struct device *dev, enum nvdimm_event event)
 122{
 123        if (event == NVDIMM_REVALIDATE_POISON) {
 124                struct nd_region *nd_region = to_nd_region(dev);
 125
 126                if (is_memory(&nd_region->dev)) {
 127                        struct range range = {
 128                                .start = nd_region->ndr_start,
 129                                .end = nd_region->ndr_start +
 130                                        nd_region->ndr_size - 1,
 131                        };
 132
 133                        nvdimm_badblocks_populate(nd_region,
 134                                        &nd_region->bb, &range);
 135                        if (nd_region->bb_state)
 136                                sysfs_notify_dirent(nd_region->bb_state);
 137                }
 138        }
 139        device_for_each_child(dev, &event, child_notify);
 140}
 141
 142static struct nd_device_driver nd_region_driver = {
 143        .probe = nd_region_probe,
 144        .remove = nd_region_remove,
 145        .notify = nd_region_notify,
 146        .drv = {
 147                .name = "nd_region",
 148        },
 149        .type = ND_DRIVER_REGION_BLK | ND_DRIVER_REGION_PMEM,
 150};
 151
 152int __init nd_region_init(void)
 153{
 154        return nd_driver_register(&nd_region_driver);
 155}
 156
 157void nd_region_exit(void)
 158{
 159        driver_unregister(&nd_region_driver.drv);
 160}
 161
 162MODULE_ALIAS_ND_DEVICE(ND_DEVICE_REGION_PMEM);
 163MODULE_ALIAS_ND_DEVICE(ND_DEVICE_REGION_BLK);
 164