1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (c) 2014-2016 Christoph Hellwig.
4 */
5#include <linux/sunrpc/svc.h>
6#include <linux/blkdev.h>
7#include <linux/nfs4.h>
8#include <linux/nfs_fs.h>
9#include <linux/nfs_xdr.h>
10#include <linux/pr.h>
11
12#include "blocklayout.h"
13#include "../nfs4trace.h"
14
15#define NFSDBG_FACILITY NFSDBG_PNFS_LD
16
17static void bl_unregister_scsi(struct pnfs_block_dev *dev)
18{
19 struct block_device *bdev = file_bdev(bdev_file: dev->bdev_file);
20 const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
21 int status;
22
23 status = ops->pr_register(bdev, dev->pr_key, 0, false);
24 if (status)
25 trace_bl_pr_key_unreg_err(bdev, key: dev->pr_key, status);
26 else
27 trace_bl_pr_key_unreg(bdev, key: dev->pr_key);
28}
29
30static bool bl_register_scsi(struct pnfs_block_dev *dev)
31{
32 struct block_device *bdev = file_bdev(bdev_file: dev->bdev_file);
33 const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
34 int status;
35
36 if (test_and_set_bit(nr: PNFS_BDEV_REGISTERED, addr: &dev->flags))
37 return true;
38
39 status = ops->pr_register(bdev, 0, dev->pr_key, true);
40 if (status) {
41 trace_bl_pr_key_reg_err(bdev, key: dev->pr_key, status);
42 return false;
43 }
44 trace_bl_pr_key_reg(bdev, key: dev->pr_key);
45 return true;
46}
47
48static void bl_unregister_dev(struct pnfs_block_dev *dev)
49{
50 u32 i;
51
52 if (dev->nr_children) {
53 for (i = 0; i < dev->nr_children; i++)
54 bl_unregister_dev(dev: &dev->children[i]);
55 return;
56 }
57
58 if (dev->type == PNFS_BLOCK_VOLUME_SCSI &&
59 test_and_clear_bit(nr: PNFS_BDEV_REGISTERED, addr: &dev->flags))
60 bl_unregister_scsi(dev);
61}
62
63bool bl_register_dev(struct pnfs_block_dev *dev)
64{
65 u32 i;
66
67 if (dev->nr_children) {
68 for (i = 0; i < dev->nr_children; i++) {
69 if (!bl_register_dev(dev: &dev->children[i])) {
70 while (i > 0)
71 bl_unregister_dev(dev: &dev->children[--i]);
72 return false;
73 }
74 }
75 return true;
76 }
77
78 if (dev->type == PNFS_BLOCK_VOLUME_SCSI)
79 return bl_register_scsi(dev);
80 return true;
81}
82
83static void
84bl_free_device(struct pnfs_block_dev *dev)
85{
86 bl_unregister_dev(dev);
87
88 if (dev->nr_children) {
89 int i;
90
91 for (i = 0; i < dev->nr_children; i++)
92 bl_free_device(dev: &dev->children[i]);
93 kfree(objp: dev->children);
94 } else {
95 if (dev->bdev_file)
96 fput(dev->bdev_file);
97 }
98}
99
100void
101bl_free_deviceid_node(struct nfs4_deviceid_node *d)
102{
103 struct pnfs_block_dev *dev =
104 container_of(d, struct pnfs_block_dev, node);
105
106 bl_free_device(dev);
107 kfree_rcu(dev, node.rcu);
108}
109
110static int
111nfs4_block_decode_volume(struct xdr_stream *xdr, struct pnfs_block_volume *b)
112{
113 __be32 *p;
114 int i;
115
116 p = xdr_inline_decode(xdr, nbytes: 4);
117 if (!p)
118 return -EIO;
119 b->type = be32_to_cpup(p: p++);
120
121 switch (b->type) {
122 case PNFS_BLOCK_VOLUME_SIMPLE:
123 p = xdr_inline_decode(xdr, nbytes: 4);
124 if (!p)
125 return -EIO;
126 b->simple.nr_sigs = be32_to_cpup(p: p++);
127 if (!b->simple.nr_sigs || b->simple.nr_sigs > PNFS_BLOCK_MAX_UUIDS) {
128 dprintk("Bad signature count: %d\n", b->simple.nr_sigs);
129 return -EIO;
130 }
131
132 b->simple.len = 4 + 4;
133 for (i = 0; i < b->simple.nr_sigs; i++) {
134 p = xdr_inline_decode(xdr, nbytes: 8 + 4);
135 if (!p)
136 return -EIO;
137 p = xdr_decode_hyper(p, valp: &b->simple.sigs[i].offset);
138 b->simple.sigs[i].sig_len = be32_to_cpup(p: p++);
139 if (b->simple.sigs[i].sig_len > PNFS_BLOCK_UUID_LEN) {
140 pr_info("signature too long: %d\n",
141 b->simple.sigs[i].sig_len);
142 return -EIO;
143 }
144
145 p = xdr_inline_decode(xdr, nbytes: b->simple.sigs[i].sig_len);
146 if (!p)
147 return -EIO;
148 memcpy(&b->simple.sigs[i].sig, p,
149 b->simple.sigs[i].sig_len);
150
151 b->simple.len += 8 + 4 + \
152 (XDR_QUADLEN(b->simple.sigs[i].sig_len) << 2);
153 }
154 break;
155 case PNFS_BLOCK_VOLUME_SLICE:
156 p = xdr_inline_decode(xdr, nbytes: 8 + 8 + 4);
157 if (!p)
158 return -EIO;
159 p = xdr_decode_hyper(p, valp: &b->slice.start);
160 p = xdr_decode_hyper(p, valp: &b->slice.len);
161 b->slice.volume = be32_to_cpup(p: p++);
162 break;
163 case PNFS_BLOCK_VOLUME_CONCAT:
164 p = xdr_inline_decode(xdr, nbytes: 4);
165 if (!p)
166 return -EIO;
167
168 b->concat.volumes_count = be32_to_cpup(p: p++);
169 if (b->concat.volumes_count > PNFS_BLOCK_MAX_DEVICES) {
170 dprintk("Too many volumes: %d\n", b->concat.volumes_count);
171 return -EIO;
172 }
173
174 p = xdr_inline_decode(xdr, nbytes: b->concat.volumes_count * 4);
175 if (!p)
176 return -EIO;
177 for (i = 0; i < b->concat.volumes_count; i++)
178 b->concat.volumes[i] = be32_to_cpup(p: p++);
179 break;
180 case PNFS_BLOCK_VOLUME_STRIPE:
181 p = xdr_inline_decode(xdr, nbytes: 8 + 4);
182 if (!p)
183 return -EIO;
184
185 p = xdr_decode_hyper(p, valp: &b->stripe.chunk_size);
186 b->stripe.volumes_count = be32_to_cpup(p: p++);
187 if (b->stripe.volumes_count > PNFS_BLOCK_MAX_DEVICES) {
188 dprintk("Too many volumes: %d\n", b->stripe.volumes_count);
189 return -EIO;
190 }
191
192 p = xdr_inline_decode(xdr, nbytes: b->stripe.volumes_count * 4);
193 if (!p)
194 return -EIO;
195 for (i = 0; i < b->stripe.volumes_count; i++)
196 b->stripe.volumes[i] = be32_to_cpup(p: p++);
197 break;
198 case PNFS_BLOCK_VOLUME_SCSI:
199 p = xdr_inline_decode(xdr, nbytes: 4 + 4 + 4);
200 if (!p)
201 return -EIO;
202 b->scsi.code_set = be32_to_cpup(p: p++);
203 b->scsi.designator_type = be32_to_cpup(p: p++);
204 b->scsi.designator_len = be32_to_cpup(p: p++);
205 p = xdr_inline_decode(xdr, nbytes: b->scsi.designator_len);
206 if (!p)
207 return -EIO;
208 if (b->scsi.designator_len > 256)
209 return -EIO;
210 memcpy(&b->scsi.designator, p, b->scsi.designator_len);
211 p = xdr_inline_decode(xdr, nbytes: 8);
212 if (!p)
213 return -EIO;
214 p = xdr_decode_hyper(p, valp: &b->scsi.pr_key);
215 break;
216 default:
217 dprintk("unknown volume type!\n");
218 return -EIO;
219 }
220
221 return 0;
222}
223
224static bool bl_map_simple(struct pnfs_block_dev *dev, u64 offset,
225 struct pnfs_block_dev_map *map)
226{
227 map->start = dev->start;
228 map->len = dev->len;
229 map->disk_offset = dev->disk_offset;
230 map->bdev = file_bdev(bdev_file: dev->bdev_file);
231 return true;
232}
233
234static bool bl_map_concat(struct pnfs_block_dev *dev, u64 offset,
235 struct pnfs_block_dev_map *map)
236{
237 int i;
238
239 for (i = 0; i < dev->nr_children; i++) {
240 struct pnfs_block_dev *child = &dev->children[i];
241
242 if (child->start > offset ||
243 child->start + child->len <= offset)
244 continue;
245
246 child->map(child, offset - child->start, map);
247 return true;
248 }
249
250 dprintk("%s: ran off loop!\n", __func__);
251 return false;
252}
253
254static bool bl_map_stripe(struct pnfs_block_dev *dev, u64 offset,
255 struct pnfs_block_dev_map *map)
256{
257 struct pnfs_block_dev *child;
258 u64 chunk;
259 u32 chunk_idx;
260 u64 disk_chunk;
261 u64 disk_offset;
262
263 chunk = div_u64(dividend: offset, divisor: dev->chunk_size);
264 disk_chunk = div_u64_rem(dividend: chunk, divisor: dev->nr_children, remainder: &chunk_idx);
265
266 if (chunk_idx >= dev->nr_children) {
267 dprintk("%s: invalid chunk idx %d (%lld/%lld)\n",
268 __func__, chunk_idx, offset, dev->chunk_size);
269 /* error, should not happen */
270 return false;
271 }
272
273 /* truncate offset to the beginning of the stripe */
274 offset = chunk * dev->chunk_size;
275
276 /* disk offset of the stripe */
277 disk_offset = disk_chunk * dev->chunk_size;
278
279 child = &dev->children[chunk_idx];
280 child->map(child, disk_offset, map);
281
282 map->start += offset;
283 map->disk_offset += disk_offset;
284 map->len = dev->chunk_size;
285 return true;
286}
287
288static int
289bl_parse_deviceid(struct nfs_server *server, struct pnfs_block_dev *d,
290 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask);
291
292
293static int
294bl_parse_simple(struct nfs_server *server, struct pnfs_block_dev *d,
295 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
296{
297 struct pnfs_block_volume *v = &volumes[idx];
298 struct file *bdev_file;
299 dev_t dev;
300
301 dev = bl_resolve_deviceid(server, b: v, gfp_mask);
302 if (!dev)
303 return -EIO;
304
305 bdev_file = bdev_file_open_by_dev(dev, BLK_OPEN_READ | BLK_OPEN_WRITE,
306 NULL, NULL);
307 if (IS_ERR(ptr: bdev_file)) {
308 printk(KERN_WARNING "pNFS: failed to open device %d:%d (%ld)\n",
309 MAJOR(dev), MINOR(dev), PTR_ERR(bdev_file));
310 return PTR_ERR(ptr: bdev_file);
311 }
312 d->bdev_file = bdev_file;
313 d->len = bdev_nr_bytes(bdev: file_bdev(bdev_file));
314 d->map = bl_map_simple;
315
316 printk(KERN_INFO "pNFS: using block device %s\n",
317 file_bdev(bdev_file)->bd_disk->disk_name);
318 return 0;
319}
320
321static bool
322bl_validate_designator(struct pnfs_block_volume *v)
323{
324 switch (v->scsi.designator_type) {
325 case PS_DESIGNATOR_EUI64:
326 if (v->scsi.code_set != PS_CODE_SET_BINARY)
327 return false;
328
329 if (v->scsi.designator_len != 8 &&
330 v->scsi.designator_len != 10 &&
331 v->scsi.designator_len != 16)
332 return false;
333
334 return true;
335 case PS_DESIGNATOR_NAA:
336 if (v->scsi.code_set != PS_CODE_SET_BINARY)
337 return false;
338
339 if (v->scsi.designator_len != 8 &&
340 v->scsi.designator_len != 16)
341 return false;
342
343 return true;
344 case PS_DESIGNATOR_T10:
345 case PS_DESIGNATOR_NAME:
346 pr_err("pNFS: unsupported designator "
347 "(code set %d, type %d, len %d.\n",
348 v->scsi.code_set,
349 v->scsi.designator_type,
350 v->scsi.designator_len);
351 return false;
352 default:
353 pr_err("pNFS: invalid designator "
354 "(code set %d, type %d, len %d.\n",
355 v->scsi.code_set,
356 v->scsi.designator_type,
357 v->scsi.designator_len);
358 return false;
359 }
360}
361
362static struct file *
363bl_open_path(struct pnfs_block_volume *v, const char *prefix)
364{
365 struct file *bdev_file;
366 const char *devname;
367
368 devname = kasprintf(GFP_KERNEL, fmt: "/dev/disk/by-id/%s%*phN",
369 prefix, v->scsi.designator_len, v->scsi.designator);
370 if (!devname)
371 return ERR_PTR(error: -ENOMEM);
372
373 bdev_file = bdev_file_open_by_path(path: devname, BLK_OPEN_READ | BLK_OPEN_WRITE,
374 NULL, NULL);
375 if (IS_ERR(ptr: bdev_file)) {
376 dprintk("failed to open device %s (%ld)\n",
377 devname, PTR_ERR(bdev_file));
378 }
379
380 kfree(objp: devname);
381 return bdev_file;
382}
383
384static int
385bl_parse_scsi(struct nfs_server *server, struct pnfs_block_dev *d,
386 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
387{
388 struct pnfs_block_volume *v = &volumes[idx];
389 struct block_device *bdev;
390 const struct pr_ops *ops;
391 struct file *bdev_file;
392 int error;
393
394 if (!bl_validate_designator(v))
395 return -EINVAL;
396
397 /*
398 * Try to open the RH/Fedora specific dm-mpath udev path first, as the
399 * wwn- links will only point to the first discovered SCSI device there.
400 * On other distributions like Debian, the default SCSI by-id path will
401 * point to the dm-multipath device if one exists.
402 */
403 bdev_file = bl_open_path(v, prefix: "dm-uuid-mpath-0x");
404 if (IS_ERR(ptr: bdev_file))
405 bdev_file = bl_open_path(v, prefix: "wwn-0x");
406 if (IS_ERR(ptr: bdev_file))
407 bdev_file = bl_open_path(v, prefix: "nvme-eui.");
408 if (IS_ERR(ptr: bdev_file)) {
409 pr_warn("pNFS: no device found for volume %*phN\n",
410 v->scsi.designator_len, v->scsi.designator);
411 return PTR_ERR(ptr: bdev_file);
412 }
413 d->bdev_file = bdev_file;
414 bdev = file_bdev(bdev_file);
415
416 d->len = bdev_nr_bytes(bdev);
417 d->map = bl_map_simple;
418 d->pr_key = v->scsi.pr_key;
419
420 if (d->len == 0) {
421 error = -ENODEV;
422 goto out_blkdev_put;
423 }
424
425 ops = bdev->bd_disk->fops->pr_ops;
426 if (!ops) {
427 pr_err("pNFS: block device %s does not support reservations.",
428 bdev->bd_disk->disk_name);
429 error = -EINVAL;
430 goto out_blkdev_put;
431 }
432
433 return 0;
434
435out_blkdev_put:
436 fput(d->bdev_file);
437 return error;
438}
439
440static int
441bl_parse_slice(struct nfs_server *server, struct pnfs_block_dev *d,
442 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
443{
444 struct pnfs_block_volume *v = &volumes[idx];
445 int ret;
446
447 ret = bl_parse_deviceid(server, d, volumes, idx: v->slice.volume, gfp_mask);
448 if (ret)
449 return ret;
450
451 d->disk_offset = v->slice.start;
452 d->len = v->slice.len;
453 return 0;
454}
455
456static int
457bl_parse_concat(struct nfs_server *server, struct pnfs_block_dev *d,
458 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
459{
460 struct pnfs_block_volume *v = &volumes[idx];
461 u64 len = 0;
462 int ret, i;
463
464 d->children = kcalloc(v->concat.volumes_count,
465 sizeof(struct pnfs_block_dev), gfp_mask);
466 if (!d->children)
467 return -ENOMEM;
468
469 for (i = 0; i < v->concat.volumes_count; i++) {
470 ret = bl_parse_deviceid(server, d: &d->children[i],
471 volumes, idx: v->concat.volumes[i], gfp_mask);
472 if (ret)
473 return ret;
474
475 d->nr_children++;
476 d->children[i].start += len;
477 len += d->children[i].len;
478 }
479
480 d->len = len;
481 d->map = bl_map_concat;
482 return 0;
483}
484
485static int
486bl_parse_stripe(struct nfs_server *server, struct pnfs_block_dev *d,
487 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
488{
489 struct pnfs_block_volume *v = &volumes[idx];
490 u64 len = 0;
491 int ret, i;
492
493 d->children = kcalloc(v->stripe.volumes_count,
494 sizeof(struct pnfs_block_dev), gfp_mask);
495 if (!d->children)
496 return -ENOMEM;
497
498 for (i = 0; i < v->stripe.volumes_count; i++) {
499 ret = bl_parse_deviceid(server, d: &d->children[i],
500 volumes, idx: v->stripe.volumes[i], gfp_mask);
501 if (ret)
502 return ret;
503
504 d->nr_children++;
505 len += d->children[i].len;
506 }
507
508 d->len = len;
509 d->chunk_size = v->stripe.chunk_size;
510 d->map = bl_map_stripe;
511 return 0;
512}
513
514static int
515bl_parse_deviceid(struct nfs_server *server, struct pnfs_block_dev *d,
516 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
517{
518 d->type = volumes[idx].type;
519
520 switch (d->type) {
521 case PNFS_BLOCK_VOLUME_SIMPLE:
522 return bl_parse_simple(server, d, volumes, idx, gfp_mask);
523 case PNFS_BLOCK_VOLUME_SLICE:
524 return bl_parse_slice(server, d, volumes, idx, gfp_mask);
525 case PNFS_BLOCK_VOLUME_CONCAT:
526 return bl_parse_concat(server, d, volumes, idx, gfp_mask);
527 case PNFS_BLOCK_VOLUME_STRIPE:
528 return bl_parse_stripe(server, d, volumes, idx, gfp_mask);
529 case PNFS_BLOCK_VOLUME_SCSI:
530 return bl_parse_scsi(server, d, volumes, idx, gfp_mask);
531 default:
532 dprintk("unsupported volume type: %d\n", d->type);
533 return -EIO;
534 }
535}
536
537struct nfs4_deviceid_node *
538bl_alloc_deviceid_node(struct nfs_server *server, struct pnfs_device *pdev,
539 gfp_t gfp_mask)
540{
541 struct nfs4_deviceid_node *node = NULL;
542 struct pnfs_block_volume *volumes;
543 struct pnfs_block_dev *top;
544 struct xdr_stream xdr;
545 struct xdr_buf buf;
546 struct folio *scratch;
547 int nr_volumes, ret, i;
548 __be32 *p;
549
550 scratch = folio_alloc(gfp_mask, 0);
551 if (!scratch)
552 goto out;
553
554 xdr_init_decode_pages(xdr: &xdr, buf: &buf, pages: pdev->pages, len: pdev->pglen);
555 xdr_set_scratch_folio(xdr: &xdr, folio: scratch);
556
557 p = xdr_inline_decode(xdr: &xdr, nbytes: sizeof(__be32));
558 if (!p)
559 goto out_free_scratch;
560 nr_volumes = be32_to_cpup(p: p++);
561
562 volumes = kcalloc(nr_volumes, sizeof(struct pnfs_block_volume),
563 gfp_mask);
564 if (!volumes)
565 goto out_free_scratch;
566
567 for (i = 0; i < nr_volumes; i++) {
568 ret = nfs4_block_decode_volume(xdr: &xdr, b: &volumes[i]);
569 if (ret < 0)
570 goto out_free_volumes;
571 }
572
573 top = kzalloc(sizeof(*top), gfp_mask);
574 if (!top)
575 goto out_free_volumes;
576
577 ret = bl_parse_deviceid(server, d: top, volumes, idx: nr_volumes - 1, gfp_mask);
578
579 node = &top->node;
580 nfs4_init_deviceid_node(node, server, &pdev->dev_id);
581 if (ret)
582 nfs4_mark_deviceid_unavailable(node);
583
584out_free_volumes:
585 kfree(objp: volumes);
586out_free_scratch:
587 folio_put(folio: scratch);
588out:
589 return node;
590}
591

source code of linux/fs/nfs/blocklayout/dev.c