Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 1 | /* |
Dan Williams | cd03412 | 2016-03-11 10:15:36 -0800 | [diff] [blame] | 2 | * Copyright(c) 2013-2016 Intel Corporation. All rights reserved. |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 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 | */ |
Dan Williams | ac515c0 | 2016-03-22 00:29:43 -0700 | [diff] [blame] | 13 | #include <linux/memremap.h> |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 14 | #include <linux/blkdev.h> |
| 15 | #include <linux/device.h> |
| 16 | #include <linux/genhd.h> |
| 17 | #include <linux/sizes.h> |
| 18 | #include <linux/slab.h> |
| 19 | #include <linux/fs.h> |
| 20 | #include <linux/mm.h> |
| 21 | #include "nd-core.h" |
| 22 | #include "pfn.h" |
| 23 | #include "nd.h" |
| 24 | |
| 25 | static void nd_pfn_release(struct device *dev) |
| 26 | { |
| 27 | struct nd_region *nd_region = to_nd_region(dev->parent); |
| 28 | struct nd_pfn *nd_pfn = to_nd_pfn(dev); |
| 29 | |
| 30 | dev_dbg(dev, "%s\n", __func__); |
| 31 | nd_detach_ndns(&nd_pfn->dev, &nd_pfn->ndns); |
| 32 | ida_simple_remove(&nd_region->pfn_ida, nd_pfn->id); |
| 33 | kfree(nd_pfn->uuid); |
| 34 | kfree(nd_pfn); |
| 35 | } |
| 36 | |
| 37 | static struct device_type nd_pfn_device_type = { |
| 38 | .name = "nd_pfn", |
| 39 | .release = nd_pfn_release, |
| 40 | }; |
| 41 | |
| 42 | bool is_nd_pfn(struct device *dev) |
| 43 | { |
| 44 | return dev ? dev->type == &nd_pfn_device_type : false; |
| 45 | } |
| 46 | EXPORT_SYMBOL(is_nd_pfn); |
| 47 | |
| 48 | struct nd_pfn *to_nd_pfn(struct device *dev) |
| 49 | { |
| 50 | struct nd_pfn *nd_pfn = container_of(dev, struct nd_pfn, dev); |
| 51 | |
| 52 | WARN_ON(!is_nd_pfn(dev)); |
| 53 | return nd_pfn; |
| 54 | } |
| 55 | EXPORT_SYMBOL(to_nd_pfn); |
| 56 | |
| 57 | static ssize_t mode_show(struct device *dev, |
| 58 | struct device_attribute *attr, char *buf) |
| 59 | { |
Dan Williams | cd03412 | 2016-03-11 10:15:36 -0800 | [diff] [blame] | 60 | struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 61 | |
| 62 | switch (nd_pfn->mode) { |
| 63 | case PFN_MODE_RAM: |
| 64 | return sprintf(buf, "ram\n"); |
| 65 | case PFN_MODE_PMEM: |
| 66 | return sprintf(buf, "pmem\n"); |
| 67 | default: |
| 68 | return sprintf(buf, "none\n"); |
| 69 | } |
| 70 | } |
| 71 | |
| 72 | static ssize_t mode_store(struct device *dev, |
| 73 | struct device_attribute *attr, const char *buf, size_t len) |
| 74 | { |
Dan Williams | cd03412 | 2016-03-11 10:15:36 -0800 | [diff] [blame] | 75 | struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 76 | ssize_t rc = 0; |
| 77 | |
| 78 | device_lock(dev); |
| 79 | nvdimm_bus_lock(dev); |
| 80 | if (dev->driver) |
| 81 | rc = -EBUSY; |
| 82 | else { |
| 83 | size_t n = len - 1; |
| 84 | |
| 85 | if (strncmp(buf, "pmem\n", n) == 0 |
| 86 | || strncmp(buf, "pmem", n) == 0) { |
Dan Williams | d2c0f04 | 2016-01-15 16:56:26 -0800 | [diff] [blame] | 87 | nd_pfn->mode = PFN_MODE_PMEM; |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 88 | } else if (strncmp(buf, "ram\n", n) == 0 |
| 89 | || strncmp(buf, "ram", n) == 0) |
| 90 | nd_pfn->mode = PFN_MODE_RAM; |
| 91 | else if (strncmp(buf, "none\n", n) == 0 |
| 92 | || strncmp(buf, "none", n) == 0) |
| 93 | nd_pfn->mode = PFN_MODE_NONE; |
| 94 | else |
| 95 | rc = -EINVAL; |
| 96 | } |
| 97 | dev_dbg(dev, "%s: result: %zd wrote: %s%s", __func__, |
| 98 | rc, buf, buf[len - 1] == '\n' ? "" : "\n"); |
| 99 | nvdimm_bus_unlock(dev); |
| 100 | device_unlock(dev); |
| 101 | |
| 102 | return rc ? rc : len; |
| 103 | } |
| 104 | static DEVICE_ATTR_RW(mode); |
| 105 | |
Dan Williams | 315c562 | 2015-12-10 14:45:23 -0800 | [diff] [blame] | 106 | static ssize_t align_show(struct device *dev, |
| 107 | struct device_attribute *attr, char *buf) |
| 108 | { |
Dan Williams | cd03412 | 2016-03-11 10:15:36 -0800 | [diff] [blame] | 109 | struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); |
Dan Williams | 315c562 | 2015-12-10 14:45:23 -0800 | [diff] [blame] | 110 | |
Dan Williams | 630a2ef | 2016-12-10 08:12:05 -0800 | [diff] [blame] | 111 | return sprintf(buf, "%ld\n", nd_pfn->align); |
Dan Williams | 315c562 | 2015-12-10 14:45:23 -0800 | [diff] [blame] | 112 | } |
| 113 | |
| 114 | static ssize_t __align_store(struct nd_pfn *nd_pfn, const char *buf) |
| 115 | { |
| 116 | unsigned long val; |
| 117 | int rc; |
| 118 | |
| 119 | rc = kstrtoul(buf, 0, &val); |
| 120 | if (rc) |
| 121 | return rc; |
| 122 | |
| 123 | if (!is_power_of_2(val) || val < PAGE_SIZE || val > SZ_1G) |
| 124 | return -EINVAL; |
| 125 | |
| 126 | if (nd_pfn->dev.driver) |
| 127 | return -EBUSY; |
| 128 | else |
| 129 | nd_pfn->align = val; |
| 130 | |
| 131 | return 0; |
| 132 | } |
| 133 | |
| 134 | static ssize_t align_store(struct device *dev, |
| 135 | struct device_attribute *attr, const char *buf, size_t len) |
| 136 | { |
Dan Williams | cd03412 | 2016-03-11 10:15:36 -0800 | [diff] [blame] | 137 | struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); |
Dan Williams | 315c562 | 2015-12-10 14:45:23 -0800 | [diff] [blame] | 138 | ssize_t rc; |
| 139 | |
| 140 | device_lock(dev); |
| 141 | nvdimm_bus_lock(dev); |
| 142 | rc = __align_store(nd_pfn, buf); |
| 143 | dev_dbg(dev, "%s: result: %zd wrote: %s%s", __func__, |
| 144 | rc, buf, buf[len - 1] == '\n' ? "" : "\n"); |
| 145 | nvdimm_bus_unlock(dev); |
| 146 | device_unlock(dev); |
| 147 | |
| 148 | return rc ? rc : len; |
| 149 | } |
| 150 | static DEVICE_ATTR_RW(align); |
| 151 | |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 152 | static ssize_t uuid_show(struct device *dev, |
| 153 | struct device_attribute *attr, char *buf) |
| 154 | { |
Dan Williams | cd03412 | 2016-03-11 10:15:36 -0800 | [diff] [blame] | 155 | struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 156 | |
| 157 | if (nd_pfn->uuid) |
| 158 | return sprintf(buf, "%pUb\n", nd_pfn->uuid); |
| 159 | return sprintf(buf, "\n"); |
| 160 | } |
| 161 | |
| 162 | static ssize_t uuid_store(struct device *dev, |
| 163 | struct device_attribute *attr, const char *buf, size_t len) |
| 164 | { |
Dan Williams | cd03412 | 2016-03-11 10:15:36 -0800 | [diff] [blame] | 165 | struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 166 | ssize_t rc; |
| 167 | |
| 168 | device_lock(dev); |
| 169 | rc = nd_uuid_store(dev, &nd_pfn->uuid, buf, len); |
| 170 | dev_dbg(dev, "%s: result: %zd wrote: %s%s", __func__, |
| 171 | rc, buf, buf[len - 1] == '\n' ? "" : "\n"); |
| 172 | device_unlock(dev); |
| 173 | |
| 174 | return rc ? rc : len; |
| 175 | } |
| 176 | static DEVICE_ATTR_RW(uuid); |
| 177 | |
| 178 | static ssize_t namespace_show(struct device *dev, |
| 179 | struct device_attribute *attr, char *buf) |
| 180 | { |
Dan Williams | cd03412 | 2016-03-11 10:15:36 -0800 | [diff] [blame] | 181 | struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 182 | ssize_t rc; |
| 183 | |
| 184 | nvdimm_bus_lock(dev); |
| 185 | rc = sprintf(buf, "%s\n", nd_pfn->ndns |
| 186 | ? dev_name(&nd_pfn->ndns->dev) : ""); |
| 187 | nvdimm_bus_unlock(dev); |
| 188 | return rc; |
| 189 | } |
| 190 | |
| 191 | static ssize_t namespace_store(struct device *dev, |
| 192 | struct device_attribute *attr, const char *buf, size_t len) |
| 193 | { |
Dan Williams | cd03412 | 2016-03-11 10:15:36 -0800 | [diff] [blame] | 194 | struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 195 | ssize_t rc; |
| 196 | |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 197 | device_lock(dev); |
Axel Lin | 4ca8b57a | 2015-09-16 21:25:38 +0800 | [diff] [blame] | 198 | nvdimm_bus_lock(dev); |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 199 | rc = nd_namespace_store(dev, &nd_pfn->ndns, buf, len); |
| 200 | dev_dbg(dev, "%s: result: %zd wrote: %s%s", __func__, |
| 201 | rc, buf, buf[len - 1] == '\n' ? "" : "\n"); |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 202 | nvdimm_bus_unlock(dev); |
Axel Lin | 4ca8b57a | 2015-09-16 21:25:38 +0800 | [diff] [blame] | 203 | device_unlock(dev); |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 204 | |
| 205 | return rc; |
| 206 | } |
| 207 | static DEVICE_ATTR_RW(namespace); |
| 208 | |
Dan Williams | f6ed58c | 2016-03-03 09:46:04 -0800 | [diff] [blame] | 209 | static ssize_t resource_show(struct device *dev, |
| 210 | struct device_attribute *attr, char *buf) |
| 211 | { |
Dan Williams | cd03412 | 2016-03-11 10:15:36 -0800 | [diff] [blame] | 212 | struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); |
Dan Williams | f6ed58c | 2016-03-03 09:46:04 -0800 | [diff] [blame] | 213 | ssize_t rc; |
| 214 | |
| 215 | device_lock(dev); |
| 216 | if (dev->driver) { |
| 217 | struct nd_pfn_sb *pfn_sb = nd_pfn->pfn_sb; |
| 218 | u64 offset = __le64_to_cpu(pfn_sb->dataoff); |
| 219 | struct nd_namespace_common *ndns = nd_pfn->ndns; |
| 220 | u32 start_pad = __le32_to_cpu(pfn_sb->start_pad); |
| 221 | struct nd_namespace_io *nsio = to_nd_namespace_io(&ndns->dev); |
| 222 | |
| 223 | rc = sprintf(buf, "%#llx\n", (unsigned long long) nsio->res.start |
| 224 | + start_pad + offset); |
| 225 | } else { |
| 226 | /* no address to convey if the pfn instance is disabled */ |
| 227 | rc = -ENXIO; |
| 228 | } |
| 229 | device_unlock(dev); |
| 230 | |
| 231 | return rc; |
| 232 | } |
| 233 | static DEVICE_ATTR_RO(resource); |
| 234 | |
| 235 | static ssize_t size_show(struct device *dev, |
| 236 | struct device_attribute *attr, char *buf) |
| 237 | { |
Dan Williams | cd03412 | 2016-03-11 10:15:36 -0800 | [diff] [blame] | 238 | struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); |
Dan Williams | f6ed58c | 2016-03-03 09:46:04 -0800 | [diff] [blame] | 239 | ssize_t rc; |
| 240 | |
| 241 | device_lock(dev); |
| 242 | if (dev->driver) { |
| 243 | struct nd_pfn_sb *pfn_sb = nd_pfn->pfn_sb; |
| 244 | u64 offset = __le64_to_cpu(pfn_sb->dataoff); |
| 245 | struct nd_namespace_common *ndns = nd_pfn->ndns; |
| 246 | u32 start_pad = __le32_to_cpu(pfn_sb->start_pad); |
| 247 | u32 end_trunc = __le32_to_cpu(pfn_sb->end_trunc); |
| 248 | struct nd_namespace_io *nsio = to_nd_namespace_io(&ndns->dev); |
| 249 | |
| 250 | rc = sprintf(buf, "%llu\n", (unsigned long long) |
| 251 | resource_size(&nsio->res) - start_pad |
| 252 | - end_trunc - offset); |
| 253 | } else { |
| 254 | /* no size to convey if the pfn instance is disabled */ |
| 255 | rc = -ENXIO; |
| 256 | } |
| 257 | device_unlock(dev); |
| 258 | |
| 259 | return rc; |
| 260 | } |
| 261 | static DEVICE_ATTR_RO(size); |
| 262 | |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 263 | static struct attribute *nd_pfn_attributes[] = { |
| 264 | &dev_attr_mode.attr, |
| 265 | &dev_attr_namespace.attr, |
| 266 | &dev_attr_uuid.attr, |
Dan Williams | 315c562 | 2015-12-10 14:45:23 -0800 | [diff] [blame] | 267 | &dev_attr_align.attr, |
Dan Williams | f6ed58c | 2016-03-03 09:46:04 -0800 | [diff] [blame] | 268 | &dev_attr_resource.attr, |
| 269 | &dev_attr_size.attr, |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 270 | NULL, |
| 271 | }; |
| 272 | |
Dan Williams | 2224973 | 2017-09-26 13:07:06 -0700 | [diff] [blame] | 273 | static umode_t pfn_visible(struct kobject *kobj, struct attribute *a, int n) |
| 274 | { |
| 275 | if (a == &dev_attr_resource.attr) |
| 276 | return 0400; |
| 277 | return a->mode; |
| 278 | } |
| 279 | |
Dan Williams | cd03412 | 2016-03-11 10:15:36 -0800 | [diff] [blame] | 280 | struct attribute_group nd_pfn_attribute_group = { |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 281 | .attrs = nd_pfn_attributes, |
Dan Williams | 2224973 | 2017-09-26 13:07:06 -0700 | [diff] [blame] | 282 | .is_visible = pfn_visible, |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 283 | }; |
| 284 | |
| 285 | static const struct attribute_group *nd_pfn_attribute_groups[] = { |
| 286 | &nd_pfn_attribute_group, |
| 287 | &nd_device_attribute_group, |
| 288 | &nd_numa_attribute_group, |
| 289 | NULL, |
| 290 | }; |
| 291 | |
Dan Williams | cd03412 | 2016-03-11 10:15:36 -0800 | [diff] [blame] | 292 | struct device *nd_pfn_devinit(struct nd_pfn *nd_pfn, |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 293 | struct nd_namespace_common *ndns) |
| 294 | { |
Dan Williams | cd03412 | 2016-03-11 10:15:36 -0800 | [diff] [blame] | 295 | struct device *dev = &nd_pfn->dev; |
| 296 | |
| 297 | if (!nd_pfn) |
| 298 | return NULL; |
| 299 | |
| 300 | nd_pfn->mode = PFN_MODE_NONE; |
| 301 | nd_pfn->align = HPAGE_SIZE; |
| 302 | dev = &nd_pfn->dev; |
| 303 | device_initialize(&nd_pfn->dev); |
| 304 | if (ndns && !__nd_attach_ndns(&nd_pfn->dev, ndns, &nd_pfn->ndns)) { |
| 305 | dev_dbg(&ndns->dev, "%s failed, already claimed by %s\n", |
| 306 | __func__, dev_name(ndns->claim)); |
| 307 | put_device(dev); |
| 308 | return NULL; |
| 309 | } |
| 310 | return dev; |
| 311 | } |
| 312 | |
| 313 | static struct nd_pfn *nd_pfn_alloc(struct nd_region *nd_region) |
| 314 | { |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 315 | struct nd_pfn *nd_pfn; |
| 316 | struct device *dev; |
| 317 | |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 318 | nd_pfn = kzalloc(sizeof(*nd_pfn), GFP_KERNEL); |
| 319 | if (!nd_pfn) |
| 320 | return NULL; |
| 321 | |
| 322 | nd_pfn->id = ida_simple_get(&nd_region->pfn_ida, 0, 0, GFP_KERNEL); |
| 323 | if (nd_pfn->id < 0) { |
| 324 | kfree(nd_pfn); |
| 325 | return NULL; |
| 326 | } |
| 327 | |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 328 | dev = &nd_pfn->dev; |
| 329 | dev_set_name(dev, "pfn%d.%d", nd_region->id, nd_pfn->id); |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 330 | dev->groups = nd_pfn_attribute_groups; |
Dan Williams | cd03412 | 2016-03-11 10:15:36 -0800 | [diff] [blame] | 331 | dev->type = &nd_pfn_device_type; |
| 332 | dev->parent = &nd_region->dev; |
| 333 | |
| 334 | return nd_pfn; |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 335 | } |
| 336 | |
| 337 | struct device *nd_pfn_create(struct nd_region *nd_region) |
| 338 | { |
Dan Williams | cd03412 | 2016-03-11 10:15:36 -0800 | [diff] [blame] | 339 | struct nd_pfn *nd_pfn; |
| 340 | struct device *dev; |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 341 | |
Dan Williams | cd03412 | 2016-03-11 10:15:36 -0800 | [diff] [blame] | 342 | if (!is_nd_pmem(&nd_region->dev)) |
| 343 | return NULL; |
| 344 | |
| 345 | nd_pfn = nd_pfn_alloc(nd_region); |
| 346 | dev = nd_pfn_devinit(nd_pfn, NULL); |
| 347 | |
| 348 | __nd_device_register(dev); |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 349 | return dev; |
| 350 | } |
| 351 | |
Dan Williams | 7839be2 | 2019-07-18 15:58:36 -0700 | [diff] [blame] | 352 | /** |
| 353 | * nd_pfn_validate - read and validate info-block |
| 354 | * @nd_pfn: fsdax namespace runtime state / properties |
| 355 | * @sig: 'devdax' or 'fsdax' signature |
| 356 | * |
| 357 | * Upon return the info-block buffer contents (->pfn_sb) are |
| 358 | * indeterminate when validation fails, and a coherent info-block |
| 359 | * otherwise. |
| 360 | */ |
Dan Williams | c5ed926 | 2016-05-18 14:50:12 -0700 | [diff] [blame] | 361 | int nd_pfn_validate(struct nd_pfn *nd_pfn, const char *sig) |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 362 | { |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 363 | u64 checksum, offset; |
Dan Williams | 1ee6667 | 2016-06-23 17:50:39 -0700 | [diff] [blame] | 364 | enum nd_pfn_mode mode; |
Dan Williams | a34d5e8 | 2015-12-12 16:09:14 -0800 | [diff] [blame] | 365 | struct nd_namespace_io *nsio; |
Dan Williams | 423716c | 2017-12-19 15:07:10 -0800 | [diff] [blame] | 366 | unsigned long align, start_pad; |
Dan Williams | a34d5e8 | 2015-12-12 16:09:14 -0800 | [diff] [blame] | 367 | struct nd_pfn_sb *pfn_sb = nd_pfn->pfn_sb; |
| 368 | struct nd_namespace_common *ndns = nd_pfn->ndns; |
| 369 | const u8 *parent_uuid = nd_dev_to_uuid(&ndns->dev); |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 370 | |
| 371 | if (!pfn_sb || !ndns) |
| 372 | return -ENODEV; |
| 373 | |
| 374 | if (!is_nd_pmem(nd_pfn->dev.parent)) |
| 375 | return -ENODEV; |
| 376 | |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 377 | if (nvdimm_read_bytes(ndns, SZ_4K, pfn_sb, sizeof(*pfn_sb))) |
| 378 | return -ENXIO; |
| 379 | |
Dan Williams | c5ed926 | 2016-05-18 14:50:12 -0700 | [diff] [blame] | 380 | if (memcmp(pfn_sb->signature, sig, PFN_SIG_LEN) != 0) |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 381 | return -ENODEV; |
| 382 | |
| 383 | checksum = le64_to_cpu(pfn_sb->checksum); |
| 384 | pfn_sb->checksum = 0; |
| 385 | if (checksum != nd_sb_checksum((struct nd_gen_sb *) pfn_sb)) |
| 386 | return -ENODEV; |
| 387 | pfn_sb->checksum = cpu_to_le64(checksum); |
| 388 | |
Dan Williams | a34d5e8 | 2015-12-12 16:09:14 -0800 | [diff] [blame] | 389 | if (memcmp(pfn_sb->parent_uuid, parent_uuid, 16) != 0) |
| 390 | return -ENODEV; |
| 391 | |
Dan Williams | cfe30b8 | 2016-03-03 09:38:00 -0800 | [diff] [blame] | 392 | if (__le16_to_cpu(pfn_sb->version_minor) < 1) { |
| 393 | pfn_sb->start_pad = 0; |
| 394 | pfn_sb->end_trunc = 0; |
| 395 | } |
| 396 | |
Dan Williams | 45a0dac | 2016-03-31 15:41:18 -0700 | [diff] [blame] | 397 | if (__le16_to_cpu(pfn_sb->version_minor) < 2) |
| 398 | pfn_sb->align = 0; |
| 399 | |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 400 | switch (le32_to_cpu(pfn_sb->mode)) { |
| 401 | case PFN_MODE_RAM: |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 402 | case PFN_MODE_PMEM: |
Dan Williams | 45eb570 | 2016-01-29 17:42:51 -0800 | [diff] [blame] | 403 | break; |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 404 | default: |
| 405 | return -ENXIO; |
| 406 | } |
| 407 | |
Dan Williams | 1ee6667 | 2016-06-23 17:50:39 -0700 | [diff] [blame] | 408 | align = le32_to_cpu(pfn_sb->align); |
| 409 | offset = le64_to_cpu(pfn_sb->dataoff); |
Dan Williams | 423716c | 2017-12-19 15:07:10 -0800 | [diff] [blame] | 410 | start_pad = le32_to_cpu(pfn_sb->start_pad); |
Dan Williams | 1ee6667 | 2016-06-23 17:50:39 -0700 | [diff] [blame] | 411 | if (align == 0) |
| 412 | align = 1UL << ilog2(offset); |
| 413 | mode = le32_to_cpu(pfn_sb->mode); |
| 414 | |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 415 | if (!nd_pfn->uuid) { |
Dan Williams | 1ee6667 | 2016-06-23 17:50:39 -0700 | [diff] [blame] | 416 | /* |
| 417 | * When probing a namepace via nd_pfn_probe() the uuid |
| 418 | * is NULL (see: nd_pfn_devinit()) we init settings from |
| 419 | * pfn_sb |
| 420 | */ |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 421 | nd_pfn->uuid = kmemdup(pfn_sb->uuid, 16, GFP_KERNEL); |
| 422 | if (!nd_pfn->uuid) |
| 423 | return -ENOMEM; |
Dan Williams | 1ee6667 | 2016-06-23 17:50:39 -0700 | [diff] [blame] | 424 | nd_pfn->align = align; |
| 425 | nd_pfn->mode = mode; |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 426 | } else { |
Dan Williams | 1ee6667 | 2016-06-23 17:50:39 -0700 | [diff] [blame] | 427 | /* |
| 428 | * When probing a pfn / dax instance we validate the |
| 429 | * live settings against the pfn_sb |
| 430 | */ |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 431 | if (memcmp(nd_pfn->uuid, pfn_sb->uuid, 16) != 0) |
Dan Williams | e567056 | 2016-04-07 19:59:27 -0700 | [diff] [blame] | 432 | return -ENODEV; |
Dan Williams | 1ee6667 | 2016-06-23 17:50:39 -0700 | [diff] [blame] | 433 | |
| 434 | /* |
| 435 | * If the uuid validates, but other settings mismatch |
| 436 | * return EINVAL because userspace has managed to change |
| 437 | * the configuration without specifying new |
| 438 | * identification. |
| 439 | */ |
| 440 | if (nd_pfn->align != align || nd_pfn->mode != mode) { |
| 441 | dev_err(&nd_pfn->dev, |
| 442 | "init failed, settings mismatch\n"); |
| 443 | dev_dbg(&nd_pfn->dev, "align: %lx:%lx mode: %d:%d\n", |
| 444 | nd_pfn->align, align, nd_pfn->mode, |
| 445 | mode); |
| 446 | return -EINVAL; |
| 447 | } |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 448 | } |
| 449 | |
Dan Williams | 1ee6667 | 2016-06-23 17:50:39 -0700 | [diff] [blame] | 450 | if (align > nvdimm_namespace_capacity(ndns)) { |
Dan Williams | 315c562 | 2015-12-10 14:45:23 -0800 | [diff] [blame] | 451 | dev_err(&nd_pfn->dev, "alignment: %lx exceeds capacity %llx\n", |
Dan Williams | 1ee6667 | 2016-06-23 17:50:39 -0700 | [diff] [blame] | 452 | align, nvdimm_namespace_capacity(ndns)); |
Dan Williams | 315c562 | 2015-12-10 14:45:23 -0800 | [diff] [blame] | 453 | return -EINVAL; |
| 454 | } |
| 455 | |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 456 | /* |
| 457 | * These warnings are verbose because they can only trigger in |
| 458 | * the case where the physical address alignment of the |
| 459 | * namespace has changed since the pfn superblock was |
| 460 | * established. |
| 461 | */ |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 462 | nsio = to_nd_namespace_io(&ndns->dev); |
Dan Williams | 9f1e8ce | 2015-12-10 15:14:20 -0800 | [diff] [blame] | 463 | if (offset >= resource_size(&nsio->res)) { |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 464 | dev_err(&nd_pfn->dev, "pfn array size exceeds capacity of %s\n", |
| 465 | dev_name(&ndns->dev)); |
| 466 | return -EBUSY; |
| 467 | } |
| 468 | |
Dan Williams | 423716c | 2017-12-19 15:07:10 -0800 | [diff] [blame] | 469 | if ((align && !IS_ALIGNED(nsio->res.start + offset + start_pad, align)) |
Dan Williams | 5e24c9f | 2016-05-21 11:01:41 -0700 | [diff] [blame] | 470 | || !IS_ALIGNED(offset, PAGE_SIZE)) { |
Dan Williams | 1ee6667 | 2016-06-23 17:50:39 -0700 | [diff] [blame] | 471 | dev_err(&nd_pfn->dev, |
| 472 | "bad offset: %#llx dax disabled align: %#lx\n", |
| 473 | offset, align); |
Dan Williams | 315c562 | 2015-12-10 14:45:23 -0800 | [diff] [blame] | 474 | return -ENXIO; |
| 475 | } |
| 476 | |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 477 | return 0; |
| 478 | } |
Dan Williams | 32ab0a3f | 2015-08-01 02:16:37 -0400 | [diff] [blame] | 479 | EXPORT_SYMBOL(nd_pfn_validate); |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 480 | |
Dan Williams | 200c79d | 2016-03-22 00:22:16 -0700 | [diff] [blame] | 481 | int nd_pfn_probe(struct device *dev, struct nd_namespace_common *ndns) |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 482 | { |
| 483 | int rc; |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 484 | struct nd_pfn *nd_pfn; |
Dan Williams | bd03294 | 2016-03-17 18:16:15 -0700 | [diff] [blame] | 485 | struct device *pfn_dev; |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 486 | struct nd_pfn_sb *pfn_sb; |
| 487 | struct nd_region *nd_region = to_nd_region(ndns->dev.parent); |
| 488 | |
| 489 | if (ndns->force_raw) |
| 490 | return -ENODEV; |
| 491 | |
| 492 | nvdimm_bus_lock(&ndns->dev); |
Dan Williams | cd03412 | 2016-03-11 10:15:36 -0800 | [diff] [blame] | 493 | nd_pfn = nd_pfn_alloc(nd_region); |
| 494 | pfn_dev = nd_pfn_devinit(nd_pfn, ndns); |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 495 | nvdimm_bus_unlock(&ndns->dev); |
Dan Williams | bd03294 | 2016-03-17 18:16:15 -0700 | [diff] [blame] | 496 | if (!pfn_dev) |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 497 | return -ENOMEM; |
Dan Williams | 7839be2 | 2019-07-18 15:58:36 -0700 | [diff] [blame] | 498 | pfn_sb = devm_kmalloc(dev, sizeof(*pfn_sb), GFP_KERNEL); |
Dan Williams | bd03294 | 2016-03-17 18:16:15 -0700 | [diff] [blame] | 499 | nd_pfn = to_nd_pfn(pfn_dev); |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 500 | nd_pfn->pfn_sb = pfn_sb; |
Dan Williams | c5ed926 | 2016-05-18 14:50:12 -0700 | [diff] [blame] | 501 | rc = nd_pfn_validate(nd_pfn, PFN_SIG); |
Dan Williams | bd03294 | 2016-03-17 18:16:15 -0700 | [diff] [blame] | 502 | dev_dbg(dev, "%s: pfn: %s\n", __func__, |
| 503 | rc == 0 ? dev_name(pfn_dev) : "<none>"); |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 504 | if (rc < 0) { |
Dan Williams | bd03294 | 2016-03-17 18:16:15 -0700 | [diff] [blame] | 505 | __nd_detach_ndns(pfn_dev, &nd_pfn->ndns); |
| 506 | put_device(pfn_dev); |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 507 | } else |
Dan Williams | bd03294 | 2016-03-17 18:16:15 -0700 | [diff] [blame] | 508 | __nd_device_register(pfn_dev); |
Dan Williams | e145574 | 2015-07-30 17:57:47 -0400 | [diff] [blame] | 509 | |
| 510 | return rc; |
| 511 | } |
| 512 | EXPORT_SYMBOL(nd_pfn_probe); |
Dan Williams | ac515c0 | 2016-03-22 00:29:43 -0700 | [diff] [blame] | 513 | |
| 514 | /* |
| 515 | * We hotplug memory at section granularity, pad the reserved area from |
| 516 | * the previous section base to the namespace base address. |
| 517 | */ |
| 518 | static unsigned long init_altmap_base(resource_size_t base) |
| 519 | { |
| 520 | unsigned long base_pfn = PHYS_PFN(base); |
| 521 | |
| 522 | return PFN_SECTION_ALIGN_DOWN(base_pfn); |
| 523 | } |
| 524 | |
| 525 | static unsigned long init_altmap_reserve(resource_size_t base) |
| 526 | { |
Oliver O'Halloran | f45c6c3 | 2019-02-06 13:04:53 +1100 | [diff] [blame] | 527 | unsigned long reserve = PFN_UP(SZ_8K); |
Dan Williams | ac515c0 | 2016-03-22 00:29:43 -0700 | [diff] [blame] | 528 | unsigned long base_pfn = PHYS_PFN(base); |
| 529 | |
| 530 | reserve += base_pfn - PFN_SECTION_ALIGN_DOWN(base_pfn); |
| 531 | return reserve; |
| 532 | } |
| 533 | |
| 534 | static struct vmem_altmap *__nvdimm_setup_pfn(struct nd_pfn *nd_pfn, |
| 535 | struct resource *res, struct vmem_altmap *altmap) |
| 536 | { |
| 537 | struct nd_pfn_sb *pfn_sb = nd_pfn->pfn_sb; |
| 538 | u64 offset = le64_to_cpu(pfn_sb->dataoff); |
| 539 | u32 start_pad = __le32_to_cpu(pfn_sb->start_pad); |
| 540 | u32 end_trunc = __le32_to_cpu(pfn_sb->end_trunc); |
| 541 | struct nd_namespace_common *ndns = nd_pfn->ndns; |
| 542 | struct nd_namespace_io *nsio = to_nd_namespace_io(&ndns->dev); |
| 543 | resource_size_t base = nsio->res.start + start_pad; |
| 544 | struct vmem_altmap __altmap = { |
| 545 | .base_pfn = init_altmap_base(base), |
| 546 | .reserve = init_altmap_reserve(base), |
| 547 | }; |
| 548 | |
| 549 | memcpy(res, &nsio->res, sizeof(*res)); |
| 550 | res->start += start_pad; |
| 551 | res->end -= end_trunc; |
| 552 | |
Dan Williams | ac515c0 | 2016-03-22 00:29:43 -0700 | [diff] [blame] | 553 | if (nd_pfn->mode == PFN_MODE_RAM) { |
| 554 | if (offset < SZ_8K) |
| 555 | return ERR_PTR(-EINVAL); |
| 556 | nd_pfn->npfns = le64_to_cpu(pfn_sb->npfns); |
| 557 | altmap = NULL; |
| 558 | } else if (nd_pfn->mode == PFN_MODE_PMEM) { |
Dan Williams | 1a10295 | 2017-05-04 19:54:42 -0700 | [diff] [blame] | 559 | nd_pfn->npfns = PFN_SECTION_ALIGN_UP((resource_size(res) |
| 560 | - offset) / PAGE_SIZE); |
Dan Williams | ac515c0 | 2016-03-22 00:29:43 -0700 | [diff] [blame] | 561 | if (le64_to_cpu(nd_pfn->pfn_sb->npfns) > nd_pfn->npfns) |
| 562 | dev_info(&nd_pfn->dev, |
| 563 | "number of pfns truncated from %lld to %ld\n", |
| 564 | le64_to_cpu(nd_pfn->pfn_sb->npfns), |
| 565 | nd_pfn->npfns); |
| 566 | memcpy(altmap, &__altmap, sizeof(*altmap)); |
| 567 | altmap->free = PHYS_PFN(offset - SZ_8K); |
| 568 | altmap->alloc = 0; |
| 569 | } else |
| 570 | return ERR_PTR(-ENXIO); |
| 571 | |
| 572 | return altmap; |
| 573 | } |
| 574 | |
Dan Williams | 807e336 | 2018-02-23 14:06:05 -0800 | [diff] [blame] | 575 | static u64 phys_pmem_align_down(struct nd_pfn *nd_pfn, u64 phys) |
| 576 | { |
| 577 | return min_t(u64, PHYS_SECTION_ALIGN_DOWN(phys), |
| 578 | ALIGN_DOWN(phys, nd_pfn->align)); |
| 579 | } |
| 580 | |
Dan Williams | ac515c0 | 2016-03-22 00:29:43 -0700 | [diff] [blame] | 581 | static int nd_pfn_init(struct nd_pfn *nd_pfn) |
| 582 | { |
Dan Williams | 52ac23b | 2016-03-31 09:37:11 -0700 | [diff] [blame] | 583 | u32 dax_label_reserve = is_nd_dax(&nd_pfn->dev) ? SZ_128K : 0; |
Dan Williams | ac515c0 | 2016-03-22 00:29:43 -0700 | [diff] [blame] | 584 | struct nd_namespace_common *ndns = nd_pfn->ndns; |
| 585 | u32 start_pad = 0, end_trunc = 0; |
| 586 | resource_size_t start, size; |
| 587 | struct nd_namespace_io *nsio; |
| 588 | struct nd_region *nd_region; |
| 589 | struct nd_pfn_sb *pfn_sb; |
| 590 | unsigned long npfns; |
| 591 | phys_addr_t offset; |
Dan Williams | c5ed926 | 2016-05-18 14:50:12 -0700 | [diff] [blame] | 592 | const char *sig; |
Dan Williams | ac515c0 | 2016-03-22 00:29:43 -0700 | [diff] [blame] | 593 | u64 checksum; |
| 594 | int rc; |
| 595 | |
Dan Williams | 7839be2 | 2019-07-18 15:58:36 -0700 | [diff] [blame] | 596 | pfn_sb = devm_kmalloc(&nd_pfn->dev, sizeof(*pfn_sb), GFP_KERNEL); |
Dan Williams | ac515c0 | 2016-03-22 00:29:43 -0700 | [diff] [blame] | 597 | if (!pfn_sb) |
| 598 | return -ENOMEM; |
| 599 | |
| 600 | nd_pfn->pfn_sb = pfn_sb; |
Dan Williams | c5ed926 | 2016-05-18 14:50:12 -0700 | [diff] [blame] | 601 | if (is_nd_dax(&nd_pfn->dev)) |
| 602 | sig = DAX_SIG; |
| 603 | else |
| 604 | sig = PFN_SIG; |
Dan Williams | 7839be2 | 2019-07-18 15:58:36 -0700 | [diff] [blame] | 605 | |
Dan Williams | c5ed926 | 2016-05-18 14:50:12 -0700 | [diff] [blame] | 606 | rc = nd_pfn_validate(nd_pfn, sig); |
Dan Williams | ac515c0 | 2016-03-22 00:29:43 -0700 | [diff] [blame] | 607 | if (rc != -ENODEV) |
| 608 | return rc; |
| 609 | |
| 610 | /* no info block, do init */; |
Dan Williams | 7839be2 | 2019-07-18 15:58:36 -0700 | [diff] [blame] | 611 | memset(pfn_sb, 0, sizeof(*pfn_sb)); |
| 612 | |
Dan Williams | ac515c0 | 2016-03-22 00:29:43 -0700 | [diff] [blame] | 613 | nd_region = to_nd_region(nd_pfn->dev.parent); |
| 614 | if (nd_region->ro) { |
| 615 | dev_info(&nd_pfn->dev, |
| 616 | "%s is read-only, unable to init metadata\n", |
| 617 | dev_name(&nd_region->dev)); |
| 618 | return -ENXIO; |
| 619 | } |
| 620 | |
| 621 | memset(pfn_sb, 0, sizeof(*pfn_sb)); |
| 622 | |
| 623 | /* |
| 624 | * Check if pmem collides with 'System RAM' when section aligned and |
| 625 | * trim it accordingly |
| 626 | */ |
| 627 | nsio = to_nd_namespace_io(&ndns->dev); |
| 628 | start = PHYS_SECTION_ALIGN_DOWN(nsio->res.start); |
| 629 | size = resource_size(&nsio->res); |
| 630 | if (region_intersects(start, size, IORESOURCE_SYSTEM_RAM, |
| 631 | IORES_DESC_NONE) == REGION_MIXED) { |
| 632 | start = nsio->res.start; |
| 633 | start_pad = PHYS_SECTION_ALIGN_UP(start) - start; |
| 634 | } |
| 635 | |
| 636 | start = nsio->res.start; |
| 637 | size = PHYS_SECTION_ALIGN_UP(start + size) - start; |
| 638 | if (region_intersects(start, size, IORESOURCE_SYSTEM_RAM, |
Dan Williams | 807e336 | 2018-02-23 14:06:05 -0800 | [diff] [blame] | 639 | IORES_DESC_NONE) == REGION_MIXED |
| 640 | || !IS_ALIGNED(start + resource_size(&nsio->res), |
| 641 | nd_pfn->align)) { |
Dan Williams | ac515c0 | 2016-03-22 00:29:43 -0700 | [diff] [blame] | 642 | size = resource_size(&nsio->res); |
Dan Williams | 807e336 | 2018-02-23 14:06:05 -0800 | [diff] [blame] | 643 | end_trunc = start + size - phys_pmem_align_down(nd_pfn, |
| 644 | start + size); |
Dan Williams | ac515c0 | 2016-03-22 00:29:43 -0700 | [diff] [blame] | 645 | } |
| 646 | |
| 647 | if (start_pad + end_trunc) |
Dan Williams | 807e336 | 2018-02-23 14:06:05 -0800 | [diff] [blame] | 648 | dev_info(&nd_pfn->dev, "%s alignment collision, truncate %d bytes\n", |
Dan Williams | ac515c0 | 2016-03-22 00:29:43 -0700 | [diff] [blame] | 649 | dev_name(&ndns->dev), start_pad + end_trunc); |
| 650 | |
| 651 | /* |
| 652 | * Note, we use 64 here for the standard size of struct page, |
| 653 | * debugging options may cause it to be larger in which case the |
| 654 | * implementation will limit the pfns advertised through |
| 655 | * ->direct_access() to those that are included in the memmap. |
| 656 | */ |
| 657 | start += start_pad; |
| 658 | size = resource_size(&nsio->res); |
Dan Williams | 1a10295 | 2017-05-04 19:54:42 -0700 | [diff] [blame] | 659 | npfns = PFN_SECTION_ALIGN_UP((size - start_pad - end_trunc - SZ_8K) |
| 660 | / PAGE_SIZE); |
Dan Williams | 594d6d9 | 2016-05-18 09:59:34 -0700 | [diff] [blame] | 661 | if (nd_pfn->mode == PFN_MODE_PMEM) { |
Dan Williams | 594d6d9 | 2016-05-18 09:59:34 -0700 | [diff] [blame] | 662 | /* |
| 663 | * vmemmap_populate_hugepages() allocates the memmap array in |
| 664 | * HPAGE_SIZE chunks. |
| 665 | */ |
Dan Williams | cd75567 | 2017-02-04 14:47:31 -0800 | [diff] [blame] | 666 | offset = ALIGN(start + SZ_8K + 64 * npfns + dax_label_reserve, |
| 667 | max(nd_pfn->align, HPAGE_SIZE)) - start; |
Dan Williams | 594d6d9 | 2016-05-18 09:59:34 -0700 | [diff] [blame] | 668 | } else if (nd_pfn->mode == PFN_MODE_RAM) |
Dan Williams | 52ac23b | 2016-03-31 09:37:11 -0700 | [diff] [blame] | 669 | offset = ALIGN(start + SZ_8K + dax_label_reserve, |
| 670 | nd_pfn->align) - start; |
Dan Williams | ac515c0 | 2016-03-22 00:29:43 -0700 | [diff] [blame] | 671 | else |
| 672 | return -ENXIO; |
| 673 | |
| 674 | if (offset + start_pad + end_trunc >= size) { |
| 675 | dev_err(&nd_pfn->dev, "%s unable to satisfy requested alignment\n", |
| 676 | dev_name(&ndns->dev)); |
| 677 | return -ENXIO; |
| 678 | } |
| 679 | |
| 680 | npfns = (size - offset - start_pad - end_trunc) / SZ_4K; |
| 681 | pfn_sb->mode = cpu_to_le32(nd_pfn->mode); |
| 682 | pfn_sb->dataoff = cpu_to_le64(offset); |
| 683 | pfn_sb->npfns = cpu_to_le64(npfns); |
Dan Williams | c5ed926 | 2016-05-18 14:50:12 -0700 | [diff] [blame] | 684 | memcpy(pfn_sb->signature, sig, PFN_SIG_LEN); |
Dan Williams | ac515c0 | 2016-03-22 00:29:43 -0700 | [diff] [blame] | 685 | memcpy(pfn_sb->uuid, nd_pfn->uuid, 16); |
| 686 | memcpy(pfn_sb->parent_uuid, nd_dev_to_uuid(&ndns->dev), 16); |
| 687 | pfn_sb->version_major = cpu_to_le16(1); |
Dan Williams | 7839be2 | 2019-07-18 15:58:36 -0700 | [diff] [blame] | 688 | pfn_sb->version_minor = cpu_to_le16(3); |
Dan Williams | ac515c0 | 2016-03-22 00:29:43 -0700 | [diff] [blame] | 689 | pfn_sb->start_pad = cpu_to_le32(start_pad); |
| 690 | pfn_sb->end_trunc = cpu_to_le32(end_trunc); |
Dan Williams | 45a0dac | 2016-03-31 15:41:18 -0700 | [diff] [blame] | 691 | pfn_sb->align = cpu_to_le32(nd_pfn->align); |
Dan Williams | ac515c0 | 2016-03-22 00:29:43 -0700 | [diff] [blame] | 692 | checksum = nd_sb_checksum((struct nd_gen_sb *) pfn_sb); |
| 693 | pfn_sb->checksum = cpu_to_le64(checksum); |
| 694 | |
| 695 | return nvdimm_write_bytes(ndns, SZ_4K, pfn_sb, sizeof(*pfn_sb)); |
| 696 | } |
| 697 | |
| 698 | /* |
| 699 | * Determine the effective resource range and vmem_altmap from an nd_pfn |
| 700 | * instance. |
| 701 | */ |
| 702 | struct vmem_altmap *nvdimm_setup_pfn(struct nd_pfn *nd_pfn, |
| 703 | struct resource *res, struct vmem_altmap *altmap) |
| 704 | { |
| 705 | int rc; |
| 706 | |
| 707 | if (!nd_pfn->uuid || !nd_pfn->ndns) |
| 708 | return ERR_PTR(-ENODEV); |
| 709 | |
| 710 | rc = nd_pfn_init(nd_pfn); |
| 711 | if (rc) |
| 712 | return ERR_PTR(rc); |
| 713 | |
| 714 | /* we need a valid pfn_sb before we can init a vmem_altmap */ |
| 715 | return __nvdimm_setup_pfn(nd_pfn, res, altmap); |
| 716 | } |
| 717 | EXPORT_SYMBOL_GPL(nvdimm_setup_pfn); |