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