2 * Copyright (c) 2014-2016 Christoph Hellwig.
4 #include <linux/sunrpc/svc.h>
5 #include <linux/blkdev.h>
6 #include <linux/nfs4.h>
7 #include <linux/nfs_fs.h>
8 #include <linux/nfs_xdr.h>
11 #include "blocklayout.h"
13 #define NFSDBG_FACILITY NFSDBG_PNFS_LD
16 bl_free_device(struct pnfs_block_dev *dev)
18 if (dev->nr_children) {
21 for (i = 0; i < dev->nr_children; i++)
22 bl_free_device(&dev->children[i]);
25 if (dev->pr_registered) {
26 const struct pr_ops *ops =
27 dev->bdev->bd_disk->fops->pr_ops;
30 error = ops->pr_register(dev->bdev, dev->pr_key, 0,
33 pr_err("failed to unregister PR key.\n");
37 blkdev_put(dev->bdev, FMODE_READ | FMODE_WRITE);
42 bl_free_deviceid_node(struct nfs4_deviceid_node *d)
44 struct pnfs_block_dev *dev =
45 container_of(d, struct pnfs_block_dev, node);
48 kfree_rcu(dev, node.rcu);
52 nfs4_block_decode_volume(struct xdr_stream *xdr, struct pnfs_block_volume *b)
57 p = xdr_inline_decode(xdr, 4);
60 b->type = be32_to_cpup(p++);
63 case PNFS_BLOCK_VOLUME_SIMPLE:
64 p = xdr_inline_decode(xdr, 4);
67 b->simple.nr_sigs = be32_to_cpup(p++);
68 if (!b->simple.nr_sigs) {
69 dprintk("no signature\n");
73 b->simple.len = 4 + 4;
74 for (i = 0; i < b->simple.nr_sigs; i++) {
75 p = xdr_inline_decode(xdr, 8 + 4);
78 p = xdr_decode_hyper(p, &b->simple.sigs[i].offset);
79 b->simple.sigs[i].sig_len = be32_to_cpup(p++);
80 if (b->simple.sigs[i].sig_len > PNFS_BLOCK_UUID_LEN) {
81 pr_info("signature too long: %d\n",
82 b->simple.sigs[i].sig_len);
86 p = xdr_inline_decode(xdr, b->simple.sigs[i].sig_len);
89 memcpy(&b->simple.sigs[i].sig, p,
90 b->simple.sigs[i].sig_len);
92 b->simple.len += 8 + 4 + \
93 (XDR_QUADLEN(b->simple.sigs[i].sig_len) << 2);
96 case PNFS_BLOCK_VOLUME_SLICE:
97 p = xdr_inline_decode(xdr, 8 + 8 + 4);
100 p = xdr_decode_hyper(p, &b->slice.start);
101 p = xdr_decode_hyper(p, &b->slice.len);
102 b->slice.volume = be32_to_cpup(p++);
104 case PNFS_BLOCK_VOLUME_CONCAT:
105 p = xdr_inline_decode(xdr, 4);
108 b->concat.volumes_count = be32_to_cpup(p++);
110 p = xdr_inline_decode(xdr, b->concat.volumes_count * 4);
113 for (i = 0; i < b->concat.volumes_count; i++)
114 b->concat.volumes[i] = be32_to_cpup(p++);
116 case PNFS_BLOCK_VOLUME_STRIPE:
117 p = xdr_inline_decode(xdr, 8 + 4);
120 p = xdr_decode_hyper(p, &b->stripe.chunk_size);
121 b->stripe.volumes_count = be32_to_cpup(p++);
123 p = xdr_inline_decode(xdr, b->stripe.volumes_count * 4);
126 for (i = 0; i < b->stripe.volumes_count; i++)
127 b->stripe.volumes[i] = be32_to_cpup(p++);
129 case PNFS_BLOCK_VOLUME_SCSI:
130 p = xdr_inline_decode(xdr, 4 + 4 + 4);
133 b->scsi.code_set = be32_to_cpup(p++);
134 b->scsi.designator_type = be32_to_cpup(p++);
135 b->scsi.designator_len = be32_to_cpup(p++);
136 p = xdr_inline_decode(xdr, b->scsi.designator_len);
139 if (b->scsi.designator_len > 256)
141 memcpy(&b->scsi.designator, p, b->scsi.designator_len);
142 p = xdr_inline_decode(xdr, 8);
145 p = xdr_decode_hyper(p, &b->scsi.pr_key);
148 dprintk("unknown volume type!\n");
155 static bool bl_map_simple(struct pnfs_block_dev *dev, u64 offset,
156 struct pnfs_block_dev_map *map)
158 map->start = dev->start;
160 map->disk_offset = dev->disk_offset;
161 map->bdev = dev->bdev;
165 static bool bl_map_concat(struct pnfs_block_dev *dev, u64 offset,
166 struct pnfs_block_dev_map *map)
170 for (i = 0; i < dev->nr_children; i++) {
171 struct pnfs_block_dev *child = &dev->children[i];
173 if (child->start > offset ||
174 child->start + child->len <= offset)
177 child->map(child, offset - child->start, map);
181 dprintk("%s: ran off loop!\n", __func__);
185 static bool bl_map_stripe(struct pnfs_block_dev *dev, u64 offset,
186 struct pnfs_block_dev_map *map)
188 struct pnfs_block_dev *child;
193 chunk = div_u64(offset, dev->chunk_size);
194 div_u64_rem(chunk, dev->nr_children, &chunk_idx);
196 if (chunk_idx > dev->nr_children) {
197 dprintk("%s: invalid chunk idx %d (%lld/%lld)\n",
198 __func__, chunk_idx, offset, dev->chunk_size);
199 /* error, should not happen */
203 /* truncate offset to the beginning of the stripe */
204 offset = chunk * dev->chunk_size;
206 /* disk offset of the stripe */
207 disk_offset = div_u64(offset, dev->nr_children);
209 child = &dev->children[chunk_idx];
210 child->map(child, disk_offset, map);
212 map->start += offset;
213 map->disk_offset += disk_offset;
214 map->len = dev->chunk_size;
219 bl_parse_deviceid(struct nfs_server *server, struct pnfs_block_dev *d,
220 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask);
224 bl_parse_simple(struct nfs_server *server, struct pnfs_block_dev *d,
225 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
227 struct pnfs_block_volume *v = &volumes[idx];
230 dev = bl_resolve_deviceid(server, v, gfp_mask);
234 d->bdev = blkdev_get_by_dev(dev, FMODE_READ | FMODE_WRITE, NULL);
235 if (IS_ERR(d->bdev)) {
236 printk(KERN_WARNING "pNFS: failed to open device %d:%d (%ld)\n",
237 MAJOR(dev), MINOR(dev), PTR_ERR(d->bdev));
238 return PTR_ERR(d->bdev);
242 d->len = i_size_read(d->bdev->bd_inode);
243 d->map = bl_map_simple;
245 printk(KERN_INFO "pNFS: using block device %s\n",
246 d->bdev->bd_disk->disk_name);
251 bl_validate_designator(struct pnfs_block_volume *v)
253 switch (v->scsi.designator_type) {
254 case PS_DESIGNATOR_EUI64:
255 if (v->scsi.code_set != PS_CODE_SET_BINARY)
258 if (v->scsi.designator_len != 8 &&
259 v->scsi.designator_len != 10 &&
260 v->scsi.designator_len != 16)
264 case PS_DESIGNATOR_NAA:
265 if (v->scsi.code_set != PS_CODE_SET_BINARY)
268 if (v->scsi.designator_len != 8 &&
269 v->scsi.designator_len != 16)
273 case PS_DESIGNATOR_T10:
274 case PS_DESIGNATOR_NAME:
275 pr_err("pNFS: unsupported designator "
276 "(code set %d, type %d, len %d.\n",
278 v->scsi.designator_type,
279 v->scsi.designator_len);
282 pr_err("pNFS: invalid designator "
283 "(code set %d, type %d, len %d.\n",
285 v->scsi.designator_type,
286 v->scsi.designator_len);
292 * Try to open the udev path for the WWN. At least on Debian the udev
293 * by-id path will always point to the dm-multipath device if one exists.
295 static struct block_device *
296 bl_open_udev_path(struct pnfs_block_volume *v)
298 struct block_device *bdev;
301 devname = kasprintf(GFP_KERNEL, "/dev/disk/by-id/wwn-0x%*phN",
302 v->scsi.designator_len, v->scsi.designator);
304 return ERR_PTR(-ENOMEM);
306 bdev = blkdev_get_by_path(devname, FMODE_READ | FMODE_WRITE, NULL);
308 pr_warn("pNFS: failed to open device %s (%ld)\n",
309 devname, PTR_ERR(bdev));
317 * Try to open the RH/Fedora specific dm-mpath udev path for this WWN, as the
318 * wwn- links will only point to the first discovered SCSI device there.
320 static struct block_device *
321 bl_open_dm_mpath_udev_path(struct pnfs_block_volume *v)
323 struct block_device *bdev;
326 devname = kasprintf(GFP_KERNEL,
327 "/dev/disk/by-id/dm-uuid-mpath-%d%*phN",
328 v->scsi.designator_type,
329 v->scsi.designator_len, v->scsi.designator);
331 return ERR_PTR(-ENOMEM);
333 bdev = blkdev_get_by_path(devname, FMODE_READ | FMODE_WRITE, NULL);
339 bl_parse_scsi(struct nfs_server *server, struct pnfs_block_dev *d,
340 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
342 struct pnfs_block_volume *v = &volumes[idx];
343 const struct pr_ops *ops;
346 if (!bl_validate_designator(v))
349 d->bdev = bl_open_dm_mpath_udev_path(v);
351 d->bdev = bl_open_udev_path(v);
353 return PTR_ERR(d->bdev);
355 d->len = i_size_read(d->bdev->bd_inode);
356 d->map = bl_map_simple;
357 d->pr_key = v->scsi.pr_key;
359 pr_info("pNFS: using block device %s (reservation key 0x%llx)\n",
360 d->bdev->bd_disk->disk_name, d->pr_key);
362 ops = d->bdev->bd_disk->fops->pr_ops;
364 pr_err("pNFS: block device %s does not support reservations.",
365 d->bdev->bd_disk->disk_name);
370 error = ops->pr_register(d->bdev, 0, d->pr_key, true);
372 pr_err("pNFS: failed to register key for block device %s.",
373 d->bdev->bd_disk->disk_name);
377 d->pr_registered = true;
381 blkdev_put(d->bdev, FMODE_READ | FMODE_WRITE);
386 bl_parse_slice(struct nfs_server *server, struct pnfs_block_dev *d,
387 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
389 struct pnfs_block_volume *v = &volumes[idx];
392 ret = bl_parse_deviceid(server, d, volumes, v->slice.volume, gfp_mask);
396 d->disk_offset = v->slice.start;
397 d->len = v->slice.len;
402 bl_parse_concat(struct nfs_server *server, struct pnfs_block_dev *d,
403 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
405 struct pnfs_block_volume *v = &volumes[idx];
409 d->children = kcalloc(v->concat.volumes_count,
410 sizeof(struct pnfs_block_dev), GFP_KERNEL);
414 for (i = 0; i < v->concat.volumes_count; i++) {
415 ret = bl_parse_deviceid(server, &d->children[i],
416 volumes, v->concat.volumes[i], gfp_mask);
421 d->children[i].start += len;
422 len += d->children[i].len;
426 d->map = bl_map_concat;
431 bl_parse_stripe(struct nfs_server *server, struct pnfs_block_dev *d,
432 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
434 struct pnfs_block_volume *v = &volumes[idx];
438 d->children = kcalloc(v->stripe.volumes_count,
439 sizeof(struct pnfs_block_dev), GFP_KERNEL);
443 for (i = 0; i < v->stripe.volumes_count; i++) {
444 ret = bl_parse_deviceid(server, &d->children[i],
445 volumes, v->stripe.volumes[i], gfp_mask);
450 len += d->children[i].len;
454 d->chunk_size = v->stripe.chunk_size;
455 d->map = bl_map_stripe;
460 bl_parse_deviceid(struct nfs_server *server, struct pnfs_block_dev *d,
461 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
463 switch (volumes[idx].type) {
464 case PNFS_BLOCK_VOLUME_SIMPLE:
465 return bl_parse_simple(server, d, volumes, idx, gfp_mask);
466 case PNFS_BLOCK_VOLUME_SLICE:
467 return bl_parse_slice(server, d, volumes, idx, gfp_mask);
468 case PNFS_BLOCK_VOLUME_CONCAT:
469 return bl_parse_concat(server, d, volumes, idx, gfp_mask);
470 case PNFS_BLOCK_VOLUME_STRIPE:
471 return bl_parse_stripe(server, d, volumes, idx, gfp_mask);
472 case PNFS_BLOCK_VOLUME_SCSI:
473 return bl_parse_scsi(server, d, volumes, idx, gfp_mask);
475 dprintk("unsupported volume type: %d\n", volumes[idx].type);
480 struct nfs4_deviceid_node *
481 bl_alloc_deviceid_node(struct nfs_server *server, struct pnfs_device *pdev,
484 struct nfs4_deviceid_node *node = NULL;
485 struct pnfs_block_volume *volumes;
486 struct pnfs_block_dev *top;
487 struct xdr_stream xdr;
489 struct page *scratch;
490 int nr_volumes, ret, i;
493 scratch = alloc_page(gfp_mask);
497 xdr_init_decode_pages(&xdr, &buf, pdev->pages, pdev->pglen);
498 xdr_set_scratch_buffer(&xdr, page_address(scratch), PAGE_SIZE);
500 p = xdr_inline_decode(&xdr, sizeof(__be32));
502 goto out_free_scratch;
503 nr_volumes = be32_to_cpup(p++);
505 volumes = kcalloc(nr_volumes, sizeof(struct pnfs_block_volume),
508 goto out_free_scratch;
510 for (i = 0; i < nr_volumes; i++) {
511 ret = nfs4_block_decode_volume(&xdr, &volumes[i]);
513 goto out_free_volumes;
516 top = kzalloc(sizeof(*top), gfp_mask);
518 goto out_free_volumes;
520 ret = bl_parse_deviceid(server, top, volumes, nr_volumes - 1, gfp_mask);
524 goto out_free_volumes;
528 nfs4_init_deviceid_node(node, server, &pdev->dev_id);
533 __free_page(scratch);