drivers/nvdimm/region.c

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