projects/linux·blob master · refs

363 lines · 8.8 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
4 */
5#include <linux/blkdev.h>
6#include <linux/device.h>
7#include <linux/sizes.h>
8#include <linux/slab.h>
9#include <linux/fs.h>
10#include <linux/mm.h>
11#include "nd-core.h"
12#include "btt.h"
13#include "nd.h"
14
15static void nd_btt_release(struct device *dev)
16{
17 struct nd_region *nd_region = to_nd_region(dev->parent);
18 struct nd_btt *nd_btt = to_nd_btt(dev);
19
20 dev_dbg(dev, "trace\n");
21 nd_detach_ndns(&nd_btt->dev, &nd_btt->ndns);
22 ida_free(&nd_region->btt_ida, nd_btt->id);
23 kfree(nd_btt->uuid);
24 kfree(nd_btt);
25}
26
27struct nd_btt *to_nd_btt(struct device *dev)
28{
29 struct nd_btt *nd_btt = container_of(dev, struct nd_btt, dev);
30
31 WARN_ON(!is_nd_btt(dev));
32 return nd_btt;
33}
34EXPORT_SYMBOL(to_nd_btt);
35
36static const unsigned long btt_lbasize_supported[] = { 512, 520, 528,
37 4096, 4104, 4160, 4224, 0 };
38
39static ssize_t sector_size_show(struct device *dev,
40 struct device_attribute *attr, char *buf)
41{
42 struct nd_btt *nd_btt = to_nd_btt(dev);
43
44 return nd_size_select_show(nd_btt->lbasize, btt_lbasize_supported, buf);
45}
46
47static ssize_t sector_size_store(struct device *dev,
48 struct device_attribute *attr, const char *buf, size_t len)
49{
50 struct nd_btt *nd_btt = to_nd_btt(dev);
51 ssize_t rc;
52
53 guard(device)(dev);
54 guard(nvdimm_bus)(dev);
55 rc = nd_size_select_store(dev, buf, &nd_btt->lbasize,
56 btt_lbasize_supported);
57 dev_dbg(dev, "result: %zd wrote: %s%s", rc, buf,
58 buf[len - 1] == '\n' ? "" : "\n");
59
60 return rc ? rc : len;
61}
62static DEVICE_ATTR_RW(sector_size);
63
64static ssize_t uuid_show(struct device *dev,
65 struct device_attribute *attr, char *buf)
66{
67 struct nd_btt *nd_btt = to_nd_btt(dev);
68
69 if (nd_btt->uuid)
70 return sprintf(buf, "%pUb\n", nd_btt->uuid);
71 return sprintf(buf, "\n");
72}
73
74static ssize_t uuid_store(struct device *dev,
75 struct device_attribute *attr, const char *buf, size_t len)
76{
77 struct nd_btt *nd_btt = to_nd_btt(dev);
78 ssize_t rc;
79
80 device_lock(dev);
81 rc = nd_uuid_store(dev, &nd_btt->uuid, buf, len);
82 dev_dbg(dev, "result: %zd wrote: %s%s", rc, buf,
83 buf[len - 1] == '\n' ? "" : "\n");
84 device_unlock(dev);
85
86 return rc ? rc : len;
87}
88static DEVICE_ATTR_RW(uuid);
89
90static ssize_t namespace_show(struct device *dev,
91 struct device_attribute *attr, char *buf)
92{
93 struct nd_btt *nd_btt = to_nd_btt(dev);
94
95 guard(nvdimm_bus)(dev);
96 return sprintf(buf, "%s\n", nd_btt->ndns
97 ? dev_name(&nd_btt->ndns->dev) : "");
98}
99
100static ssize_t namespace_store(struct device *dev,
101 struct device_attribute *attr, const char *buf, size_t len)
102{
103 struct nd_btt *nd_btt = to_nd_btt(dev);
104 ssize_t rc;
105
106 guard(device)(dev);
107 guard(nvdimm_bus)(dev);
108 rc = nd_namespace_store(dev, &nd_btt->ndns, buf, len);
109 dev_dbg(dev, "result: %zd wrote: %s%s", rc, buf,
110 buf[len - 1] == '\n' ? "" : "\n");
111
112 return rc;
113}
114static DEVICE_ATTR_RW(namespace);
115
116static ssize_t size_show(struct device *dev,
117 struct device_attribute *attr, char *buf)
118{
119 struct nd_btt *nd_btt = to_nd_btt(dev);
120 ssize_t rc;
121
122 device_lock(dev);
123 if (dev->driver)
124 rc = sprintf(buf, "%llu\n", nd_btt->size);
125 else {
126 /* no size to convey if the btt instance is disabled */
127 rc = -ENXIO;
128 }
129 device_unlock(dev);
130
131 return rc;
132}
133static DEVICE_ATTR_RO(size);
134
135static ssize_t log_zero_flags_show(struct device *dev,
136 struct device_attribute *attr, char *buf)
137{
138 return sprintf(buf, "Y\n");
139}
140static DEVICE_ATTR_RO(log_zero_flags);
141
142static struct attribute *nd_btt_attributes[] = {
143 &dev_attr_sector_size.attr,
144 &dev_attr_namespace.attr,
145 &dev_attr_uuid.attr,
146 &dev_attr_size.attr,
147 &dev_attr_log_zero_flags.attr,
148 NULL,
149};
150
151static struct attribute_group nd_btt_attribute_group = {
152 .attrs = nd_btt_attributes,
153};
154
155static const struct attribute_group *nd_btt_attribute_groups[] = {
156 &nd_btt_attribute_group,
157 &nd_device_attribute_group,
158 &nd_numa_attribute_group,
159 NULL,
160};
161
162static const struct device_type nd_btt_device_type = {
163 .name = "nd_btt",
164 .release = nd_btt_release,
165 .groups = nd_btt_attribute_groups,
166};
167
168bool is_nd_btt(struct device *dev)
169{
170 return dev->type == &nd_btt_device_type;
171}
172EXPORT_SYMBOL(is_nd_btt);
173
174static struct lock_class_key nvdimm_btt_key;
175
176static struct device *__nd_btt_create(struct nd_region *nd_region,
177 unsigned long lbasize, uuid_t *uuid,
178 struct nd_namespace_common *ndns)
179{
180 struct nd_btt *nd_btt;
181 struct device *dev;
182
183 nd_btt = kzalloc_obj(*nd_btt);
184 if (!nd_btt)
185 return NULL;
186
187 nd_btt->id = ida_alloc(&nd_region->btt_ida, GFP_KERNEL);
188 if (nd_btt->id < 0)
189 goto out_nd_btt;
190
191 nd_btt->lbasize = lbasize;
192 if (uuid) {
193 uuid = kmemdup(uuid, 16, GFP_KERNEL);
194 if (!uuid)
195 goto out_put_id;
196 }
197 nd_btt->uuid = uuid;
198 dev = &nd_btt->dev;
199 dev_set_name(dev, "btt%d.%d", nd_region->id, nd_btt->id);
200 dev->parent = &nd_region->dev;
201 dev->type = &nd_btt_device_type;
202 device_initialize(&nd_btt->dev);
203 lockdep_set_class(&nd_btt->dev.mutex, &nvdimm_btt_key);
204 if (ndns && !__nd_attach_ndns(&nd_btt->dev, ndns, &nd_btt->ndns)) {
205 dev_dbg(&ndns->dev, "failed, already claimed by %s\n",
206 dev_name(ndns->claim));
207 put_device(dev);
208 return NULL;
209 }
210 return dev;
211
212out_put_id:
213 ida_free(&nd_region->btt_ida, nd_btt->id);
214
215out_nd_btt:
216 kfree(nd_btt);
217 return NULL;
218}
219
220struct device *nd_btt_create(struct nd_region *nd_region)
221{
222 struct device *dev = __nd_btt_create(nd_region, 0, NULL, NULL);
223
224 nd_device_register(dev);
225 return dev;
226}
227
228/**
229 * nd_btt_arena_is_valid - check if the metadata layout is valid
230 * @nd_btt: device with BTT geometry and backing device info
231 * @super: pointer to the arena's info block being tested
232 *
233 * Check consistency of the btt info block with itself by validating
234 * the checksum, and with the parent namespace by verifying the
235 * parent_uuid contained in the info block with the one supplied in.
236 *
237 * Returns:
238 * false for an invalid info block, true for a valid one
239 */
240bool nd_btt_arena_is_valid(struct nd_btt *nd_btt, struct btt_sb *super)
241{
242 const uuid_t *ns_uuid = nd_dev_to_uuid(&nd_btt->ndns->dev);
243 uuid_t parent_uuid;
244 u64 checksum;
245
246 if (memcmp(super->signature, BTT_SIG, BTT_SIG_LEN) != 0)
247 return false;
248
249 import_uuid(&parent_uuid, super->parent_uuid);
250 if (!uuid_is_null(&parent_uuid))
251 if (!uuid_equal(&parent_uuid, ns_uuid))
252 return false;
253
254 checksum = le64_to_cpu(super->checksum);
255 super->checksum = 0;
256 if (checksum != nd_sb_checksum((struct nd_gen_sb *) super))
257 return false;
258 super->checksum = cpu_to_le64(checksum);
259
260 /* TODO: figure out action for this */
261 if ((le32_to_cpu(super->flags) & IB_FLAG_ERROR_MASK) != 0)
262 dev_info(&nd_btt->dev, "Found arena with an error flag\n");
263
264 return true;
265}
266EXPORT_SYMBOL(nd_btt_arena_is_valid);
267
268int nd_btt_version(struct nd_btt *nd_btt, struct nd_namespace_common *ndns,
269 struct btt_sb *btt_sb)
270{
271 if (ndns->claim_class == NVDIMM_CCLASS_BTT2) {
272 /* Probe/setup for BTT v2.0 */
273 nd_btt->initial_offset = 0;
274 nd_btt->version_major = 2;
275 nd_btt->version_minor = 0;
276 if (nvdimm_read_bytes(ndns, 0, btt_sb, sizeof(*btt_sb), 0))
277 return -ENXIO;
278 if (!nd_btt_arena_is_valid(nd_btt, btt_sb))
279 return -ENODEV;
280 if ((le16_to_cpu(btt_sb->version_major) != 2) ||
281 (le16_to_cpu(btt_sb->version_minor) != 0))
282 return -ENODEV;
283 } else {
284 /*
285 * Probe/setup for BTT v1.1 (NVDIMM_CCLASS_NONE or
286 * NVDIMM_CCLASS_BTT)
287 */
288 nd_btt->initial_offset = SZ_4K;
289 nd_btt->version_major = 1;
290 nd_btt->version_minor = 1;
291 if (nvdimm_read_bytes(ndns, SZ_4K, btt_sb, sizeof(*btt_sb), 0))
292 return -ENXIO;
293 if (!nd_btt_arena_is_valid(nd_btt, btt_sb))
294 return -ENODEV;
295 if ((le16_to_cpu(btt_sb->version_major) != 1) ||
296 (le16_to_cpu(btt_sb->version_minor) != 1))
297 return -ENODEV;
298 }
299 return 0;
300}
301EXPORT_SYMBOL(nd_btt_version);
302
303static int __nd_btt_probe(struct nd_btt *nd_btt,
304 struct nd_namespace_common *ndns, struct btt_sb *btt_sb)
305{
306 int rc;
307
308 if (!btt_sb || !ndns || !nd_btt)
309 return -ENODEV;
310
311 if (nvdimm_namespace_capacity(ndns) < SZ_16M)
312 return -ENXIO;
313
314 rc = nd_btt_version(nd_btt, ndns, btt_sb);
315 if (rc < 0)
316 return rc;
317
318 nd_btt->lbasize = le32_to_cpu(btt_sb->external_lbasize);
319 nd_btt->uuid = kmemdup(&btt_sb->uuid, sizeof(uuid_t), GFP_KERNEL);
320 if (!nd_btt->uuid)
321 return -ENOMEM;
322
323 nd_device_register(&nd_btt->dev);
324
325 return 0;
326}
327
328int nd_btt_probe(struct device *dev, struct nd_namespace_common *ndns)
329{
330 int rc;
331 struct device *btt_dev;
332 struct btt_sb *btt_sb;
333 struct nd_region *nd_region = to_nd_region(ndns->dev.parent);
334
335 if (ndns->force_raw)
336 return -ENODEV;
337
338 switch (ndns->claim_class) {
339 case NVDIMM_CCLASS_NONE:
340 case NVDIMM_CCLASS_BTT:
341 case NVDIMM_CCLASS_BTT2:
342 break;
343 default:
344 return -ENODEV;
345 }
346
347 scoped_guard(nvdimm_bus, &ndns->dev)
348 btt_dev = __nd_btt_create(nd_region, 0, NULL, ndns);
349 if (!btt_dev)
350 return -ENOMEM;
351 btt_sb = devm_kzalloc(dev, sizeof(*btt_sb), GFP_KERNEL);
352 rc = __nd_btt_probe(to_nd_btt(btt_dev), ndns, btt_sb);
353 dev_dbg(dev, "btt: %s\n", rc == 0 ? dev_name(btt_dev) : "<none>");
354 if (rc < 0) {
355 struct nd_btt *nd_btt = to_nd_btt(btt_dev);
356
357 nd_detach_ndns(btt_dev, &nd_btt->ndns);
358 put_device(btt_dev);
359 }
360
361 return rc;
362}
363EXPORT_SYMBOL(nd_btt_probe);