| | 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 | ndr_res.start = nd_region->ndr_start; |
| | 62 | ndr_res.end = nd_region->ndr_start + nd_region->ndr_size - 1; |
| | 63 | nvdimm_badblocks_populate(nd_region, |
| | 64 | &nd_region->bb, &ndr_res); |
| | 65 | } |
| | 66 | |
| | 67 | nd_region->btt_seed = nd_btt_create(nd_region); |
| | 68 | nd_region->pfn_seed = nd_pfn_create(nd_region); |
| | 69 | nd_region->dax_seed = nd_dax_create(nd_region); |
| | 70 | if (err == 0) |
| | 71 | return 0; |
| | 72 | |
| | 73 | /* |
| | 74 | * Given multiple namespaces per region, we do not want to |
| | 75 | * disable all the successfully registered peer namespaces upon |
| | 76 | * a single registration failure. If userspace is missing a |
| | 77 | * namespace that it expects it can disable/re-enable the region |
| | 78 | * to retry discovery after correcting the failure. |
| | 79 | * <regionX>/namespaces returns the current |
| | 80 | * "<async-registered>/<total>" namespace count. |
| | 81 | */ |
| | 82 | dev_err(dev, "failed to register %d namespace%s, continuing...\n", |
| | 83 | err, err == 1 ? "" : "s"); |
| | 84 | return 0; |
| | 85 | } |
| | 86 | |
| | 87 | static int child_unregister(struct device *dev, void *data) |
| | 88 | { |
| | 89 | nd_device_unregister(dev, ND_SYNC); |
| | 90 | return 0; |
| | 91 | } |
| | 92 | |
| | 93 | static int nd_region_remove(struct device *dev) |
| | 94 | { |
| | 95 | struct nd_region *nd_region = to_nd_region(dev); |
| | 96 | |
| | 97 | device_for_each_child(dev, NULL, child_unregister); |
| | 98 | |
| | 99 | /* flush attribute readers and disable */ |
| | 100 | nvdimm_bus_lock(dev); |
| | 101 | nd_region->ns_seed = NULL; |
| | 102 | nd_region->btt_seed = NULL; |
| | 103 | nd_region->pfn_seed = NULL; |
| | 104 | nd_region->dax_seed = NULL; |
| | 105 | dev_set_drvdata(dev, NULL); |
| | 106 | nvdimm_bus_unlock(dev); |
| | 107 | |
| | 108 | return 0; |
| | 109 | } |
| | 110 | |
| | 111 | static int child_notify(struct device *dev, void *data) |
| | 112 | { |
| | 113 | nd_device_notify(dev, *(enum nvdimm_event *) data); |
| | 114 | return 0; |
| | 115 | } |
| | 116 | |
| | 117 | static void nd_region_notify(struct device *dev, enum nvdimm_event event) |
| | 118 | { |
| | 119 | if (event == NVDIMM_REVALIDATE_POISON) { |
| | 120 | struct nd_region *nd_region = to_nd_region(dev); |
| | 121 | struct resource res; |
| | 122 | |
| | 123 | if (is_nd_pmem(&nd_region->dev)) { |
| | 124 | res.start = nd_region->ndr_start; |
| | 125 | res.end = nd_region->ndr_start + |
| | 126 | nd_region->ndr_size - 1; |
| | 127 | nvdimm_badblocks_populate(nd_region, |
| | 128 | &nd_region->bb, &res); |
| | 129 | } |
| | 130 | } |
| | 131 | device_for_each_child(dev, &event, child_notify); |
| | 132 | } |
| | 133 | |
| | 134 | static struct nd_device_driver nd_region_driver = { |
| | 135 | .probe = nd_region_probe, |
| | 136 | .remove = nd_region_remove, |
| | 137 | .notify = nd_region_notify, |
| | 138 | .drv = { |
| | 139 | .name = "nd_region", |
| | 140 | }, |
| | 141 | .type = ND_DRIVER_REGION_BLK | ND_DRIVER_REGION_PMEM, |
| | 142 | }; |
| | 143 | |
| | 144 | int __init nd_region_init(void) |
| | 145 | { |
| | 146 | return nd_driver_register(&nd_region_driver); |
| | 147 | } |
| | 148 | |
| | 149 | void nd_region_exit(void) |
| | 150 | { |
| | 151 | driver_unregister(&nd_region_driver.drv); |
| | 152 | } |
| | 153 | |
| | 154 | MODULE_ALIAS_ND_DEVICE(ND_DEVICE_REGION_PMEM); |
| | 155 | MODULE_ALIAS_ND_DEVICE(ND_DEVICE_REGION_BLK); |
projects / linux-2.6-block.git / blame_incremental