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_dbg(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_dbg(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); 169