projects/linux·blob master · refs

608 lines · 14.5 KiB

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