blob: e8f03b0e95e4a7b5357e1a50ad704218bd0267ac [file] [log] [blame]
Dan Williamse1455742015-07-30 17:57:47 -04001/*
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/device.h>
14#include <linux/sizes.h>
15#include "nd-core.h"
16#include "pfn.h"
17#include "btt.h"
18#include "nd.h"
19
20void __nd_detach_ndns(struct device *dev, struct nd_namespace_common **_ndns)
21{
22 struct nd_namespace_common *ndns = *_ndns;
23
24 dev_WARN_ONCE(dev, !mutex_is_locked(&ndns->dev.mutex)
25 || ndns->claim != dev,
26 "%s: invalid claim\n", __func__);
27 ndns->claim = NULL;
28 *_ndns = NULL;
29 put_device(&ndns->dev);
30}
31
32void nd_detach_ndns(struct device *dev,
33 struct nd_namespace_common **_ndns)
34{
35 struct nd_namespace_common *ndns = *_ndns;
36
37 if (!ndns)
38 return;
39 get_device(&ndns->dev);
40 device_lock(&ndns->dev);
41 __nd_detach_ndns(dev, _ndns);
42 device_unlock(&ndns->dev);
43 put_device(&ndns->dev);
44}
45
46bool __nd_attach_ndns(struct device *dev, struct nd_namespace_common *attach,
47 struct nd_namespace_common **_ndns)
48{
49 if (attach->claim)
50 return false;
51 dev_WARN_ONCE(dev, !mutex_is_locked(&attach->dev.mutex)
52 || *_ndns,
53 "%s: invalid claim\n", __func__);
54 attach->claim = dev;
55 *_ndns = attach;
56 get_device(&attach->dev);
57 return true;
58}
59
60bool nd_attach_ndns(struct device *dev, struct nd_namespace_common *attach,
61 struct nd_namespace_common **_ndns)
62{
63 bool claimed;
64
65 device_lock(&attach->dev);
66 claimed = __nd_attach_ndns(dev, attach, _ndns);
67 device_unlock(&attach->dev);
68 return claimed;
69}
70
71static int namespace_match(struct device *dev, void *data)
72{
73 char *name = data;
74
75 return strcmp(name, dev_name(dev)) == 0;
76}
77
78static bool is_idle(struct device *dev, struct nd_namespace_common *ndns)
79{
80 struct nd_region *nd_region = to_nd_region(dev->parent);
81 struct device *seed = NULL;
82
83 if (is_nd_btt(dev))
84 seed = nd_region->btt_seed;
85 else if (is_nd_pfn(dev))
86 seed = nd_region->pfn_seed;
87
88 if (seed == dev || ndns || dev->driver)
89 return false;
90 return true;
91}
92
93static void nd_detach_and_reset(struct device *dev,
94 struct nd_namespace_common **_ndns)
95{
96 /* detach the namespace and destroy / reset the device */
97 nd_detach_ndns(dev, _ndns);
98 if (is_idle(dev, *_ndns)) {
99 nd_device_unregister(dev, ND_ASYNC);
100 } else if (is_nd_btt(dev)) {
101 struct nd_btt *nd_btt = to_nd_btt(dev);
102
103 nd_btt->lbasize = 0;
104 kfree(nd_btt->uuid);
105 nd_btt->uuid = NULL;
106 } else if (is_nd_pfn(dev)) {
107 struct nd_pfn *nd_pfn = to_nd_pfn(dev);
108
109 kfree(nd_pfn->uuid);
110 nd_pfn->uuid = NULL;
111 nd_pfn->mode = PFN_MODE_NONE;
112 }
113}
114
115ssize_t nd_namespace_store(struct device *dev,
116 struct nd_namespace_common **_ndns, const char *buf,
117 size_t len)
118{
119 struct nd_namespace_common *ndns;
120 struct device *found;
121 char *name;
122
123 if (dev->driver) {
124 dev_dbg(dev, "%s: -EBUSY\n", __func__);
125 return -EBUSY;
126 }
127
128 name = kstrndup(buf, len, GFP_KERNEL);
129 if (!name)
130 return -ENOMEM;
131 strim(name);
132
133 if (strncmp(name, "namespace", 9) == 0 || strcmp(name, "") == 0)
134 /* pass */;
135 else {
136 len = -EINVAL;
137 goto out;
138 }
139
140 ndns = *_ndns;
141 if (strcmp(name, "") == 0) {
142 nd_detach_and_reset(dev, _ndns);
143 goto out;
144 } else if (ndns) {
145 dev_dbg(dev, "namespace already set to: %s\n",
146 dev_name(&ndns->dev));
147 len = -EBUSY;
148 goto out;
149 }
150
151 found = device_find_child(dev->parent, name, namespace_match);
152 if (!found) {
153 dev_dbg(dev, "'%s' not found under %s\n", name,
154 dev_name(dev->parent));
155 len = -ENODEV;
156 goto out;
157 }
158
159 ndns = to_ndns(found);
160 if (__nvdimm_namespace_capacity(ndns) < SZ_16M) {
161 dev_dbg(dev, "%s too small to host\n", name);
162 len = -ENXIO;
163 goto out_attach;
164 }
165
166 WARN_ON_ONCE(!is_nvdimm_bus_locked(dev));
167 if (!nd_attach_ndns(dev, ndns, _ndns)) {
168 dev_dbg(dev, "%s already claimed\n",
169 dev_name(&ndns->dev));
170 len = -EBUSY;
171 }
172
173 out_attach:
174 put_device(&ndns->dev); /* from device_find_child */
175 out:
176 kfree(name);
177 return len;
178}
179
180/*
181 * nd_sb_checksum: compute checksum for a generic info block
182 *
183 * Returns a fletcher64 checksum of everything in the given info block
184 * except the last field (since that's where the checksum lives).
185 */
186u64 nd_sb_checksum(struct nd_gen_sb *nd_gen_sb)
187{
188 u64 sum;
189 __le64 sum_save;
190
191 BUILD_BUG_ON(sizeof(struct btt_sb) != SZ_4K);
192 BUILD_BUG_ON(sizeof(struct nd_pfn_sb) != SZ_4K);
193 BUILD_BUG_ON(sizeof(struct nd_gen_sb) != SZ_4K);
194
195 sum_save = nd_gen_sb->checksum;
196 nd_gen_sb->checksum = 0;
197 sum = nd_fletcher64(nd_gen_sb, sizeof(*nd_gen_sb), 1);
198 nd_gen_sb->checksum = sum_save;
199 return sum;
200}
201EXPORT_SYMBOL(nd_sb_checksum);