drivers/nvdimm/dax_devs.c

   1 /*
   2  * Copyright(c) 2013-2016 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/device.h>
  14 #include <linux/sizes.h>
  15 #include <linux/slab.h>
  16 #include <linux/mm.h>
  17 #include "nd-core.h"
  18 #include "pfn.h"
  19 #include "nd.h"
  20
  21 static void nd_dax_release(struct device *dev)
  22 {
  23         struct nd_region *nd_region = to_nd_region(dev->parent);
  24         struct nd_dax *nd_dax = to_nd_dax(dev);
  25         struct nd_pfn *nd_pfn = &nd_dax->nd_pfn;
  26
  27         dev_dbg(dev, "%s\n", __func__);
  28         nd_detach_ndns(dev, &nd_pfn->ndns);
  29         ida_simple_remove(&nd_region->dax_ida, nd_pfn->id);
  30         kfree(nd_pfn->uuid);
  31         kfree(nd_dax);
  32 }
  33
  34 static struct device_type nd_dax_device_type = {
  35         .name = "nd_dax",
  36         .release = nd_dax_release,
  37 };
  38
  39 bool is_nd_dax(struct device *dev)
  40 {
  41         return dev ? dev->type == &nd_dax_device_type : false;
  42 }
  43 EXPORT_SYMBOL(is_nd_dax);
  44
  45 struct nd_dax *to_nd_dax(struct device *dev)
  46 {
  47         struct nd_dax *nd_dax = container_of(dev, struct nd_dax, nd_pfn.dev);
  48
  49         WARN_ON(!is_nd_dax(dev));
  50         return nd_dax;
  51 }
  52 EXPORT_SYMBOL(to_nd_dax);
  53
  54 static const struct attribute_group *nd_dax_attribute_groups[] = {
  55         &nd_pfn_attribute_group,
  56         &nd_device_attribute_group,
  57         &nd_numa_attribute_group,
  58         NULL,
  59 };
  60
  61 static struct nd_dax *nd_dax_alloc(struct nd_region *nd_region)
  62 {
  63         struct nd_pfn *nd_pfn;
  64         struct nd_dax *nd_dax;
  65         struct device *dev;
  66
  67         nd_dax = kzalloc(sizeof(*nd_dax), GFP_KERNEL);
  68         if (!nd_dax)
  69                 return NULL;
  70
  71         nd_pfn = &nd_dax->nd_pfn;
  72         nd_pfn->id = ida_simple_get(&nd_region->dax_ida, 0, 0, GFP_KERNEL);
  73         if (nd_pfn->id < 0) {
  74                 kfree(nd_dax);
  75                 return NULL;
  76         }
  77
  78         dev = &nd_pfn->dev;
  79         dev_set_name(dev, "dax%d.%d", nd_region->id, nd_pfn->id);
  80         dev->groups = nd_dax_attribute_groups;
  81         dev->type = &nd_dax_device_type;
  82         dev->parent = &nd_region->dev;
  83
  84         return nd_dax;
  85 }
  86
  87 struct device *nd_dax_create(struct nd_region *nd_region)
  88 {
  89         struct device *dev = NULL;
  90         struct nd_dax *nd_dax;
  91
  92         if (!is_memory(&nd_region->dev))
  93                 return NULL;
  94
  95         nd_dax = nd_dax_alloc(nd_region);
  96         if (nd_dax)
  97                 dev = nd_pfn_devinit(&nd_dax->nd_pfn, NULL);
  98         __nd_device_register(dev);
  99         return dev;
 100 }
 101
 102 int nd_dax_probe(struct device *dev, struct nd_namespace_common *ndns)
 103 {
 104         int rc;
 105         struct nd_dax *nd_dax;
 106         struct device *dax_dev;
 107         struct nd_pfn *nd_pfn;
 108         struct nd_pfn_sb *pfn_sb;
 109         struct nd_region *nd_region = to_nd_region(ndns->dev.parent);
 110
 111         if (ndns->force_raw)
 112                 return -ENODEV;
 113
 114         switch (ndns->claim_class) {
 115         case NVDIMM_CCLASS_NONE:
 116         case NVDIMM_CCLASS_DAX:
 117                 break;
 118         default:
 119                 return -ENODEV;
 120         }
 121
 122         nvdimm_bus_lock(&ndns->dev);
 123         nd_dax = nd_dax_alloc(nd_region);
 124         nd_pfn = &nd_dax->nd_pfn;
 125         dax_dev = nd_pfn_devinit(nd_pfn, ndns);
 126         nvdimm_bus_unlock(&ndns->dev);
 127         if (!dax_dev)
 128                 return -ENOMEM;
 129         pfn_sb = devm_kzalloc(dev, sizeof(*pfn_sb), GFP_KERNEL);
 130         nd_pfn->pfn_sb = pfn_sb;
 131         rc = nd_pfn_validate(nd_pfn, DAX_SIG);
 132         dev_dbg(dev, "%s: dax: %s\n", __func__,
 133                         rc == 0 ? dev_name(dax_dev) : "<none>");
 134         if (rc < 0) {
 135                 nd_detach_ndns(dax_dev, &nd_pfn->ndns);
 136                 put_device(dax_dev);
 137         } else
 138                 __nd_device_register(dax_dev);
 139
 140         return rc;
 141 }
 142 EXPORT_SYMBOL(nd_dax_probe);