]>
Commit | Line | Data |
---|---|---|
5b497af4 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
e1455744 DW |
2 | /* |
3 | * Copyright(c) 2013-2015 Intel Corporation. All rights reserved. | |
e1455744 DW |
4 | */ |
5 | #include <linux/device.h> | |
6 | #include <linux/sizes.h> | |
7 | #include "nd-core.h" | |
f2b61257 | 8 | #include "pmem.h" |
e1455744 DW |
9 | #include "pfn.h" |
10 | #include "btt.h" | |
11 | #include "nd.h" | |
12 | ||
13 | void __nd_detach_ndns(struct device *dev, struct nd_namespace_common **_ndns) | |
14 | { | |
15 | struct nd_namespace_common *ndns = *_ndns; | |
452bae0a | 16 | struct nvdimm_bus *nvdimm_bus; |
e1455744 | 17 | |
452bae0a DW |
18 | if (!ndns) |
19 | return; | |
20 | ||
21 | nvdimm_bus = walk_to_nvdimm_bus(&ndns->dev); | |
22 | lockdep_assert_held(&nvdimm_bus->reconfig_mutex); | |
9cf8bd52 | 23 | dev_WARN_ONCE(dev, ndns->claim != dev, "%s: invalid claim\n", __func__); |
e1455744 DW |
24 | ndns->claim = NULL; |
25 | *_ndns = NULL; | |
26 | put_device(&ndns->dev); | |
27 | } | |
28 | ||
29 | void nd_detach_ndns(struct device *dev, | |
30 | struct nd_namespace_common **_ndns) | |
31 | { | |
32 | struct nd_namespace_common *ndns = *_ndns; | |
33 | ||
34 | if (!ndns) | |
35 | return; | |
36 | get_device(&ndns->dev); | |
452bae0a | 37 | nvdimm_bus_lock(&ndns->dev); |
e1455744 | 38 | __nd_detach_ndns(dev, _ndns); |
452bae0a | 39 | nvdimm_bus_unlock(&ndns->dev); |
e1455744 DW |
40 | put_device(&ndns->dev); |
41 | } | |
42 | ||
43 | bool __nd_attach_ndns(struct device *dev, struct nd_namespace_common *attach, | |
44 | struct nd_namespace_common **_ndns) | |
45 | { | |
452bae0a DW |
46 | struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(&attach->dev); |
47 | ||
e1455744 DW |
48 | if (attach->claim) |
49 | return false; | |
452bae0a | 50 | lockdep_assert_held(&nvdimm_bus->reconfig_mutex); |
9cf8bd52 | 51 | dev_WARN_ONCE(dev, *_ndns, "%s: invalid claim\n", __func__); |
e1455744 DW |
52 | attach->claim = dev; |
53 | *_ndns = attach; | |
54 | get_device(&attach->dev); | |
55 | return true; | |
56 | } | |
57 | ||
58 | bool nd_attach_ndns(struct device *dev, struct nd_namespace_common *attach, | |
59 | struct nd_namespace_common **_ndns) | |
60 | { | |
61 | bool claimed; | |
62 | ||
452bae0a | 63 | nvdimm_bus_lock(&attach->dev); |
e1455744 | 64 | claimed = __nd_attach_ndns(dev, attach, _ndns); |
452bae0a | 65 | nvdimm_bus_unlock(&attach->dev); |
e1455744 DW |
66 | return claimed; |
67 | } | |
68 | ||
69 | static int namespace_match(struct device *dev, void *data) | |
70 | { | |
71 | char *name = data; | |
72 | ||
73 | return strcmp(name, dev_name(dev)) == 0; | |
74 | } | |
75 | ||
76 | static bool is_idle(struct device *dev, struct nd_namespace_common *ndns) | |
77 | { | |
78 | struct nd_region *nd_region = to_nd_region(dev->parent); | |
79 | struct device *seed = NULL; | |
80 | ||
81 | if (is_nd_btt(dev)) | |
82 | seed = nd_region->btt_seed; | |
83 | else if (is_nd_pfn(dev)) | |
84 | seed = nd_region->pfn_seed; | |
cd03412a DW |
85 | else if (is_nd_dax(dev)) |
86 | seed = nd_region->dax_seed; | |
e1455744 DW |
87 | |
88 | if (seed == dev || ndns || dev->driver) | |
89 | return false; | |
90 | return true; | |
91 | } | |
92 | ||
03dca343 DW |
93 | struct nd_pfn *to_nd_pfn_safe(struct device *dev) |
94 | { | |
95 | /* | |
96 | * pfn device attributes are re-used by dax device instances, so we | |
97 | * need to be careful to correct device-to-nd_pfn conversion. | |
98 | */ | |
99 | if (is_nd_pfn(dev)) | |
100 | return to_nd_pfn(dev); | |
101 | ||
102 | if (is_nd_dax(dev)) { | |
103 | struct nd_dax *nd_dax = to_nd_dax(dev); | |
104 | ||
105 | return &nd_dax->nd_pfn; | |
106 | } | |
107 | ||
108 | WARN_ON(1); | |
109 | return NULL; | |
110 | } | |
111 | ||
e1455744 DW |
112 | static void nd_detach_and_reset(struct device *dev, |
113 | struct nd_namespace_common **_ndns) | |
114 | { | |
115 | /* detach the namespace and destroy / reset the device */ | |
452bae0a | 116 | __nd_detach_ndns(dev, _ndns); |
e1455744 DW |
117 | if (is_idle(dev, *_ndns)) { |
118 | nd_device_unregister(dev, ND_ASYNC); | |
119 | } else if (is_nd_btt(dev)) { | |
120 | struct nd_btt *nd_btt = to_nd_btt(dev); | |
121 | ||
122 | nd_btt->lbasize = 0; | |
123 | kfree(nd_btt->uuid); | |
124 | nd_btt->uuid = NULL; | |
03dca343 DW |
125 | } else if (is_nd_pfn(dev) || is_nd_dax(dev)) { |
126 | struct nd_pfn *nd_pfn = to_nd_pfn_safe(dev); | |
e1455744 DW |
127 | |
128 | kfree(nd_pfn->uuid); | |
129 | nd_pfn->uuid = NULL; | |
130 | nd_pfn->mode = PFN_MODE_NONE; | |
131 | } | |
132 | } | |
133 | ||
134 | ssize_t nd_namespace_store(struct device *dev, | |
135 | struct nd_namespace_common **_ndns, const char *buf, | |
136 | size_t len) | |
137 | { | |
138 | struct nd_namespace_common *ndns; | |
139 | struct device *found; | |
140 | char *name; | |
141 | ||
142 | if (dev->driver) { | |
426824d6 | 143 | dev_dbg(dev, "namespace already active\n"); |
e1455744 DW |
144 | return -EBUSY; |
145 | } | |
146 | ||
147 | name = kstrndup(buf, len, GFP_KERNEL); | |
148 | if (!name) | |
149 | return -ENOMEM; | |
150 | strim(name); | |
151 | ||
152 | if (strncmp(name, "namespace", 9) == 0 || strcmp(name, "") == 0) | |
153 | /* pass */; | |
154 | else { | |
155 | len = -EINVAL; | |
156 | goto out; | |
157 | } | |
158 | ||
159 | ndns = *_ndns; | |
160 | if (strcmp(name, "") == 0) { | |
161 | nd_detach_and_reset(dev, _ndns); | |
162 | goto out; | |
163 | } else if (ndns) { | |
164 | dev_dbg(dev, "namespace already set to: %s\n", | |
165 | dev_name(&ndns->dev)); | |
166 | len = -EBUSY; | |
167 | goto out; | |
168 | } | |
169 | ||
170 | found = device_find_child(dev->parent, name, namespace_match); | |
171 | if (!found) { | |
172 | dev_dbg(dev, "'%s' not found under %s\n", name, | |
173 | dev_name(dev->parent)); | |
174 | len = -ENODEV; | |
175 | goto out; | |
176 | } | |
177 | ||
178 | ndns = to_ndns(found); | |
b3fde74e DW |
179 | |
180 | switch (ndns->claim_class) { | |
181 | case NVDIMM_CCLASS_NONE: | |
182 | break; | |
183 | case NVDIMM_CCLASS_BTT: | |
14e49454 | 184 | case NVDIMM_CCLASS_BTT2: |
b3fde74e DW |
185 | if (!is_nd_btt(dev)) { |
186 | len = -EBUSY; | |
187 | goto out_attach; | |
188 | } | |
189 | break; | |
190 | case NVDIMM_CCLASS_PFN: | |
191 | if (!is_nd_pfn(dev)) { | |
192 | len = -EBUSY; | |
193 | goto out_attach; | |
194 | } | |
195 | break; | |
196 | case NVDIMM_CCLASS_DAX: | |
197 | if (!is_nd_dax(dev)) { | |
198 | len = -EBUSY; | |
199 | goto out_attach; | |
200 | } | |
201 | break; | |
202 | default: | |
203 | len = -EBUSY; | |
204 | goto out_attach; | |
205 | break; | |
206 | } | |
207 | ||
e1455744 DW |
208 | if (__nvdimm_namespace_capacity(ndns) < SZ_16M) { |
209 | dev_dbg(dev, "%s too small to host\n", name); | |
210 | len = -ENXIO; | |
211 | goto out_attach; | |
212 | } | |
213 | ||
214 | WARN_ON_ONCE(!is_nvdimm_bus_locked(dev)); | |
452bae0a | 215 | if (!__nd_attach_ndns(dev, ndns, _ndns)) { |
e1455744 DW |
216 | dev_dbg(dev, "%s already claimed\n", |
217 | dev_name(&ndns->dev)); | |
218 | len = -EBUSY; | |
219 | } | |
220 | ||
221 | out_attach: | |
222 | put_device(&ndns->dev); /* from device_find_child */ | |
223 | out: | |
224 | kfree(name); | |
225 | return len; | |
226 | } | |
227 | ||
228 | /* | |
229 | * nd_sb_checksum: compute checksum for a generic info block | |
230 | * | |
231 | * Returns a fletcher64 checksum of everything in the given info block | |
232 | * except the last field (since that's where the checksum lives). | |
233 | */ | |
234 | u64 nd_sb_checksum(struct nd_gen_sb *nd_gen_sb) | |
235 | { | |
236 | u64 sum; | |
237 | __le64 sum_save; | |
238 | ||
239 | BUILD_BUG_ON(sizeof(struct btt_sb) != SZ_4K); | |
240 | BUILD_BUG_ON(sizeof(struct nd_pfn_sb) != SZ_4K); | |
241 | BUILD_BUG_ON(sizeof(struct nd_gen_sb) != SZ_4K); | |
242 | ||
243 | sum_save = nd_gen_sb->checksum; | |
244 | nd_gen_sb->checksum = 0; | |
245 | sum = nd_fletcher64(nd_gen_sb, sizeof(*nd_gen_sb), 1); | |
246 | nd_gen_sb->checksum = sum_save; | |
247 | return sum; | |
248 | } | |
249 | EXPORT_SYMBOL(nd_sb_checksum); | |
200c79da DW |
250 | |
251 | static int nsio_rw_bytes(struct nd_namespace_common *ndns, | |
3ae3d67b VV |
252 | resource_size_t offset, void *buf, size_t size, int rw, |
253 | unsigned long flags) | |
200c79da DW |
254 | { |
255 | struct nd_namespace_io *nsio = to_nd_namespace_io(&ndns->dev); | |
82bf1037 DJ |
256 | unsigned int sz_align = ALIGN(size + (offset & (512 - 1)), 512); |
257 | sector_t sector = offset >> 9; | |
c5d4355d | 258 | int rc = 0, ret = 0; |
82bf1037 DJ |
259 | |
260 | if (unlikely(!size)) | |
261 | return 0; | |
200c79da DW |
262 | |
263 | if (unlikely(offset + size > nsio->size)) { | |
264 | dev_WARN_ONCE(&ndns->dev, 1, "request out of range\n"); | |
265 | return -EFAULT; | |
266 | } | |
267 | ||
268 | if (rw == READ) { | |
82bf1037 | 269 | if (unlikely(is_bad_pmem(&nsio->bb, sector, sz_align))) |
200c79da | 270 | return -EIO; |
60622d68 DW |
271 | if (memcpy_mcsafe(buf, nsio->addr + offset, size) != 0) |
272 | return -EIO; | |
b62cc6fd | 273 | return 0; |
d37806dc FF |
274 | } |
275 | ||
276 | if (unlikely(is_bad_pmem(&nsio->bb, sector, sz_align))) { | |
a3e9af95 | 277 | if (IS_ALIGNED(offset, 512) && IS_ALIGNED(size, 512) |
7e5a21df | 278 | && !(flags & NVDIMM_IO_ATOMIC)) { |
d37806dc FF |
279 | long cleared; |
280 | ||
1db1f3ce | 281 | might_sleep(); |
97681f9b TK |
282 | cleared = nvdimm_clear_poison(&ndns->dev, |
283 | nsio->res.start + offset, size); | |
868f036f | 284 | if (cleared < size) |
82bf1037 | 285 | rc = -EIO; |
868f036f DW |
286 | if (cleared > 0 && cleared / 512) { |
287 | cleared /= 512; | |
288 | badblocks_clear(&nsio->bb, sector, cleared); | |
d37806dc | 289 | } |
f2b61257 | 290 | arch_invalidate_pmem(nsio->addr + offset, size); |
d37806dc FF |
291 | } else |
292 | rc = -EIO; | |
200c79da DW |
293 | } |
294 | ||
0aed55af | 295 | memcpy_flushcache(nsio->addr + offset, buf, size); |
c5d4355d PG |
296 | ret = nvdimm_flush(to_nd_region(ndns->dev.parent), NULL); |
297 | if (ret) | |
298 | rc = ret; | |
d37806dc | 299 | |
82bf1037 | 300 | return rc; |
200c79da DW |
301 | } |
302 | ||
8f4b01fc AK |
303 | int devm_nsio_enable(struct device *dev, struct nd_namespace_io *nsio, |
304 | resource_size_t size) | |
200c79da DW |
305 | { |
306 | struct resource *res = &nsio->res; | |
307 | struct nd_namespace_common *ndns = &nsio->common; | |
308 | ||
8f4b01fc AK |
309 | nsio->size = size; |
310 | if (!devm_request_mem_region(dev, res->start, size, | |
450c6633 | 311 | dev_name(&ndns->dev))) { |
200c79da DW |
312 | dev_warn(dev, "could not reserve region %pR\n", res); |
313 | return -EBUSY; | |
314 | } | |
315 | ||
316 | ndns->rw_bytes = nsio_rw_bytes; | |
317 | if (devm_init_badblocks(dev, &nsio->bb)) | |
318 | return -ENOMEM; | |
319 | nvdimm_badblocks_populate(to_nd_region(ndns->dev.parent), &nsio->bb, | |
320 | &nsio->res); | |
321 | ||
8f4b01fc | 322 | nsio->addr = devm_memremap(dev, res->start, size, ARCH_MEMREMAP_PMEM); |
42588958 DW |
323 | |
324 | return PTR_ERR_OR_ZERO(nsio->addr); | |
200c79da | 325 | } |
200c79da DW |
326 | |
327 | void devm_nsio_disable(struct device *dev, struct nd_namespace_io *nsio) | |
328 | { | |
329 | struct resource *res = &nsio->res; | |
330 | ||
331 | devm_memunmap(dev, nsio->addr); | |
332 | devm_exit_badblocks(dev, &nsio->bb); | |
8f4b01fc | 333 | devm_release_mem_region(dev, res->start, nsio->size); |
200c79da | 334 | } |