drivers/nvdimm/core.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
   4  */
   5 #include <linux/libnvdimm.h>
   6 #include <linux/badblocks.h>
   7 #include <linux/export.h>
   8 #include <linux/module.h>
   9 #include <linux/blkdev.h>
  10 #include <linux/device.h>
  11 #include <linux/ctype.h>
  12 #include <linux/ndctl.h>
  13 #include <linux/mutex.h>
  14 #include <linux/slab.h>
  15 #include <linux/io.h>
  16 #include "nd-core.h"
  17 #include "nd.h"
  18
  19 LIST_HEAD(nvdimm_bus_list);
  20 DEFINE_MUTEX(nvdimm_bus_list_mutex);
  21
  22 void nvdimm_bus_lock(struct device *dev)
  23 {
  24         struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
  25
  26         if (!nvdimm_bus)
  27                 return;
  28         mutex_lock(&nvdimm_bus->reconfig_mutex);
  29 }
  30 EXPORT_SYMBOL(nvdimm_bus_lock);
  31
  32 void nvdimm_bus_unlock(struct device *dev)
  33 {
  34         struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
  35
  36         if (!nvdimm_bus)
  37                 return;
  38         mutex_unlock(&nvdimm_bus->reconfig_mutex);
  39 }
  40 EXPORT_SYMBOL(nvdimm_bus_unlock);
  41
  42 bool is_nvdimm_bus_locked(struct device *dev)
  43 {
  44         struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
  45
  46         if (!nvdimm_bus)
  47                 return false;
  48         return mutex_is_locked(&nvdimm_bus->reconfig_mutex);
  49 }
  50 EXPORT_SYMBOL(is_nvdimm_bus_locked);
  51
  52 struct nvdimm_map {
  53         struct nvdimm_bus *nvdimm_bus;
  54         struct list_head list;
  55         resource_size_t offset;
  56         unsigned long flags;
  57         size_t size;
  58         union {
  59                 void *mem;
  60                 void __iomem *iomem;
  61         };
  62         struct kref kref;
  63 };
  64
  65 static struct nvdimm_map *find_nvdimm_map(struct device *dev,
  66                 resource_size_t offset)
  67 {
  68         struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
  69         struct nvdimm_map *nvdimm_map;
  70
  71         list_for_each_entry(nvdimm_map, &nvdimm_bus->mapping_list, list)
  72                 if (nvdimm_map->offset == offset)
  73                         return nvdimm_map;
  74         return NULL;
  75 }
  76
  77 static struct nvdimm_map *alloc_nvdimm_map(struct device *dev,
  78                 resource_size_t offset, size_t size, unsigned long flags)
  79 {
  80         struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
  81         struct nvdimm_map *nvdimm_map;
  82
  83         nvdimm_map = kzalloc(sizeof(*nvdimm_map), GFP_KERNEL);
  84         if (!nvdimm_map)
  85                 return NULL;
  86
  87         INIT_LIST_HEAD(&nvdimm_map->list);
  88         nvdimm_map->nvdimm_bus = nvdimm_bus;
  89         nvdimm_map->offset = offset;
  90         nvdimm_map->flags = flags;
  91         nvdimm_map->size = size;
  92         kref_init(&nvdimm_map->kref);
  93
  94         if (!request_mem_region(offset, size, dev_name(&nvdimm_bus->dev))) {
  95                 dev_err(&nvdimm_bus->dev, "failed to request %pa + %zd for %s\n",
  96                                 &offset, size, dev_name(dev));
  97                 goto err_request_region;
  98         }
  99
 100         if (flags)
 101                 nvdimm_map->mem = memremap(offset, size, flags);
 102         else
 103                 nvdimm_map->iomem = ioremap(offset, size);
 104
 105         if (!nvdimm_map->mem)
 106                 goto err_map;
 107
 108         dev_WARN_ONCE(dev, !is_nvdimm_bus_locked(dev), "%s: bus unlocked!",
 109                         __func__);
 110         list_add(&nvdimm_map->list, &nvdimm_bus->mapping_list);
 111
 112         return nvdimm_map;
 113
 114  err_map:
 115         release_mem_region(offset, size);
 116  err_request_region:
 117         kfree(nvdimm_map);
 118         return NULL;
 119 }
 120
 121 static void nvdimm_map_release(struct kref *kref)
 122 {
 123         struct nvdimm_bus *nvdimm_bus;
 124         struct nvdimm_map *nvdimm_map;
 125
 126         nvdimm_map = container_of(kref, struct nvdimm_map, kref);
 127         nvdimm_bus = nvdimm_map->nvdimm_bus;
 128
 129         dev_dbg(&nvdimm_bus->dev, "%pa\n", &nvdimm_map->offset);
 130         list_del(&nvdimm_map->list);
 131         if (nvdimm_map->flags)
 132                 memunmap(nvdimm_map->mem);
 133         else
 134                 iounmap(nvdimm_map->iomem);
 135         release_mem_region(nvdimm_map->offset, nvdimm_map->size);
 136         kfree(nvdimm_map);
 137 }
 138
 139 static void nvdimm_map_put(void *data)
 140 {
 141         struct nvdimm_map *nvdimm_map = data;
 142         struct nvdimm_bus *nvdimm_bus = nvdimm_map->nvdimm_bus;
 143
 144         nvdimm_bus_lock(&nvdimm_bus->dev);
 145         kref_put(&nvdimm_map->kref, nvdimm_map_release);
 146         nvdimm_bus_unlock(&nvdimm_bus->dev);
 147 }
 148
 149 /**
 150  * devm_nvdimm_memremap - map a resource that is shared across regions
 151  * @dev: device that will own a reference to the shared mapping
 152  * @offset: physical base address of the mapping
 153  * @size: mapping size
 154  * @flags: memremap flags, or, if zero, perform an ioremap instead
 155  */
 156 void *devm_nvdimm_memremap(struct device *dev, resource_size_t offset,
 157                 size_t size, unsigned long flags)
 158 {
 159         struct nvdimm_map *nvdimm_map;
 160
 161         nvdimm_bus_lock(dev);
 162         nvdimm_map = find_nvdimm_map(dev, offset);
 163         if (!nvdimm_map)
 164                 nvdimm_map = alloc_nvdimm_map(dev, offset, size, flags);
 165         else
 166                 kref_get(&nvdimm_map->kref);
 167         nvdimm_bus_unlock(dev);
 168
 169         if (!nvdimm_map)
 170                 return NULL;
 171
 172         if (devm_add_action_or_reset(dev, nvdimm_map_put, nvdimm_map))
 173                 return NULL;
 174
 175         return nvdimm_map->mem;
 176 }
 177 EXPORT_SYMBOL_GPL(devm_nvdimm_memremap);
 178
 179 u64 nd_fletcher64(void *addr, size_t len, bool le)
 180 {
 181         u32 *buf = addr;
 182         u32 lo32 = 0;
 183         u64 hi32 = 0;
 184         int i;
 185
 186         for (i = 0; i < len / sizeof(u32); i++) {
 187                 lo32 += le ? le32_to_cpu((__le32) buf[i]) : buf[i];
 188                 hi32 += lo32;
 189         }
 190
 191         return hi32 << 32 | lo32;
 192 }
 193 EXPORT_SYMBOL_GPL(nd_fletcher64);
 194
 195 struct nvdimm_bus_descriptor *to_nd_desc(struct nvdimm_bus *nvdimm_bus)
 196 {
 197         /* struct nvdimm_bus definition is private to libnvdimm */
 198         return nvdimm_bus->nd_desc;
 199 }
 200 EXPORT_SYMBOL_GPL(to_nd_desc);
 201
 202 struct device *to_nvdimm_bus_dev(struct nvdimm_bus *nvdimm_bus)
 203 {
 204         /* struct nvdimm_bus definition is private to libnvdimm */
 205         return &nvdimm_bus->dev;
 206 }
 207 EXPORT_SYMBOL_GPL(to_nvdimm_bus_dev);
 208
 209 static bool is_uuid_sep(char sep)
 210 {
 211         if (sep == '\n' || sep == '-' || sep == ':' || sep == '\0')
 212                 return true;
 213         return false;
 214 }
 215
 216 static int nd_uuid_parse(struct device *dev, u8 *uuid_out, const char *buf,
 217                 size_t len)
 218 {
 219         const char *str = buf;
 220         u8 uuid[16];
 221         int i;
 222
 223         for (i = 0; i < 16; i++) {
 224                 if (!isxdigit(str[0]) || !isxdigit(str[1])) {
 225                         dev_dbg(dev, "pos: %d buf[%zd]: %c buf[%zd]: %c\n",
 226                                         i, str - buf, str[0],
 227                                         str + 1 - buf, str[1]);
 228                         return -EINVAL;
 229                 }
 230
 231                 uuid[i] = (hex_to_bin(str[0]) << 4) | hex_to_bin(str[1]);
 232                 str += 2;
 233                 if (is_uuid_sep(*str))
 234                         str++;
 235         }
 236
 237         memcpy(uuid_out, uuid, sizeof(uuid));
 238         return 0;
 239 }
 240
 241 /**
 242  * nd_uuid_store: common implementation for writing 'uuid' sysfs attributes
 243  * @dev: container device for the uuid property
 244  * @uuid_out: uuid buffer to replace
 245  * @buf: raw sysfs buffer to parse
 246  *
 247  * Enforce that uuids can only be changed while the device is disabled
 248  * (driver detached)
 249  * LOCKING: expects nd_device_lock() is held on entry
 250  */
 251 int nd_uuid_store(struct device *dev, u8 **uuid_out, const char *buf,
 252                 size_t len)
 253 {
 254         u8 uuid[16];
 255         int rc;
 256
 257         if (dev->driver)
 258                 return -EBUSY;
 259
 260         rc = nd_uuid_parse(dev, uuid, buf, len);
 261         if (rc)
 262                 return rc;
 263
 264         kfree(*uuid_out);
 265         *uuid_out = kmemdup(uuid, sizeof(uuid), GFP_KERNEL);
 266         if (!(*uuid_out))
 267                 return -ENOMEM;
 268
 269         return 0;
 270 }
 271
 272 ssize_t nd_size_select_show(unsigned long current_size,
 273                 const unsigned long *supported, char *buf)
 274 {
 275         ssize_t len = 0;
 276         int i;
 277
 278         for (i = 0; supported[i]; i++)
 279                 if (current_size == supported[i])
 280                         len += sprintf(buf + len, "[%ld] ", supported[i]);
 281                 else
 282                         len += sprintf(buf + len, "%ld ", supported[i]);
 283         len += sprintf(buf + len, "\n");
 284         return len;
 285 }
 286
 287 ssize_t nd_size_select_store(struct device *dev, const char *buf,
 288                 unsigned long *current_size, const unsigned long *supported)
 289 {
 290         unsigned long lbasize;
 291         int rc, i;
 292
 293         if (dev->driver)
 294                 return -EBUSY;
 295
 296         rc = kstrtoul(buf, 0, &lbasize);
 297         if (rc)
 298                 return rc;
 299
 300         for (i = 0; supported[i]; i++)
 301                 if (lbasize == supported[i])
 302                         break;
 303
 304         if (supported[i]) {
 305                 *current_size = lbasize;
 306                 return 0;
 307         } else {
 308                 return -EINVAL;
 309         }
 310 }
 311
 312 static ssize_t commands_show(struct device *dev,
 313                 struct device_attribute *attr, char *buf)
 314 {
 315         int cmd, len = 0;
 316         struct nvdimm_bus *nvdimm_bus = to_nvdimm_bus(dev);
 317         struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
 318
 319         for_each_set_bit(cmd, &nd_desc->cmd_mask, BITS_PER_LONG)
 320                 len += sprintf(buf + len, "%s ", nvdimm_bus_cmd_name(cmd));
 321         len += sprintf(buf + len, "\n");
 322         return len;
 323 }
 324 static DEVICE_ATTR_RO(commands);
 325
 326 static const char *nvdimm_bus_provider(struct nvdimm_bus *nvdimm_bus)
 327 {
 328         struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
 329         struct device *parent = nvdimm_bus->dev.parent;
 330
 331         if (nd_desc->provider_name)
 332                 return nd_desc->provider_name;
 333         else if (parent)
 334                 return dev_name(parent);
 335         else
 336                 return "unknown";
 337 }
 338
 339 static ssize_t provider_show(struct device *dev,
 340                 struct device_attribute *attr, char *buf)
 341 {
 342         struct nvdimm_bus *nvdimm_bus = to_nvdimm_bus(dev);
 343
 344         return sprintf(buf, "%s\n", nvdimm_bus_provider(nvdimm_bus));
 345 }
 346 static DEVICE_ATTR_RO(provider);
 347
 348 static int flush_namespaces(struct device *dev, void *data)
 349 {
 350         nd_device_lock(dev);
 351         nd_device_unlock(dev);
 352         return 0;
 353 }
 354
 355 static int flush_regions_dimms(struct device *dev, void *data)
 356 {
 357         nd_device_lock(dev);
 358         nd_device_unlock(dev);
 359         device_for_each_child(dev, NULL, flush_namespaces);
 360         return 0;
 361 }
 362
 363 static ssize_t wait_probe_show(struct device *dev,
 364                 struct device_attribute *attr, char *buf)
 365 {
 366         struct nvdimm_bus *nvdimm_bus = to_nvdimm_bus(dev);
 367         struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
 368         int rc;
 369
 370         if (nd_desc->flush_probe) {
 371                 rc = nd_desc->flush_probe(nd_desc);
 372                 if (rc)
 373                         return rc;
 374         }
 375         nd_synchronize();
 376         device_for_each_child(dev, NULL, flush_regions_dimms);
 377         return sprintf(buf, "1\n");
 378 }
 379 static DEVICE_ATTR_RO(wait_probe);
 380
 381 static struct attribute *nvdimm_bus_attributes[] = {
 382         &dev_attr_commands.attr,
 383         &dev_attr_wait_probe.attr,
 384         &dev_attr_provider.attr,
 385         NULL,
 386 };
 387
 388 static const struct attribute_group nvdimm_bus_attribute_group = {
 389         .attrs = nvdimm_bus_attributes,
 390 };
 391
 392 const struct attribute_group *nvdimm_bus_attribute_groups[] = {
 393         &nvdimm_bus_attribute_group,
 394         NULL,
 395 };
 396
 397 int nvdimm_bus_add_badrange(struct nvdimm_bus *nvdimm_bus, u64 addr, u64 length)
 398 {
 399         return badrange_add(&nvdimm_bus->badrange, addr, length);
 400 }
 401 EXPORT_SYMBOL_GPL(nvdimm_bus_add_badrange);
 402
 403 #ifdef CONFIG_BLK_DEV_INTEGRITY
 404 int nd_integrity_init(struct gendisk *disk, unsigned long meta_size)
 405 {
 406         struct blk_integrity bi;
 407
 408         if (meta_size == 0)
 409                 return 0;
 410
 411         memset(&bi, 0, sizeof(bi));
 412
 413         bi.tuple_size = meta_size;
 414         bi.tag_size = meta_size;
 415
 416         blk_integrity_register(disk, &bi);
 417         blk_queue_max_integrity_segments(disk->queue, 1);
 418
 419         return 0;
 420 }
 421 EXPORT_SYMBOL(nd_integrity_init);
 422
 423 #else /* CONFIG_BLK_DEV_INTEGRITY */
 424 int nd_integrity_init(struct gendisk *disk, unsigned long meta_size)
 425 {
 426         return 0;
 427 }
 428 EXPORT_SYMBOL(nd_integrity_init);
 429
 430 #endif
 431
 432 static __init int libnvdimm_init(void)
 433 {
 434         int rc;
 435
 436         rc = nvdimm_bus_init();
 437         if (rc)
 438                 return rc;
 439         rc = nvdimm_init();
 440         if (rc)
 441                 goto err_dimm;
 442         rc = nd_region_init();
 443         if (rc)
 444                 goto err_region;
 445
 446         nd_label_init();
 447
 448         return 0;
 449  err_region:
 450         nvdimm_exit();
 451  err_dimm:
 452         nvdimm_bus_exit();
 453         return rc;
 454 }
 455
 456 static __exit void libnvdimm_exit(void)
 457 {
 458         WARN_ON(!list_empty(&nvdimm_bus_list));
 459         nd_region_exit();
 460         nvdimm_exit();
 461         nvdimm_bus_exit();
 462         nvdimm_devs_exit();
 463 }
 464
 465 MODULE_LICENSE("GPL v2");
 466 MODULE_AUTHOR("Intel Corporation");
 467 subsys_initcall(libnvdimm_init);
 468 module_exit(libnvdimm_exit);