2 * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
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.
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.
13 #include <linux/blkdev.h>
14 #include <linux/device.h>
15 #include <linux/genhd.h>
16 #include <linux/sizes.h>
17 #include <linux/slab.h>
24 static void __nd_btt_detach_ndns(struct nd_btt
*nd_btt
)
26 struct nd_namespace_common
*ndns
= nd_btt
->ndns
;
28 dev_WARN_ONCE(&nd_btt
->dev
, !mutex_is_locked(&ndns
->dev
.mutex
)
29 || ndns
->claim
!= &nd_btt
->dev
,
30 "%s: invalid claim\n", __func__
);
33 put_device(&ndns
->dev
);
36 static void nd_btt_detach_ndns(struct nd_btt
*nd_btt
)
38 struct nd_namespace_common
*ndns
= nd_btt
->ndns
;
42 get_device(&ndns
->dev
);
43 device_lock(&ndns
->dev
);
44 __nd_btt_detach_ndns(nd_btt
);
45 device_unlock(&ndns
->dev
);
46 put_device(&ndns
->dev
);
49 static bool __nd_btt_attach_ndns(struct nd_btt
*nd_btt
,
50 struct nd_namespace_common
*ndns
)
54 dev_WARN_ONCE(&nd_btt
->dev
, !mutex_is_locked(&ndns
->dev
.mutex
)
56 "%s: invalid claim\n", __func__
);
57 ndns
->claim
= &nd_btt
->dev
;
59 get_device(&ndns
->dev
);
63 static bool nd_btt_attach_ndns(struct nd_btt
*nd_btt
,
64 struct nd_namespace_common
*ndns
)
68 device_lock(&ndns
->dev
);
69 claimed
= __nd_btt_attach_ndns(nd_btt
, ndns
);
70 device_unlock(&ndns
->dev
);
74 static void nd_btt_release(struct device
*dev
)
76 struct nd_region
*nd_region
= to_nd_region(dev
->parent
);
77 struct nd_btt
*nd_btt
= to_nd_btt(dev
);
79 dev_dbg(dev
, "%s\n", __func__
);
80 nd_btt_detach_ndns(nd_btt
);
81 ida_simple_remove(&nd_region
->btt_ida
, nd_btt
->id
);
86 static struct device_type nd_btt_device_type
= {
88 .release
= nd_btt_release
,
91 bool is_nd_btt(struct device
*dev
)
93 return dev
->type
== &nd_btt_device_type
;
95 EXPORT_SYMBOL(is_nd_btt
);
97 struct nd_btt
*to_nd_btt(struct device
*dev
)
99 struct nd_btt
*nd_btt
= container_of(dev
, struct nd_btt
, dev
);
101 WARN_ON(!is_nd_btt(dev
));
104 EXPORT_SYMBOL(to_nd_btt
);
106 static const unsigned long btt_lbasize_supported
[] = { 512, 520, 528,
107 4096, 4104, 4160, 4224, 0 };
109 static ssize_t
sector_size_show(struct device
*dev
,
110 struct device_attribute
*attr
, char *buf
)
112 struct nd_btt
*nd_btt
= to_nd_btt(dev
);
114 return nd_sector_size_show(nd_btt
->lbasize
, btt_lbasize_supported
, buf
);
117 static ssize_t
sector_size_store(struct device
*dev
,
118 struct device_attribute
*attr
, const char *buf
, size_t len
)
120 struct nd_btt
*nd_btt
= to_nd_btt(dev
);
124 nvdimm_bus_lock(dev
);
125 rc
= nd_sector_size_store(dev
, buf
, &nd_btt
->lbasize
,
126 btt_lbasize_supported
);
127 dev_dbg(dev
, "%s: result: %zd wrote: %s%s", __func__
,
128 rc
, buf
, buf
[len
- 1] == '\n' ? "" : "\n");
129 nvdimm_bus_unlock(dev
);
132 return rc
? rc
: len
;
134 static DEVICE_ATTR_RW(sector_size
);
136 static ssize_t
uuid_show(struct device
*dev
,
137 struct device_attribute
*attr
, char *buf
)
139 struct nd_btt
*nd_btt
= to_nd_btt(dev
);
142 return sprintf(buf
, "%pUb\n", nd_btt
->uuid
);
143 return sprintf(buf
, "\n");
146 static ssize_t
uuid_store(struct device
*dev
,
147 struct device_attribute
*attr
, const char *buf
, size_t len
)
149 struct nd_btt
*nd_btt
= to_nd_btt(dev
);
153 rc
= nd_uuid_store(dev
, &nd_btt
->uuid
, buf
, len
);
154 dev_dbg(dev
, "%s: result: %zd wrote: %s%s", __func__
,
155 rc
, buf
, buf
[len
- 1] == '\n' ? "" : "\n");
158 return rc
? rc
: len
;
160 static DEVICE_ATTR_RW(uuid
);
162 static ssize_t
namespace_show(struct device
*dev
,
163 struct device_attribute
*attr
, char *buf
)
165 struct nd_btt
*nd_btt
= to_nd_btt(dev
);
168 nvdimm_bus_lock(dev
);
169 rc
= sprintf(buf
, "%s\n", nd_btt
->ndns
170 ? dev_name(&nd_btt
->ndns
->dev
) : "");
171 nvdimm_bus_unlock(dev
);
175 static int namespace_match(struct device
*dev
, void *data
)
179 return strcmp(name
, dev_name(dev
)) == 0;
182 static bool is_nd_btt_idle(struct device
*dev
)
184 struct nd_region
*nd_region
= to_nd_region(dev
->parent
);
185 struct nd_btt
*nd_btt
= to_nd_btt(dev
);
187 if (nd_region
->btt_seed
== dev
|| nd_btt
->ndns
|| dev
->driver
)
192 static ssize_t
__namespace_store(struct device
*dev
,
193 struct device_attribute
*attr
, const char *buf
, size_t len
)
195 struct nd_btt
*nd_btt
= to_nd_btt(dev
);
196 struct nd_namespace_common
*ndns
;
197 struct device
*found
;
201 dev_dbg(dev
, "%s: -EBUSY\n", __func__
);
205 name
= kstrndup(buf
, len
, GFP_KERNEL
);
210 if (strncmp(name
, "namespace", 9) == 0 || strcmp(name
, "") == 0)
218 if (strcmp(name
, "") == 0) {
219 /* detach the namespace and destroy / reset the btt device */
220 nd_btt_detach_ndns(nd_btt
);
221 if (is_nd_btt_idle(dev
))
222 nd_device_unregister(dev
, ND_ASYNC
);
230 dev_dbg(dev
, "namespace already set to: %s\n",
231 dev_name(&ndns
->dev
));
236 found
= device_find_child(dev
->parent
, name
, namespace_match
);
238 dev_dbg(dev
, "'%s' not found under %s\n", name
,
239 dev_name(dev
->parent
));
244 ndns
= to_ndns(found
);
245 if (__nvdimm_namespace_capacity(ndns
) < SZ_16M
) {
246 dev_dbg(dev
, "%s too small to host btt\n", name
);
251 WARN_ON_ONCE(!is_nvdimm_bus_locked(&nd_btt
->dev
));
252 if (!nd_btt_attach_ndns(nd_btt
, ndns
)) {
253 dev_dbg(dev
, "%s already claimed\n",
254 dev_name(&ndns
->dev
));
259 put_device(&ndns
->dev
); /* from device_find_child */
265 static ssize_t
namespace_store(struct device
*dev
,
266 struct device_attribute
*attr
, const char *buf
, size_t len
)
270 nvdimm_bus_lock(dev
);
272 rc
= __namespace_store(dev
, attr
, buf
, len
);
273 dev_dbg(dev
, "%s: result: %zd wrote: %s%s", __func__
,
274 rc
, buf
, buf
[len
- 1] == '\n' ? "" : "\n");
276 nvdimm_bus_unlock(dev
);
280 static DEVICE_ATTR_RW(namespace);
282 static struct attribute
*nd_btt_attributes
[] = {
283 &dev_attr_sector_size
.attr
,
284 &dev_attr_namespace
.attr
,
289 static struct attribute_group nd_btt_attribute_group
= {
290 .attrs
= nd_btt_attributes
,
293 static const struct attribute_group
*nd_btt_attribute_groups
[] = {
294 &nd_btt_attribute_group
,
295 &nd_device_attribute_group
,
296 &nd_numa_attribute_group
,
300 static struct device
*__nd_btt_create(struct nd_region
*nd_region
,
301 unsigned long lbasize
, u8
*uuid
,
302 struct nd_namespace_common
*ndns
)
304 struct nd_btt
*nd_btt
;
307 nd_btt
= kzalloc(sizeof(*nd_btt
), GFP_KERNEL
);
311 nd_btt
->id
= ida_simple_get(&nd_region
->btt_ida
, 0, 0, GFP_KERNEL
);
312 if (nd_btt
->id
< 0) {
317 nd_btt
->lbasize
= lbasize
;
319 uuid
= kmemdup(uuid
, 16, GFP_KERNEL
);
322 dev_set_name(dev
, "btt%d.%d", nd_region
->id
, nd_btt
->id
);
323 dev
->parent
= &nd_region
->dev
;
324 dev
->type
= &nd_btt_device_type
;
325 dev
->groups
= nd_btt_attribute_groups
;
326 device_initialize(&nd_btt
->dev
);
327 if (ndns
&& !__nd_btt_attach_ndns(nd_btt
, ndns
)) {
328 dev_dbg(&ndns
->dev
, "%s failed, already claimed by %s\n",
329 __func__
, dev_name(ndns
->claim
));
336 struct device
*nd_btt_create(struct nd_region
*nd_region
)
338 struct device
*dev
= __nd_btt_create(nd_region
, 0, NULL
, NULL
);
341 __nd_device_register(dev
);
346 * nd_btt_sb_checksum: compute checksum for btt info block
348 * Returns a fletcher64 checksum of everything in the given info block
349 * except the last field (since that's where the checksum lives).
351 u64
nd_btt_sb_checksum(struct btt_sb
*btt_sb
)
356 sum_save
= btt_sb
->checksum
;
357 btt_sb
->checksum
= 0;
358 sum
= nd_fletcher64(btt_sb
, sizeof(*btt_sb
), 1);
359 btt_sb
->checksum
= sum_save
;
362 EXPORT_SYMBOL(nd_btt_sb_checksum
);
364 static int __nd_btt_probe(struct nd_btt
*nd_btt
,
365 struct nd_namespace_common
*ndns
, struct btt_sb
*btt_sb
)
369 if (!btt_sb
|| !ndns
|| !nd_btt
)
372 if (nvdimm_read_bytes(ndns
, SZ_4K
, btt_sb
, sizeof(*btt_sb
)))
375 if (nvdimm_namespace_capacity(ndns
) < SZ_16M
)
378 if (memcmp(btt_sb
->signature
, BTT_SIG
, BTT_SIG_LEN
) != 0)
381 checksum
= le64_to_cpu(btt_sb
->checksum
);
382 btt_sb
->checksum
= 0;
383 if (checksum
!= nd_btt_sb_checksum(btt_sb
))
385 btt_sb
->checksum
= cpu_to_le64(checksum
);
387 nd_btt
->lbasize
= le32_to_cpu(btt_sb
->external_lbasize
);
388 nd_btt
->uuid
= kmemdup(btt_sb
->uuid
, 16, GFP_KERNEL
);
392 __nd_device_register(&nd_btt
->dev
);
397 int nd_btt_probe(struct nd_namespace_common
*ndns
, void *drvdata
)
401 struct btt_sb
*btt_sb
;
402 struct nd_region
*nd_region
= to_nd_region(ndns
->dev
.parent
);
407 nvdimm_bus_lock(&ndns
->dev
);
408 dev
= __nd_btt_create(nd_region
, 0, NULL
, ndns
);
409 nvdimm_bus_unlock(&ndns
->dev
);
412 dev_set_drvdata(dev
, drvdata
);
413 btt_sb
= kzalloc(sizeof(*btt_sb
), GFP_KERNEL
);
414 rc
= __nd_btt_probe(to_nd_btt(dev
), ndns
, btt_sb
);
416 dev_dbg(&ndns
->dev
, "%s: btt: %s\n", __func__
,
417 rc
== 0 ? dev_name(dev
) : "<none>");
419 __nd_btt_detach_ndns(to_nd_btt(dev
));
425 EXPORT_SYMBOL(nd_btt_probe
);