drivers/dax/super.c

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