fs/nfs/blocklayout/dev.c

   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
  17 static void bl_unregister_scsi(struct pnfs_block_dev *dev)
  18 {
  19         struct block_device *bdev = file_bdev(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, dev->pr_key, status);
  26         else
  27                 trace_bl_pr_key_unreg(bdev, dev->pr_key);
  28 }
  29
  30 static bool bl_register_scsi(struct pnfs_block_dev *dev)
  31 {
  32         struct block_device *bdev = file_bdev(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(PNFS_BDEV_REGISTERED, &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, dev->pr_key, status);
  42                 return false;
  43         }
  44         trace_bl_pr_key_reg(bdev, dev->pr_key);
  45         return true;
  46 }
  47
  48 static 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->children[i]);
  55                 return;
  56         }
  57
  58         if (dev->type == PNFS_BLOCK_VOLUME_SCSI &&
  59                 test_and_clear_bit(PNFS_BDEV_REGISTERED, &dev->flags))
  60                 bl_unregister_scsi(dev);
  61 }
  62
  63 bool 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->children[i])) {
  70                                 while (i > 0)
  71                                         bl_unregister_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
  83 static void
  84 bl_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->children[i]);
  93                 kfree(dev->children);
  94         } else {
  95                 if (dev->bdev_file)
  96                         fput(dev->bdev_file);
  97         }
  98 }
  99
 100 void
 101 bl_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
 110 static int
 111 nfs4_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, 4);
 117         if (!p)
 118                 return -EIO;
 119         b->type = be32_to_cpup(p++);
 120
 121         switch (b->type) {
 122         case PNFS_BLOCK_VOLUME_SIMPLE:
 123                 p = xdr_inline_decode(xdr, 4);
 124                 if (!p)
 125                         return -EIO;
 126                 b->simple.nr_sigs = be32_to_cpup(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, 8 + 4);
 135                         if (!p)
 136                                 return -EIO;
 137                         p = xdr_decode_hyper(p, &b->simple.sigs[i].offset);
 138                         b->simple.sigs[i].sig_len = be32_to_cpup(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, 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, 8 + 8 + 4);
 157                 if (!p)
 158                         return -EIO;
 159                 p = xdr_decode_hyper(p, &b->slice.start);
 160                 p = xdr_decode_hyper(p, &b->slice.len);
 161                 b->slice.volume = be32_to_cpup(p++);
 162                 break;
 163         case PNFS_BLOCK_VOLUME_CONCAT:
 164                 p = xdr_inline_decode(xdr, 4);
 165                 if (!p)
 166                         return -EIO;
 167
 168                 b->concat.volumes_count = be32_to_cpup(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, 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++);
 179                 break;
 180         case PNFS_BLOCK_VOLUME_STRIPE:
 181                 p = xdr_inline_decode(xdr, 8 + 4);
 182                 if (!p)
 183                         return -EIO;
 184
 185                 p = xdr_decode_hyper(p, &b->stripe.chunk_size);
 186                 b->stripe.volumes_count = be32_to_cpup(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, 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++);
 197                 break;
 198         case PNFS_BLOCK_VOLUME_SCSI:
 199                 p = xdr_inline_decode(xdr, 4 + 4 + 4);
 200                 if (!p)
 201                         return -EIO;
 202                 b->scsi.code_set = be32_to_cpup(p++);
 203                 b->scsi.designator_type = be32_to_cpup(p++);
 204                 b->scsi.designator_len = be32_to_cpup(p++);
 205                 p = xdr_inline_decode(xdr, 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, 8);
 212                 if (!p)
 213                         return -EIO;
 214                 p = xdr_decode_hyper(p, &b->scsi.pr_key);
 215                 break;
 216         default:
 217                 dprintk("unknown volume type!\n");
 218                 return -EIO;
 219         }
 220
 221         return 0;
 222 }
 223
 224 static 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(dev->bdev_file);
 231         return true;
 232 }
 233
 234 static 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
 254 static 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_offset;
 261
 262         chunk = div_u64(offset, dev->chunk_size);
 263         div_u64_rem(chunk, dev->nr_children, &chunk_idx);
 264
 265         if (chunk_idx >= dev->nr_children) {
 266                 dprintk("%s: invalid chunk idx %d (%lld/%lld)\n",
 267                         __func__, chunk_idx, offset, dev->chunk_size);
 268                 /* error, should not happen */
 269                 return false;
 270         }
 271
 272         /* truncate offset to the beginning of the stripe */
 273         offset = chunk * dev->chunk_size;
 274
 275         /* disk offset of the stripe */
 276         disk_offset = div_u64(offset, dev->nr_children);
 277
 278         child = &dev->children[chunk_idx];
 279         child->map(child, disk_offset, map);
 280
 281         map->start += offset;
 282         map->disk_offset += disk_offset;
 283         map->len = dev->chunk_size;
 284         return true;
 285 }
 286
 287 static int
 288 bl_parse_deviceid(struct nfs_server *server, struct pnfs_block_dev *d,
 289                 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask);
 290
 291
 292 static int
 293 bl_parse_simple(struct nfs_server *server, struct pnfs_block_dev *d,
 294                 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
 295 {
 296         struct pnfs_block_volume *v = &volumes[idx];
 297         struct file *bdev_file;
 298         dev_t dev;
 299
 300         dev = bl_resolve_deviceid(server, v, gfp_mask);
 301         if (!dev)
 302                 return -EIO;
 303
 304         bdev_file = bdev_file_open_by_dev(dev, BLK_OPEN_READ | BLK_OPEN_WRITE,
 305                                        NULL, NULL);
 306         if (IS_ERR(bdev_file)) {
 307                 printk(KERN_WARNING "pNFS: failed to open device %d:%d (%ld)\n",
 308                         MAJOR(dev), MINOR(dev), PTR_ERR(bdev_file));
 309                 return PTR_ERR(bdev_file);
 310         }
 311         d->bdev_file = bdev_file;
 312         d->len = bdev_nr_bytes(file_bdev(bdev_file));
 313         d->map = bl_map_simple;
 314
 315         printk(KERN_INFO "pNFS: using block device %s\n",
 316                 file_bdev(bdev_file)->bd_disk->disk_name);
 317         return 0;
 318 }
 319
 320 static bool
 321 bl_validate_designator(struct pnfs_block_volume *v)
 322 {
 323         switch (v->scsi.designator_type) {
 324         case PS_DESIGNATOR_EUI64:
 325                 if (v->scsi.code_set != PS_CODE_SET_BINARY)
 326                         return false;
 327
 328                 if (v->scsi.designator_len != 8 &&
 329                     v->scsi.designator_len != 10 &&
 330                     v->scsi.designator_len != 16)
 331                         return false;
 332
 333                 return true;
 334         case PS_DESIGNATOR_NAA:
 335                 if (v->scsi.code_set != PS_CODE_SET_BINARY)
 336                         return false;
 337
 338                 if (v->scsi.designator_len != 8 &&
 339                     v->scsi.designator_len != 16)
 340                         return false;
 341
 342                 return true;
 343         case PS_DESIGNATOR_T10:
 344         case PS_DESIGNATOR_NAME:
 345                 pr_err("pNFS: unsupported designator "
 346                         "(code set %d, type %d, len %d.\n",
 347                         v->scsi.code_set,
 348                         v->scsi.designator_type,
 349                         v->scsi.designator_len);
 350                 return false;
 351         default:
 352                 pr_err("pNFS: invalid designator "
 353                         "(code set %d, type %d, len %d.\n",
 354                         v->scsi.code_set,
 355                         v->scsi.designator_type,
 356                         v->scsi.designator_len);
 357                 return false;
 358         }
 359 }
 360
 361 static struct file *
 362 bl_open_path(struct pnfs_block_volume *v, const char *prefix)
 363 {
 364         struct file *bdev_file;
 365         const char *devname;
 366
 367         devname = kasprintf(GFP_KERNEL, "/dev/disk/by-id/%s%*phN",
 368                         prefix, v->scsi.designator_len, v->scsi.designator);
 369         if (!devname)
 370                 return ERR_PTR(-ENOMEM);
 371
 372         bdev_file = bdev_file_open_by_path(devname, BLK_OPEN_READ | BLK_OPEN_WRITE,
 373                                         NULL, NULL);
 374         if (IS_ERR(bdev_file)) {
 375                 dprintk("failed to open device %s (%ld)\n",
 376                         devname, PTR_ERR(bdev_file));
 377         }
 378
 379         kfree(devname);
 380         return bdev_file;
 381 }
 382
 383 static int
 384 bl_parse_scsi(struct nfs_server *server, struct pnfs_block_dev *d,
 385                 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
 386 {
 387         struct pnfs_block_volume *v = &volumes[idx];
 388         struct block_device *bdev;
 389         const struct pr_ops *ops;
 390         struct file *bdev_file;
 391         int error;
 392
 393         if (!bl_validate_designator(v))
 394                 return -EINVAL;
 395
 396         /*
 397          * Try to open the RH/Fedora specific dm-mpath udev path first, as the
 398          * wwn- links will only point to the first discovered SCSI device there.
 399          * On other distributions like Debian, the default SCSI by-id path will
 400          * point to the dm-multipath device if one exists.
 401          */
 402         bdev_file = bl_open_path(v, "dm-uuid-mpath-0x");
 403         if (IS_ERR(bdev_file))
 404                 bdev_file = bl_open_path(v, "wwn-0x");
 405         if (IS_ERR(bdev_file))
 406                 bdev_file = bl_open_path(v, "nvme-eui.");
 407         if (IS_ERR(bdev_file)) {
 408                 pr_warn("pNFS: no device found for volume %*phN\n",
 409                         v->scsi.designator_len, v->scsi.designator);
 410                 return PTR_ERR(bdev_file);
 411         }
 412         d->bdev_file = bdev_file;
 413         bdev = file_bdev(bdev_file);
 414
 415         d->len = bdev_nr_bytes(bdev);
 416         d->map = bl_map_simple;
 417         d->pr_key = v->scsi.pr_key;
 418
 419         if (d->len == 0)
 420                 return -ENODEV;
 421
 422         ops = bdev->bd_disk->fops->pr_ops;
 423         if (!ops) {
 424                 pr_err("pNFS: block device %s does not support reservations.",
 425                                 bdev->bd_disk->disk_name);
 426                 error = -EINVAL;
 427                 goto out_blkdev_put;
 428         }
 429
 430         return 0;
 431
 432 out_blkdev_put:
 433         fput(d->bdev_file);
 434         return error;
 435 }
 436
 437 static int
 438 bl_parse_slice(struct nfs_server *server, struct pnfs_block_dev *d,
 439                 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
 440 {
 441         struct pnfs_block_volume *v = &volumes[idx];
 442         int ret;
 443
 444         ret = bl_parse_deviceid(server, d, volumes, v->slice.volume, gfp_mask);
 445         if (ret)
 446                 return ret;
 447
 448         d->disk_offset = v->slice.start;
 449         d->len = v->slice.len;
 450         return 0;
 451 }
 452
 453 static int
 454 bl_parse_concat(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         u64 len = 0;
 459         int ret, i;
 460
 461         d->children = kcalloc(v->concat.volumes_count,
 462                         sizeof(struct pnfs_block_dev), gfp_mask);
 463         if (!d->children)
 464                 return -ENOMEM;
 465
 466         for (i = 0; i < v->concat.volumes_count; i++) {
 467                 ret = bl_parse_deviceid(server, &d->children[i],
 468                                 volumes, v->concat.volumes[i], gfp_mask);
 469                 if (ret)
 470                         return ret;
 471
 472                 d->nr_children++;
 473                 d->children[i].start += len;
 474                 len += d->children[i].len;
 475         }
 476
 477         d->len = len;
 478         d->map = bl_map_concat;
 479         return 0;
 480 }
 481
 482 static int
 483 bl_parse_stripe(struct nfs_server *server, struct pnfs_block_dev *d,
 484                 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
 485 {
 486         struct pnfs_block_volume *v = &volumes[idx];
 487         u64 len = 0;
 488         int ret, i;
 489
 490         d->children = kcalloc(v->stripe.volumes_count,
 491                         sizeof(struct pnfs_block_dev), gfp_mask);
 492         if (!d->children)
 493                 return -ENOMEM;
 494
 495         for (i = 0; i < v->stripe.volumes_count; i++) {
 496                 ret = bl_parse_deviceid(server, &d->children[i],
 497                                 volumes, v->stripe.volumes[i], gfp_mask);
 498                 if (ret)
 499                         return ret;
 500
 501                 d->nr_children++;
 502                 len += d->children[i].len;
 503         }
 504
 505         d->len = len;
 506         d->chunk_size = v->stripe.chunk_size;
 507         d->map = bl_map_stripe;
 508         return 0;
 509 }
 510
 511 static int
 512 bl_parse_deviceid(struct nfs_server *server, struct pnfs_block_dev *d,
 513                 struct pnfs_block_volume *volumes, int idx, gfp_t gfp_mask)
 514 {
 515         d->type = volumes[idx].type;
 516
 517         switch (d->type) {
 518         case PNFS_BLOCK_VOLUME_SIMPLE:
 519                 return bl_parse_simple(server, d, volumes, idx, gfp_mask);
 520         case PNFS_BLOCK_VOLUME_SLICE:
 521                 return bl_parse_slice(server, d, volumes, idx, gfp_mask);
 522         case PNFS_BLOCK_VOLUME_CONCAT:
 523                 return bl_parse_concat(server, d, volumes, idx, gfp_mask);
 524         case PNFS_BLOCK_VOLUME_STRIPE:
 525                 return bl_parse_stripe(server, d, volumes, idx, gfp_mask);
 526         case PNFS_BLOCK_VOLUME_SCSI:
 527                 return bl_parse_scsi(server, d, volumes, idx, gfp_mask);
 528         default:
 529                 dprintk("unsupported volume type: %d\n", d->type);
 530                 return -EIO;
 531         }
 532 }
 533
 534 struct nfs4_deviceid_node *
 535 bl_alloc_deviceid_node(struct nfs_server *server, struct pnfs_device *pdev,
 536                 gfp_t gfp_mask)
 537 {
 538         struct nfs4_deviceid_node *node = NULL;
 539         struct pnfs_block_volume *volumes;
 540         struct pnfs_block_dev *top;
 541         struct xdr_stream xdr;
 542         struct xdr_buf buf;
 543         struct page *scratch;
 544         int nr_volumes, ret, i;
 545         __be32 *p;
 546
 547         scratch = alloc_page(gfp_mask);
 548         if (!scratch)
 549                 goto out;
 550
 551         xdr_init_decode_pages(&xdr, &buf, pdev->pages, pdev->pglen);
 552         xdr_set_scratch_page(&xdr, scratch);
 553
 554         p = xdr_inline_decode(&xdr, sizeof(__be32));
 555         if (!p)
 556                 goto out_free_scratch;
 557         nr_volumes = be32_to_cpup(p++);
 558
 559         volumes = kcalloc(nr_volumes, sizeof(struct pnfs_block_volume),
 560                           gfp_mask);
 561         if (!volumes)
 562                 goto out_free_scratch;
 563
 564         for (i = 0; i < nr_volumes; i++) {
 565                 ret = nfs4_block_decode_volume(&xdr, &volumes[i]);
 566                 if (ret < 0)
 567                         goto out_free_volumes;
 568         }
 569
 570         top = kzalloc(sizeof(*top), gfp_mask);
 571         if (!top)
 572                 goto out_free_volumes;
 573
 574         ret = bl_parse_deviceid(server, top, volumes, nr_volumes - 1, gfp_mask);
 575
 576         node = &top->node;
 577         nfs4_init_deviceid_node(node, server, &pdev->dev_id);
 578         if (ret)
 579                 nfs4_mark_deviceid_unavailable(node);
 580
 581 out_free_volumes:
 582         kfree(volumes);
 583 out_free_scratch:
 584         __free_page(scratch);
 585 out:
 586         return node;
 587 }