drivers/dax/super.c

   1 /*
   2  * Copyright(c) 2017 Intel Corporation. All rights reserved.
   3  *
   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.
   7  *
   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.
  12  */
  13 #include <linux/pagemap.h>
  14 #include <linux/module.h>
  15 #include <linux/mount.h>
  16 #include <linux/magic.h>
  17 #include <linux/genhd.h>
  18 #include <linux/pfn_t.h>
  19 #include <linux/cdev.h>
  20 #include <linux/hash.h>
  21 #include <linux/slab.h>
  22 #include <linux/uio.h>
  23 #include <linux/dax.h>
  24 #include <linux/fs.h>
  25 #include "dax-private.h"
  26
  27 static dev_t dax_devt;
  28 DEFINE_STATIC_SRCU(dax_srcu);
  29 static struct vfsmount *dax_mnt;
  30 static DEFINE_IDA(dax_minor_ida);
  31 static struct kmem_cache *dax_cache __read_mostly;
  32 static struct super_block *dax_superblock __read_mostly;
  33
  34 #define DAX_HASH_SIZE (PAGE_SIZE / sizeof(struct hlist_head))
  35 static struct hlist_head dax_host_list[DAX_HASH_SIZE];
  36 static DEFINE_SPINLOCK(dax_host_lock);
  37
  38 int dax_read_lock(void)
  39 {
  40         return srcu_read_lock(&dax_srcu);
  41 }
  42 EXPORT_SYMBOL_GPL(dax_read_lock);
  43
  44 void dax_read_unlock(int id)
  45 {
  46         srcu_read_unlock(&dax_srcu, id);
  47 }
  48 EXPORT_SYMBOL_GPL(dax_read_unlock);
  49
  50 #ifdef CONFIG_BLOCK
  51 #include <linux/blkdev.h>
  52
  53 int bdev_dax_pgoff(struct block_device *bdev, sector_t sector, size_t size,
  54                 pgoff_t *pgoff)
  55 {
  56         phys_addr_t phys_off = (get_start_sect(bdev) + sector) * 512;
  57
  58         if (pgoff)
  59                 *pgoff = PHYS_PFN(phys_off);
  60         if (phys_off % PAGE_SIZE || size % PAGE_SIZE)
  61                 return -EINVAL;
  62         return 0;
  63 }
  64 EXPORT_SYMBOL(bdev_dax_pgoff);
  65
  66 #if IS_ENABLED(CONFIG_FS_DAX)
  67 struct dax_device *fs_dax_get_by_bdev(struct block_device *bdev)
  68 {
  69         if (!blk_queue_dax(bdev->bd_queue))
  70                 return NULL;
  71         return fs_dax_get_by_host(bdev->bd_disk->disk_name);
  72 }
  73 EXPORT_SYMBOL_GPL(fs_dax_get_by_bdev);
  74 #endif
  75
  76 /**
  77  * __bdev_dax_supported() - Check if the device supports dax for filesystem
  78  * @bdev: block device to check
  79  * @blocksize: The block size of the device
  80  *
  81  * This is a library function for filesystems to check if the block device
  82  * can be mounted with dax option.
  83  *
  84  * Return: true if supported, false if unsupported
  85  */
  86 bool __bdev_dax_supported(struct block_device *bdev, int blocksize)
  87 {
  88         struct dax_device *dax_dev;
  89         bool dax_enabled = false;
  90         struct request_queue *q;
  91         pgoff_t pgoff;
  92         int err, id;
  93         pfn_t pfn;
  94         long len;
  95         char buf[BDEVNAME_SIZE];
  96
  97         if (blocksize != PAGE_SIZE) {
  98                 pr_debug("%s: error: unsupported blocksize for dax\n",
  99                                 bdevname(bdev, buf));
 100                 return false;
 101         }
 102
 103         q = bdev_get_queue(bdev);
 104         if (!q || !blk_queue_dax(q)) {
 105                 pr_debug("%s: error: request queue doesn't support dax\n",
 106                                 bdevname(bdev, buf));
 107                 return false;
 108         }
 109
 110         err = bdev_dax_pgoff(bdev, 0, PAGE_SIZE, &pgoff);
 111         if (err) {
 112                 pr_debug("%s: error: unaligned partition for dax\n",
 113                                 bdevname(bdev, buf));
 114                 return false;
 115         }
 116
 117         dax_dev = dax_get_by_host(bdev->bd_disk->disk_name);
 118         if (!dax_dev) {
 119                 pr_debug("%s: error: device does not support dax\n",
 120                                 bdevname(bdev, buf));
 121                 return false;
 122         }
 123
 124         id = dax_read_lock();
 125         len = dax_direct_access(dax_dev, pgoff, 1, NULL, &pfn);
 126         dax_read_unlock(id);
 127
 128         put_dax(dax_dev);
 129
 130         if (len < 1) {
 131                 pr_debug("%s: error: dax access failed (%ld)\n",
 132                                 bdevname(bdev, buf), len);
 133                 return false;
 134         }
 135
 136         if (IS_ENABLED(CONFIG_FS_DAX_LIMITED) && pfn_t_special(pfn)) {
 137                 /*
 138                  * An arch that has enabled the pmem api should also
 139                  * have its drivers support pfn_t_devmap()
 140                  *
 141                  * This is a developer warning and should not trigger in
 142                  * production. dax_flush() will crash since it depends
 143                  * on being able to do (page_address(pfn_to_page())).
 144                  */
 145                 WARN_ON(IS_ENABLED(CONFIG_ARCH_HAS_PMEM_API));
 146                 dax_enabled = true;
 147         } else if (pfn_t_devmap(pfn)) {
 148                 struct dev_pagemap *pgmap;
 149
 150                 pgmap = get_dev_pagemap(pfn_t_to_pfn(pfn), NULL);
 151                 if (pgmap && pgmap->type == MEMORY_DEVICE_FS_DAX)
 152                         dax_enabled = true;
 153                 put_dev_pagemap(pgmap);
 154         }
 155
 156         if (!dax_enabled) {
 157                 pr_debug("%s: error: dax support not enabled\n",
 158                                 bdevname(bdev, buf));
 159                 return false;
 160         }
 161         return true;
 162 }
 163 EXPORT_SYMBOL_GPL(__bdev_dax_supported);
 164 #endif
 165
 166 enum dax_device_flags {
 167         /* !alive + rcu grace period == no new operations / mappings */
 168         DAXDEV_ALIVE,
 169         /* gate whether dax_flush() calls the low level flush routine */
 170         DAXDEV_WRITE_CACHE,
 171 };
 172
 173 /**
 174  * struct dax_device - anchor object for dax services
 175  * @inode: core vfs
 176  * @cdev: optional character interface for "device dax"
 177  * @host: optional name for lookups where the device path is not available
 178  * @private: dax driver private data
 179  * @flags: state and boolean properties
 180  */
 181 struct dax_device {
 182         struct hlist_node list;
 183         struct inode inode;
 184         struct cdev cdev;
 185         const char *host;
 186         void *private;
 187         unsigned long flags;
 188         const struct dax_operations *ops;
 189 };
 190
 191 static ssize_t write_cache_show(struct device *dev,
 192                 struct device_attribute *attr, char *buf)
 193 {
 194         struct dax_device *dax_dev = dax_get_by_host(dev_name(dev));
 195         ssize_t rc;
 196
 197         WARN_ON_ONCE(!dax_dev);
 198         if (!dax_dev)
 199                 return -ENXIO;
 200
 201         rc = sprintf(buf, "%d\n", !!dax_write_cache_enabled(dax_dev));
 202         put_dax(dax_dev);
 203         return rc;
 204 }
 205
 206 static ssize_t write_cache_store(struct device *dev,
 207                 struct device_attribute *attr, const char *buf, size_t len)
 208 {
 209         bool write_cache;
 210         int rc = strtobool(buf, &write_cache);
 211         struct dax_device *dax_dev = dax_get_by_host(dev_name(dev));
 212
 213         WARN_ON_ONCE(!dax_dev);
 214         if (!dax_dev)
 215                 return -ENXIO;
 216
 217         if (rc)
 218                 len = rc;
 219         else
 220                 dax_write_cache(dax_dev, write_cache);
 221
 222         put_dax(dax_dev);
 223         return len;
 224 }
 225 static DEVICE_ATTR_RW(write_cache);
 226
 227 static umode_t dax_visible(struct kobject *kobj, struct attribute *a, int n)
 228 {
 229         struct device *dev = container_of(kobj, typeof(*dev), kobj);
 230         struct dax_device *dax_dev = dax_get_by_host(dev_name(dev));
 231
 232         WARN_ON_ONCE(!dax_dev);
 233         if (!dax_dev)
 234                 return 0;
 235
 236 #ifndef CONFIG_ARCH_HAS_PMEM_API
 237         if (a == &dev_attr_write_cache.attr)
 238                 return 0;
 239 #endif
 240         return a->mode;
 241 }
 242
 243 static struct attribute *dax_attributes[] = {
 244         &dev_attr_write_cache.attr,
 245         NULL,
 246 };
 247
 248 struct attribute_group dax_attribute_group = {
 249         .name = "dax",
 250         .attrs = dax_attributes,
 251         .is_visible = dax_visible,
 252 };
 253 EXPORT_SYMBOL_GPL(dax_attribute_group);
 254
 255 /**
 256  * dax_direct_access() - translate a device pgoff to an absolute pfn
 257  * @dax_dev: a dax_device instance representing the logical memory range
 258  * @pgoff: offset in pages from the start of the device to translate
 259  * @nr_pages: number of consecutive pages caller can handle relative to @pfn
 260  * @kaddr: output parameter that returns a virtual address mapping of pfn
 261  * @pfn: output parameter that returns an absolute pfn translation of @pgoff
 262  *
 263  * Return: negative errno if an error occurs, otherwise the number of
 264  * pages accessible at the device relative @pgoff.
 265  */
 266 long dax_direct_access(struct dax_device *dax_dev, pgoff_t pgoff, long nr_pages,
 267                 void **kaddr, pfn_t *pfn)
 268 {
 269         long avail;
 270
 271         if (!dax_dev)
 272                 return -EOPNOTSUPP;
 273
 274         if (!dax_alive(dax_dev))
 275                 return -ENXIO;
 276
 277         if (nr_pages < 0)
 278                 return nr_pages;
 279
 280         avail = dax_dev->ops->direct_access(dax_dev, pgoff, nr_pages,
 281                         kaddr, pfn);
 282         if (!avail)
 283                 return -ERANGE;
 284         return min(avail, nr_pages);
 285 }
 286 EXPORT_SYMBOL_GPL(dax_direct_access);
 287
 288 size_t dax_copy_from_iter(struct dax_device *dax_dev, pgoff_t pgoff, void *addr,
 289                 size_t bytes, struct iov_iter *i)
 290 {
 291         if (!dax_alive(dax_dev))
 292                 return 0;
 293
 294         return dax_dev->ops->copy_from_iter(dax_dev, pgoff, addr, bytes, i);
 295 }
 296 EXPORT_SYMBOL_GPL(dax_copy_from_iter);
 297
 298 size_t dax_copy_to_iter(struct dax_device *dax_dev, pgoff_t pgoff, void *addr,
 299                 size_t bytes, struct iov_iter *i)
 300 {
 301         if (!dax_alive(dax_dev))
 302                 return 0;
 303
 304         return dax_dev->ops->copy_to_iter(dax_dev, pgoff, addr, bytes, i);
 305 }
 306 EXPORT_SYMBOL_GPL(dax_copy_to_iter);
 307
 308 #ifdef CONFIG_ARCH_HAS_PMEM_API
 309 void arch_wb_cache_pmem(void *addr, size_t size);
 310 void dax_flush(struct dax_device *dax_dev, void *addr, size_t size)
 311 {
 312         if (unlikely(!dax_write_cache_enabled(dax_dev)))
 313                 return;
 314
 315         arch_wb_cache_pmem(addr, size);
 316 }
 317 #else
 318 void dax_flush(struct dax_device *dax_dev, void *addr, size_t size)
 319 {
 320 }
 321 #endif
 322 EXPORT_SYMBOL_GPL(dax_flush);
 323
 324 void dax_write_cache(struct dax_device *dax_dev, bool wc)
 325 {
 326         if (wc)
 327                 set_bit(DAXDEV_WRITE_CACHE, &dax_dev->flags);
 328         else
 329                 clear_bit(DAXDEV_WRITE_CACHE, &dax_dev->flags);
 330 }
 331 EXPORT_SYMBOL_GPL(dax_write_cache);
 332
 333 bool dax_write_cache_enabled(struct dax_device *dax_dev)
 334 {
 335         return test_bit(DAXDEV_WRITE_CACHE, &dax_dev->flags);
 336 }
 337 EXPORT_SYMBOL_GPL(dax_write_cache_enabled);
 338
 339 bool dax_alive(struct dax_device *dax_dev)
 340 {
 341         lockdep_assert_held(&dax_srcu);
 342         return test_bit(DAXDEV_ALIVE, &dax_dev->flags);
 343 }
 344 EXPORT_SYMBOL_GPL(dax_alive);
 345
 346 static int dax_host_hash(const char *host)
 347 {
 348         return hashlen_hash(hashlen_string("DAX", host)) % DAX_HASH_SIZE;
 349 }
 350
 351 /*
 352  * Note, rcu is not protecting the liveness of dax_dev, rcu is ensuring
 353  * that any fault handlers or operations that might have seen
 354  * dax_alive(), have completed.  Any operations that start after
 355  * synchronize_srcu() has run will abort upon seeing !dax_alive().
 356  */
 357 void kill_dax(struct dax_device *dax_dev)
 358 {
 359         if (!dax_dev)
 360                 return;
 361
 362         clear_bit(DAXDEV_ALIVE, &dax_dev->flags);
 363
 364         synchronize_srcu(&dax_srcu);
 365
 366         spin_lock(&dax_host_lock);
 367         hlist_del_init(&dax_dev->list);
 368         spin_unlock(&dax_host_lock);
 369 }
 370 EXPORT_SYMBOL_GPL(kill_dax);
 371
 372 void run_dax(struct dax_device *dax_dev)
 373 {
 374         set_bit(DAXDEV_ALIVE, &dax_dev->flags);
 375 }
 376 EXPORT_SYMBOL_GPL(run_dax);
 377
 378 static struct inode *dax_alloc_inode(struct super_block *sb)
 379 {
 380         struct dax_device *dax_dev;
 381         struct inode *inode;
 382
 383         dax_dev = kmem_cache_alloc(dax_cache, GFP_KERNEL);
 384         if (!dax_dev)
 385                 return NULL;
 386
 387         inode = &dax_dev->inode;
 388         inode->i_rdev = 0;
 389         return inode;
 390 }
 391
 392 static struct dax_device *to_dax_dev(struct inode *inode)
 393 {
 394         return container_of(inode, struct dax_device, inode);
 395 }
 396
 397 static void dax_i_callback(struct rcu_head *head)
 398 {
 399         struct inode *inode = container_of(head, struct inode, i_rcu);
 400         struct dax_device *dax_dev = to_dax_dev(inode);
 401
 402         kfree(dax_dev->host);
 403         dax_dev->host = NULL;
 404         if (inode->i_rdev)
 405                 ida_simple_remove(&dax_minor_ida, MINOR(inode->i_rdev));
 406         kmem_cache_free(dax_cache, dax_dev);
 407 }
 408
 409 static void dax_destroy_inode(struct inode *inode)
 410 {
 411         struct dax_device *dax_dev = to_dax_dev(inode);
 412
 413         WARN_ONCE(test_bit(DAXDEV_ALIVE, &dax_dev->flags),
 414                         "kill_dax() must be called before final iput()\n");
 415         call_rcu(&inode->i_rcu, dax_i_callback);
 416 }
 417
 418 static const struct super_operations dax_sops = {
 419         .statfs = simple_statfs,
 420         .alloc_inode = dax_alloc_inode,
 421         .destroy_inode = dax_destroy_inode,
 422         .drop_inode = generic_delete_inode,
 423 };
 424
 425 static struct dentry *dax_mount(struct file_system_type *fs_type,
 426                 int flags, const char *dev_name, void *data)
 427 {
 428         return mount_pseudo(fs_type, "dax:", &dax_sops, NULL, DAXFS_MAGIC);
 429 }
 430
 431 static struct file_system_type dax_fs_type = {
 432         .name = "dax",
 433         .mount = dax_mount,
 434         .kill_sb = kill_anon_super,
 435 };
 436
 437 static int dax_test(struct inode *inode, void *data)
 438 {
 439         dev_t devt = *(dev_t *) data;
 440
 441         return inode->i_rdev == devt;
 442 }
 443
 444 static int dax_set(struct inode *inode, void *data)
 445 {
 446         dev_t devt = *(dev_t *) data;
 447
 448         inode->i_rdev = devt;
 449         return 0;
 450 }
 451
 452 static struct dax_device *dax_dev_get(dev_t devt)
 453 {
 454         struct dax_device *dax_dev;
 455         struct inode *inode;
 456
 457         inode = iget5_locked(dax_superblock, hash_32(devt + DAXFS_MAGIC, 31),
 458                         dax_test, dax_set, &devt);
 459
 460         if (!inode)
 461                 return NULL;
 462
 463         dax_dev = to_dax_dev(inode);
 464         if (inode->i_state & I_NEW) {
 465                 set_bit(DAXDEV_ALIVE, &dax_dev->flags);
 466                 inode->i_cdev = &dax_dev->cdev;
 467                 inode->i_mode = S_IFCHR;
 468                 inode->i_flags = S_DAX;
 469                 mapping_set_gfp_mask(&inode->i_data, GFP_USER);
 470                 unlock_new_inode(inode);
 471         }
 472
 473         return dax_dev;
 474 }
 475
 476 static void dax_add_host(struct dax_device *dax_dev, const char *host)
 477 {
 478         int hash;
 479
 480         /*
 481          * Unconditionally init dax_dev since it's coming from a
 482          * non-zeroed slab cache
 483          */
 484         INIT_HLIST_NODE(&dax_dev->list);
 485         dax_dev->host = host;
 486         if (!host)
 487                 return;
 488
 489         hash = dax_host_hash(host);
 490         spin_lock(&dax_host_lock);
 491         hlist_add_head(&dax_dev->list, &dax_host_list[hash]);
 492         spin_unlock(&dax_host_lock);
 493 }
 494
 495 struct dax_device *alloc_dax(void *private, const char *__host,
 496                 const struct dax_operations *ops)
 497 {
 498         struct dax_device *dax_dev;
 499         const char *host;
 500         dev_t devt;
 501         int minor;
 502
 503         host = kstrdup(__host, GFP_KERNEL);
 504         if (__host && !host)
 505                 return NULL;
 506
 507         minor = ida_simple_get(&dax_minor_ida, 0, MINORMASK+1, GFP_KERNEL);
 508         if (minor < 0)
 509                 goto err_minor;
 510
 511         devt = MKDEV(MAJOR(dax_devt), minor);
 512         dax_dev = dax_dev_get(devt);
 513         if (!dax_dev)
 514                 goto err_dev;
 515
 516         dax_add_host(dax_dev, host);
 517         dax_dev->ops = ops;
 518         dax_dev->private = private;
 519         return dax_dev;
 520
 521  err_dev:
 522         ida_simple_remove(&dax_minor_ida, minor);
 523  err_minor:
 524         kfree(host);
 525         return NULL;
 526 }
 527 EXPORT_SYMBOL_GPL(alloc_dax);
 528
 529 void put_dax(struct dax_device *dax_dev)
 530 {
 531         if (!dax_dev)
 532                 return;
 533         iput(&dax_dev->inode);
 534 }
 535 EXPORT_SYMBOL_GPL(put_dax);
 536
 537 /**
 538  * dax_get_by_host() - temporary lookup mechanism for filesystem-dax
 539  * @host: alternate name for the device registered by a dax driver
 540  */
 541 struct dax_device *dax_get_by_host(const char *host)
 542 {
 543         struct dax_device *dax_dev, *found = NULL;
 544         int hash, id;
 545
 546         if (!host)
 547                 return NULL;
 548
 549         hash = dax_host_hash(host);
 550
 551         id = dax_read_lock();
 552         spin_lock(&dax_host_lock);
 553         hlist_for_each_entry(dax_dev, &dax_host_list[hash], list) {
 554                 if (!dax_alive(dax_dev)
 555                                 || strcmp(host, dax_dev->host) != 0)
 556                         continue;
 557
 558                 if (igrab(&dax_dev->inode))
 559                         found = dax_dev;
 560                 break;
 561         }
 562         spin_unlock(&dax_host_lock);
 563         dax_read_unlock(id);
 564
 565         return found;
 566 }
 567 EXPORT_SYMBOL_GPL(dax_get_by_host);
 568
 569 /**
 570  * inode_dax: convert a public inode into its dax_dev
 571  * @inode: An inode with i_cdev pointing to a dax_dev
 572  *
 573  * Note this is not equivalent to to_dax_dev() which is for private
 574  * internal use where we know the inode filesystem type == dax_fs_type.
 575  */
 576 struct dax_device *inode_dax(struct inode *inode)
 577 {
 578         struct cdev *cdev = inode->i_cdev;
 579
 580         return container_of(cdev, struct dax_device, cdev);
 581 }
 582 EXPORT_SYMBOL_GPL(inode_dax);
 583
 584 struct inode *dax_inode(struct dax_device *dax_dev)
 585 {
 586         return &dax_dev->inode;
 587 }
 588 EXPORT_SYMBOL_GPL(dax_inode);
 589
 590 void *dax_get_private(struct dax_device *dax_dev)
 591 {
 592         if (!test_bit(DAXDEV_ALIVE, &dax_dev->flags))
 593                 return NULL;
 594         return dax_dev->private;
 595 }
 596 EXPORT_SYMBOL_GPL(dax_get_private);
 597
 598 static void init_once(void *_dax_dev)
 599 {
 600         struct dax_device *dax_dev = _dax_dev;
 601         struct inode *inode = &dax_dev->inode;
 602
 603         memset(dax_dev, 0, sizeof(*dax_dev));
 604         inode_init_once(inode);
 605 }
 606
 607 static int dax_fs_init(void)
 608 {
 609         int rc;
 610
 611         dax_cache = kmem_cache_create("dax_cache", sizeof(struct dax_device), 0,
 612                         (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
 613                          SLAB_MEM_SPREAD|SLAB_ACCOUNT),
 614                         init_once);
 615         if (!dax_cache)
 616                 return -ENOMEM;
 617
 618         rc = register_filesystem(&dax_fs_type);
 619         if (rc)
 620                 goto err_register_fs;
 621
 622         dax_mnt = kern_mount(&dax_fs_type);
 623         if (IS_ERR(dax_mnt)) {
 624                 rc = PTR_ERR(dax_mnt);
 625                 goto err_mount;
 626         }
 627         dax_superblock = dax_mnt->mnt_sb;
 628
 629         return 0;
 630
 631  err_mount:
 632         unregister_filesystem(&dax_fs_type);
 633  err_register_fs:
 634         kmem_cache_destroy(dax_cache);
 635
 636         return rc;
 637 }
 638
 639 static void dax_fs_exit(void)
 640 {
 641         kern_unmount(dax_mnt);
 642         unregister_filesystem(&dax_fs_type);
 643         kmem_cache_destroy(dax_cache);
 644 }
 645
 646 static int __init dax_core_init(void)
 647 {
 648         int rc;
 649
 650         rc = dax_fs_init();
 651         if (rc)
 652                 return rc;
 653
 654         rc = alloc_chrdev_region(&dax_devt, 0, MINORMASK+1, "dax");
 655         if (rc)
 656                 goto err_chrdev;
 657
 658         rc = dax_bus_init();
 659         if (rc)
 660                 goto err_bus;
 661         return 0;
 662
 663 err_bus:
 664         unregister_chrdev_region(dax_devt, MINORMASK+1);
 665 err_chrdev:
 666         dax_fs_exit();
 667         return 0;
 668 }
 669
 670 static void __exit dax_core_exit(void)
 671 {
 672         unregister_chrdev_region(dax_devt, MINORMASK+1);
 673         ida_destroy(&dax_minor_ida);
 674         dax_fs_exit();
 675 }
 676
 677 MODULE_AUTHOR("Intel Corporation");
 678 MODULE_LICENSE("GPL v2");
 679 subsys_initcall(dax_core_init);
 680 module_exit(dax_core_exit);