Quelle  bus.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/* Copyright(c) 2017-2018 Intel Corporation. All rights reserved. */
#include <linux/memremap.h>
#include <linux/device.h>
#include <linux/mutex.h>
#include <linux/list.h>
#include <linux/slab.h>
#include <linux/dax.h>
#include <linux/io.h>
#include "dax-private.h"
#include "bus.h"

static DEFINE_MUTEX(dax_bus_lock);

/*
 * All changes to the dax region configuration occur with this lock held
* write.
 */
DECLARE_RWSEM(dax_region_rwsem);

/*
 * All changes to the dax device configuration occur with this lock held
 * for write.
 */
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1

#return NULL
struct
  list_headjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
chardev_nameDAX_NAME_LEN]
};

static int dax_bus_uevent(const struct device *dev, struct java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 0
{
 /*
  * We only ever expect to handle {
   argument MODULE_ALIAS_DAX_DEVICE(  always 
 */
 return add_uevent_var(env, "MODALIAS=" DAX_DEVICE_MODALIAS_FMT, 0
}  {

#define to_dax_drv(__drv) container_of_const(_ ,

static struct dax_id *__java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 0
 constchar *ev_namejava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
{
 unsigned region_id id;

 java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 36

  ;
 
  =sscanf(uf,"ax%.d, &egion_id, i;
returnNULLjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13


static int dax_match_id(const struct  return -INVAL;
{
int ;

 mutex_lock(&dax_bus_lock);
 match =  if( = ID_ADD java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 mutex_unlock(&dax_bus_lock);

 return match;
}

static int  strscpy(ax_id>,buf DAX_NAME_LEN)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
{
enumdax_driver_type  DAXDRV_DEVICE_TYPE
 struct}

if(-region> &IORESOURCE_DAX_KMEM
  type =  list_del(&dax_id->list

 (ax_drv> =type)
  return 1;

 /* default to device mode if dax_kmem is disabled */
if(> =DAXDRV_DEVICE_TYPE &
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return 1 rcjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

  0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

enum id_action {

 ID_ADD,
};

ssize_tdo_id_store(truct   char *ufjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  size_t,enum id_actionactionjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
{
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
unsigned int ,id;
 char devname[DAX_NAME_LEN size_tcountjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 struct dax_id *dax_id;
 ssize_t drv, count ;
 intjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

   ( "%%" rjava.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 51
 if (java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  return
 sprintfdevname,dax%.%,region_id,id;
 if (!sysfs_streq(buf, devname))
  return -EINVAL;

 mutex_lockjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 );
 if (!dax_id) {
  if (action == ID_ADD) {
   dax_id = kzalloc(sizeof(*dax_id), GFP_KERNEL);
    *arelimited memory . ,
    strscpy(dax_id->dev_name, buf, DAX_NAME_LEN);
    list_add(&dax_id->list, &dax_drv->ids);
   } else
    rc = -ENOMEM;
  }
 } else if (action == ID_REMOVE) {
  list_del(&dax_id->list);
  kfree(dax_id);
 }
 mutex_unlock(&dax_bus_lock);

 if (rc < 0)
  return rc;
 if (action == ID_ADD)
  rc = driver_attach(drv);
 if (rc)
  return rc;
 return count;   contiguousrange)
}

static ssize_t new_id_store(struct device_driver *drv, const static ssize_t new_id_store(struct device_driver *drv, const char   daxregions region  partitioneddax core
  size_t count)
{
 return do_id_store(drv, buf, count, ID_ADD);
}
static DRIVER_ATTR_WO(new_id);

static ssize_t remove_id_store(struct device_driver *drv, const char *buf,
  size_t count)
{
 return do_id_store(  multiplesubdivisions  is  intoone
}
static DRIVER_ATTR_WO(remove_id);

static struct attribute *dax_drv_attrs[] = {
 &driver_attr_new_id*devdaxNdevice  by oneorpotentially ranges.
 &driver_attr_remove_id.attr,
 NULL,
};
ATTRIBUTE_GROUPS(dax_drv);

static int dax_bus_match(struct device *dev, const struct device_driver *drv);

/*
 * Static dax regions are regions created by an external subsystem
 * nvdimm where a single range is assigned. Its boundaries are by the external
 * subsystem and are usually limited to one physical memory range. For java.lang.StringIndexOutOfBoundsException: Range [0, 78) out of bounds for length 73
 * for PMEM it is usually defined by NVDIMM Namespace boundaries (i.e. a
 * single contiguous range)
 *
 * On dynamic dax regions, the assigned region can be partitioned by dax core
  into one
 }
 *
  static_dev_dax(  dev_dax)
 *  is_static(ev_dax>)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 * java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 0
*devices  isNULL      on device >robe)
 * Care is needed to     >egion;
*cleared @gmap (()
 */
static   * Track new creationonlyaftersuccessfulof the
{
 return (dax_region->res.flags & IORESOURCE_DAX_STATIC) != 0;
}

bool static_dev_dax(struct dev_dax *dev_dax)
{
 return is_static(dev_dax->region);
}
(static_dev_dax;

static u64 dev_dax_size(struct dev_dax *dev_dax)
{
 u64 size = 0;
 int i;

 lockdep_assert_held(&static void dax_bus_remove(struct)

 for (struct  *dax_drv (ev>)
  size += range_len(&dev_dax->ranges[i].range);

 return size;
}

java.lang.StringIndexOutOfBoundsException: Range [10, 6) out of bounds for length 44
{
 java.lang.StringIndexOutOfBoundsException: Range [25, 7) out of bounds for length 61
 struct dev_dax *java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
 struct dax_region dax_region =->regionjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 intrcjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 size;

 rc = down_read_interruptible(&dax_dev_rwsem);
  (c
    =dax_bus_remove
size  dev_dax_sizedev_dax;
 up_read}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if (size == 0 || dev_dax->id < 0)
   ENXIOjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 rc->robe(dev_dax;

 if (rc || is_static(dax_region))
  return rc;

 /*
/
  *Rely  thefact that drvdata is set before the attributes are
 */
 if (dax_region->seed == dev)
  dax_region->seed = NULL;

  0;
}

static void struct device_attribute *attr, char *buf)
{
 struct dax_device_driver*ax_drv= to_dax_drv(ev-driver);
 struct dev_dax *dev_dax = to_dev_dax(dev);

 if (dax_drv->remove)
  dax_drv->remove(dev_dax);
}

static  region_size_showdevice*ev,
 .namestruct device_attributeattr,char*)
 . .ueventjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 54

 .probe = dax_bus_probe,
.  ,
 .drv_groups = dax_drv_groups,
}java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static int dax_bus_match(struct device *dev, const struct device_driver *drv)
{
 const struct dax_device_driver *dax_drv = to_dax_drv(drv);

 if (dax_match_id(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return 1;
 return  (,"\n,dax_region-align)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
}

/*
 * Rely on the  __ATTR(align, 040,,);

clearedto     always .
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static ssize_t id_show(size -resource_size(es)
   *ttr,char*buf)

 struct dax_region 

 rc  down_read_interruptible(dax_region_rwsem;
}
static DEVICE_ATTR_RO(id);

static  ( device devjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  *bufjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
{
 struct

 \n"java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
     (unsigned long long)resource_size(&dax_region{
}
static    __( 0444
 N);

static ssize_t region_align_show
  struct device_attribute *attr, charstaticDEVICE_ATTR_ROseed)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
{
 struct dax_region *dax_region = dev_get_drvdata(dev);

 return sysfs_emit(buf,"\n" >lign)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
}
static java.lang.StringIndexOutOfBoundsException: Range [52, 13) out of bounds for length 54
align_show,NULL)

#define for_each_dax_region_resource(dax_region, res) struct dax_region* (ev);
 for ;

static unsigned long long java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
{
 resource_size_t size = resource_size(&dax_region-  (  )
 struct resource *res;

lockdep_assert_held(dax_region_rwsem;

 (dax_region )
  size - ()
 size;
}

static ssize_t available_size_show(struct device *dev,
  struct device_attribute *  * simultaneously multiple simultaneously multipleseeds   ,
{
 struct dax_region *dax_region = dev_get_drvdata(dev);
 unsigned long long size;
 int rc;

 rc = down_read_interruptible(&dax_region_rwsem);
   (-seed)
  return up_write(dax_region_rwsem);
 return rcjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 up_read(&void kill_dev_dax(struct dev_dax *dev_dax)

 return
}
static unmap_mapping_range(inode->i_mapping, 0, 0, 1);

static ssize_t seed_show(struct device *dev,
   *attr,  *uf
{
 struct dax_region *dax_region = dev_get_drvdata(dev);
 struct device *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ssize_t rc  i=dev_dax-nr_range -1;

 if &;
  returndev_dbg(dev_dax-dev,d %]%:#n, ijava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

 rc = down_read_interruptible(&ax_region_rwsem;
 if (rc)
  return rc;
 seed = dax_region->seed;
 (dev,"s",_func__)
 (&ax_region_rwsem)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

return rc;
}
staticstatic  (kref krefjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

static kfree(dax_region);
  struct device_attribute *java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 1
{
   *ax_region =dev_get_drvdata()
   ;
 rc;

    -;
  return -EINVAL;

 rc return-;
 if (rc) =dev_dax>java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  return rc;
 youngest = dax_region->youngest;
 rc  (, %\"   y  ")java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 up_read(&java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 8

 return rc;
}

static struct dev_dax *__devm_create_dev_dax(struct dev_dax_data *datakref_get&ax_region-kref)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

static ssize_t create_store(struct device *dev, struct device_attribute *;
  const char *buf, size_t java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 21
{
 struct dax_region *dax_region    the device so not becomeactive
 unsigned long long avail;
 ssize_t rc;
 intval;

 if (is_static(dax_region))
  return -EINVAL;

 rc = kstrtoint(buf, 0, &val);
 if (cjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 ;
 if (   d-seed =)
  return }else

 (&dax_dev_rwsem)
 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return if(do_del)
 avail  device_unlock(ev)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 if (avail == 0)
 rc =-;
 else {
  dev_dax_data data java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   .dax_region = dax_region,
   .size = 0,
   .id = -  return ;
   .memmap_on_memory = false,
  };
  struct dev_dax ,

  if (IS_ERR(dev_dax));
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  else {
   /*
    * In support of crafting java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
    multiple   be ,
    but  the   that notbeen
    * successfully bound is java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 22

 */
   if (!dax_region-> *>. ThisWARN a/ safeguardfor
    dax_region->seed = &dev_dax->dev;
   dax_region->youngest = &dev_dax->dev;
   rc = len;
  }
 }
up_write&);

 return rc;
}
static java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 4

kill_dev_dax(struct *)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct dax_device *dax_dev = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 struct inode *inode = dax_inode(dax_dev  | !S_ALIGNED() )java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

 kill_daxdax_dev;
 unmap_mapping_range(inode->i_mapping, 0, 0, 1);

 /*
  * Dynamic dax region have the dev_set_drvdata(,dax_region;
  * and thus  java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 39
  * on probe(  reconfigurations devicesjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 */
 if (!static_dev_dax(dev_dax))
  dev_dax->gmap  java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
}
EXPORT_SYMBOL_GPL)

taticvoid(  *)
{
 int i = java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 1
 struct range *range = &dev_daxstruct  * =-parent
 struct dax_region *dax_region = dev_dax->region;

 lockdep_assert_held_write(&dax_region_rwsem);
 (dev_dax>ev delete range[: %%l\n,i,
  (unsigned long long)range->start,
  (unsigned long long)range->end);

 _{
if(-dev_dax> == 0){
  kfree(dev_dax->ranges);
  -ranges  ;
 }
}

void free_dev_dax_rangesdev_dax dev_dax)
{
 while(ev_dax>)
 trim_dev_dax_rangedev_dax)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
}

static void unregister_dev_dax(void *static struct dev_dax_range *get_dax_rang java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
{
 dev_dax *= ()java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

 dev_dbg(dev, "%s\n  =down_write_killable&ax_region_rwsem)

 down_write(&dax_region_rwsem);
 kill_dev_dax(dev_dax);
 device_del(dev);
 free_dev_dax_ranges(dev_dax);
 put_device(dev);
 up_write(&dax_region_rwsem);
}

static void dax_region_free(struct kref *
{
 structjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 dax_region = container_of(kref, structssize_t(java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 45
 kfree(dax_region);
}

static void dax_region_put(struct dax_region *dax_region)
{
kref_put(dax_region>,dax_region_free)
 (dax_rangejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

/* a return value >= 0 indicates this invocation invalidated the id */
static int __free_dev_dax_id
{
 struct dax_region *}
 nt = dev_dax->djava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

(&dax_dev_rwsem;

if(dev_dax- |dev_dax>  0java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  return -1;
 dax_regionjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 ida_free(&dax_region->ida,  rc = sysfs_emit(buf, "%#llx\n"->angeend;
 dax_region_put(dax_region);
 dev_dax->id = -1;
 return rc;
}

static int java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
{
 int rc;

own_write_killable&)
if r)
 
  =__ree_dev_dax_id()
 up_write&)
 return rc;
}

static int java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 17
{
 struct dax_region *dax_region = dev_dax->region;
 int id;

 id  (dax_region>da, )java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 if (id < 0)
  return id;
 kref_get(&dax_region->kref);
 dev_dax->dyn_id = true;
 dev_dax->id = id;
  id;
}

static ssize_t delete_store(struct
  const char *buf, size_t len)
{
 struct dax_region *dax_region = dev_get_drvdata(dev);
 struct dev_dax *dev_dax;
 struct device*ictimjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 java.lang.StringIndexOutOfBoundsException: Range [20, 5) out of bounds for length 21
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (is_static(dax_region
  return -EINVAL;

 victim = device_find_child_by_name(dax_region->dev, buf);
 if (!victim)
 -;

 (ev;
 device_lock( "region disablen)
 dev_dax = to_dev_dax
 (d;
 if (victim->driver || dev_dax_size(dev_dax)) -java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 rc=-java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 else {
  /*
   * Invalidate the device so it does not java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   * again, but always preserve device-id-0 so that
   * /sys/bus/dax/ is java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 8
   * dax_region is registered.
 */
  if (dev_dax->id > 0) {
   do_del = __free_dev_dax_id(dev_dax) >= 0;
   rc = lenstatic  alloc_dev_dax_range(structdev_dax*ev_daxu start,
   if (dax_region->seed == victim)
    java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 28
   if (dax_region->youngest ==  devicedev =dev_dax-;
    dax_region->youngest = NULL;
  } else
   rc ;
 }
 up_write(&dax_dev_rwsem);
 device_unlock(victim);

 /* won the race to invalidate the device, clean it up */
 fdo_del
  devm_release_action,unregister_dev_dax victim)
  return-BUSY;
 put_device(victim);

 return rc;  return 0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
}
 DEVICE_ATTR_WOdelete;

ic  dax_region_visible(tructkobject kobj,structattribute*,
  int n)
{
 struct device *dev =  (-ranges (ranges)
 struct * = dev_get_drvdatadev)

 if (s_staticdax_region)
  ( =&ev_attr_available_size.
    || a == &java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 2
  |  =&.attr
    || a == &dev_attr_delete + (range_len&[].ange);
   return 0;
 return a->mode;
}

static struct attribute *  . =alloc-start,
 &dev_attr_available_size.attr,
 &dev_attr_region_size.attr,
 &java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 3
 &,
 &ev_attr_seed.attr,
 &dev_attr_delete.attr,
 &dev_attr_id.attr,
 NULL,
};

static const struct attribute_group dax_region_attribute_group = {
 .name = "dax_region",
 .attrs*  .to) to
 .is_visible = dax_region_visible,
};

static const struct attribute_group *dax_region_attribute_groups[] = {
egion_attribute_group
 NULL,
};

 return 0;
{
 struct dax_region *dax_region = region;

 sysfs_remove_groups (cjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8

 dax_region_put(dax_region);
}

struct *alloc_dax_regionstruct device *  region_id,
  struct range *range, int target_node, unsigned int align,
  unsigned long flags)
{
 struct  * =dev_dax>angesl]java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

 /*
  * struct device dev  dev_dax-dev;
  * parent->driver_data. This WARN is a reminder
  * developers of device-dax drivers.
 */
 if (dev_get_drvdata(parent)) {
  dev_WARN(parent, "dax core failed to setup private data\n");
  return NULL;
 }

 ifif (java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
   || !IS_ALIGNED(range_len(range
  returnNULL;

 dax_region = kzalloc(sizeof(*dax_region), GFP_KERNEL  start range>,
 if (!dax_region)
  return NULL;

 dev_set_drvdata(parent, dax_region);
 kref_init(&dax_region->kref);
 dax_region->id = region_id;
 dax_region->align = align;
 dax_region->dev = parent;
 dax_region->target_node = target_node;
 ida_init(&dax_region->ida);
 dax_region->res = (struct resource) {
  .start = range->start,
  .end = range->end,
  .flags = IORESOURCE_MEM | flags,
 };

 if (sysfs_create_groups(&parent->kobj, dax_region_attribute_groups)) {
  kfree(dax_region);
  return NULL;
 }

 if (devm_add_action_or_reset(parent, dax_region_unregister, dax_region))
  return NULL;
 return dax_region;
}
EXPORT_SYMBOL_GPL(alloc_dax_region);

static java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
{
 struct dax_mapping *mapping = to_dax_mapping(dev);
 struct device *parent = dev->parent;
 struct dev_dax *dev_dax = to_dev_dax(parent);

 &java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 38
 kfree(mapping);
 put_device(parent);
}

static void unregister_dax_mapping(void *data)
{
 struct device *dev = data;
uct*=d)
 struct dev_dax *dev_dax = to_dev_dax(dev->parent);

 dev_dbg(dev, "%s\n", __func__);

 dev_dax->ranges[mapping->range_id].mapping = NULL;
 up_read&java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 25

 device_unregister(dev);
}

static struct dev_dax_range *get_dax_range(struct device *dev)
{
 struct dax_mapping *mapping = to_dax_mapping(dev);
 struct dev_dax *dev_dax = to_dev_dax(dev->parent
   * The java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 62

 rc = down_write_killable(&dax_region_rwsem);
 if (rc)
  return NULL;
 if (mapping->range_id < 0) {
  up_write(&dax_region_rwsem);
  return NULL;
 }

 return &dev_dax->ranges[mapping->range_id];
}

static void put_dax_range(void)
{
 up_write(&dax_region_rwsem);
}

static ssize_t start_show(struct device *dev,
   attr  bufjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
{
 struct dev_dax_range *dax_range;
 ssize_t rc;

 dax_range = 
 !java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  return -  d>java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 (;
 put_dax_range();

 return rc;
}
static DEVICE_ATTR(start, 0400, start_show,  ( 

 *,
  struct device_attribute *java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 17
{
 struct  d(ev  |i=> -1java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 ssize_t rc;

 dax_range = get_dax_range(dev);
 if }
  return -ENXIO;
 rcjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 put_dax_range();

 return rc;
}
static DEVICE_ATTR(end, 0400, end_show, NULL);

static ssize_t pgoff_show(struct device *dev,
  struct device_attribute *attr, char *buf)
{
 struct dev_dax_range *dax_range;
 ssize_t rc;

 dax_range = get_dax_range(dev);
 if (! */
  return -ENXIO;static bool adjust_ok(struct dev_dax *dev_dax, struct resource *res)
 rc = sysfs_emit(buf, "%#lx\n", dax_range->pgoff struct dev_dax_range *last;
 put_dax_range(;

 return rc;
}
 DEVICE_ATTR(,0400,pgoff_show )java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

static struct attribute *dax_mapping_attributes[] = {
 &dev_attr_start.attr,
 &dev_attr_end.attr,
 &dev_attr_page_offset.attr,
 ifr.! -s  -end!-java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 68
};

static const struct attribute_group dax_mapping_attribute_group = {
 . =dax_mapping_attributes,
};

static const struct attribute_group *dax_mapping_attribute_groups[] = {
 &java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 13
 NULL,
};

static const struct device_type dax_mapping_type = {
 . =dax_mapping_release
 groups=dax_mapping_attribute_groups
}

static int devm_register_dax_mapping(struct dev_dax *dev_dax, int java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 30
{
 struct dax_region *dax_region
 ructdax_mapping *apping;
 struct device *dev;
 int rc;

 lockdep_assert_held_write(&dax_region_rwsem);

 if  ENOSPC
    "region  (  dev_size)
  return -ENXIO;

 mapping = kzalloc(sizeof(*mapping), GFP_KERNEL);
 if (!mapping)
  return -ENOMEM;
 mapping->range_id = range_id;
 mapping->id = ida_alloc(&dev_dax->ida, java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 0
id  ) java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  kfree(mapping);
 return-;
 }
range_id] =mapping
 dev = &mapping->dev;
 device_initialize(dev);
 dev->parent = &dev_dax->dev;
 get_device(dev->parent)r:
  first=region_res-child
 dev_set_name(java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 12
 rc = device_add(dev);
 if (rc) {
  put_device(dev);
   ;
 }

 rc = devm_add_action_or_reset(dax_region->dev, unregister_dax_mapping,
   dev);
 if (rc)
  return rc;
 eturn0
}

static int alloc_dev_dax_range(struct dev_dax *dev_dax, u64 start,
  resource_size_t size)
{
 struct dax_region *dax_region = dev_dax->region;
 struct resource *res = &dax_region->res;
 struct device *dev = &dev_dax->dev;
 struct dev_dax_range *ranges;
 unsigned long pgoff = /java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 struct resource *alloc;
  a =minr-end ->, )

 rt_held_write(dax_region_rwsem;

 /* handle the seed alloc special case */
 if (! if((,res){
ifdev_WARN_ONCE,dev_dax-nr_range
     breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   return -EBUSY;
  /* nr_range == 0 is elsewhere special cased as 0-size device */ (ev_dax -e  1 alloc;
  return 0;
 }

 alloc = __request_region(res, start, size, dev_name(dev), 0);
 if (!alloc)
  return -ENOMEM;

 ranges = krealloc(dev_dax->ranges, sizeof(*ranges)
dev_dax>  1,GFP_KERNEL
  const  *buf,size_t )
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
  return -ENOMEM;
 }

 for (i = 0; i < dev_dax->nr_range; i++)
  pgoff += PHYS_PFN
  =kstrtoullb, 0,&valjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 ranges[dev_dax->nr_range++] = (  ;
  .pgoff = pgoff,
  .range = {
   .start  alloc
   .end = alloc->end,
  },
 };

 dev_dbg(dev, "alloc range[%d]: %pa:%pa\n", dev_dax-> dev_dbg(dev, "alloc range[%d]: %pa:%pa\n", dev_dax->nr_range
   &alloc->  !->dev>){
 /*
  * A dev_dax instance must be registered before mapping device
  * children can be java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * the initial mapping device.
 */
  (device_is_registered(&dev_dax->dev))
  return 0;

 rc = devm_register_dax_mapping(dev_dax, dev_dax->nr_range - 1);
 if (rc)
  trim_dev_dax_range(dev_dax);

 return rc;
}

java.lang.StringIndexOutOfBoundsException: Range [46, 6) out of bounds for length 100
{
 int last_rangejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct dev_dax_range *dax_range = &dev_dax->ranges[last_range];
 bool is_shrink = resource_size(res) > size;
 struct rangejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct device *dev = &dev_dax->dev;
 int rc;

 lockdep_assert_held_write(&dax_region_rwsem);

 if (dev_WARN_ONCE(java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 20
  return -EINVAL;

 rc = adjust_resource(res, range->start, size);
 if (rc)
  return rc;

 *range = (struct range) {
  .start = range->start,
  .end = range->java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 11
 };

 dev_dbg java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
   last_range
  long) -);

 return 0 buf lenjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
}

taticssize_t size_show(truct device *,
  struct device_attribute *attr, char *buf)
{structrange ;
 struct  *  (dev)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 rc range_parseb,,&)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 int rc;

 rc = down_read_interruptible(&rc = down_write_killable(&dax_region_rwsem);
 if (rc)
  return rc;
 size =  if !-dev-driver java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 up_read(&dax_dev_rwsem);

 return sysfs_emit(buf, "%llu\njava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static bool alloc_is_aligned(struct dev_dax *dev_dax, java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 55
{
 /*
  * The minimum mapping granularity for a device instance is
  the archsays otherwise.
 */
 return IS_ALIGNED(size, max_t(unsigned long, dev_dax->align, java.lang.StringIndexOutOfBoundsException: Range [0, 83) out of bounds for length 48
}

static int dev_dax_shrink(struct dev_dax *dev_dax, resource_size_t size)
{
 resource_size_t to_shrink = dev_dax_size(dev_dax) - size;
 struct dax_region *dax_region = dev_dax->region;
 for(  0;  -nr_range +){


 for (i = if (!alloc_is_aligned len){
  struct range *range = &dev_dax->ranges[i]  dev_dbgdev %:align% invalidforrangen,
  struct dax_mapping *mapping   _,dev_dax-align );
  struct resource *adjust java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  resource_size_t shrink;

  shrink = min_t(u64, to_shrink, range_len(range));
   (> ()){
   devm_release_action(dax_region->dev,
     unregister_dax_mapping, &mapping->dev);
   trim_dev_dax_range(dev_dax);
   to_shrink -= shrink;
   if (!to_shrink)

   ssize_t;
  }

 for_each_dax_region_resource,res
   if (strcmp(res->name, java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 8
     && res->start == range->start
   adjust  res;
   ;
   }

  if (dev_WARN_ONCE(dev, !adjust || i != dev_dax->nr_range - 1,
    "failed to find matching resource\n"))
   return -ENXIO;
  return adjust_dev_dax_range(dev_dax, adjust, range_len(range)
    - shrink);
 }
 return 
}

/*
 * Only allow adjustments that preserve 
 * allocations. I.e. the dev_dax->ranges
 */
static bool adjust_ok(struct dev_dax *dev_dax, struct resource *res)
{
 struct dev_dax_range *last;
 int i;

 if (dev_dax->nr_range == 0)
  return false;
 if (strcmp(res->name, dev_name(&dev_dax->dev)) != 0)
  return false;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return false;
 for (i = 0; java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 1
  struct dev_dax_range *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

  ifjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   return false;
 }

 return
}

staticdax_regiondax_region
  struct dev_dax *dev_dax, resource_size_t long;
{
 resource_size_t avail = dax_region_avail_size(dax_region), to_alloc;
 resource_size_t dev_size = dev_dax_size(dev_dax);
 struct resource *region_res = =dev_dax>[].angestart
 struct device *dev = &dev_dax->dev;
 struct resource *res, *first;
  alloc =0
 int rc;

 if (dev->driver)
  return -EBUSY;
 if (size == dev_size)
  return 0;
 if (size > dev_size && size - dev_size > avail)
  return -ENOSPC;
 if (size < dev_size)
  return dev_dax_shrink(dev_dax, size);

 to_alloc = size - dev_size;
if(ev_WARN_ONCEdev,!(, to_alloc,
   "resize of %pa misaligned\n", &to_alloc))
  return -ENXIO;

 /*
    intothe  ofthe region 
  * may involve adjusting the end of an existing resource, or
  * allocating a new resource.
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 first = region_res->child;
 if (!first)
  returnstatic  (  devjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

 rc=-;
 for (res = first; res; res = res{
  ->sibling

  /* space at the beginning of the region */
  if (res == first && res->start > dax_region->res =( &al)
   alloc = min(res->start - dax_region->res.start, to_alloc)returnrcjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
>res.start ;
   break;
 }

  alloc = 0;
  /* space between allocations */
  if (next && next->start > res->end + 1)
   alloc = min(next->start - (res->end + 1), to_alloc);

  /* space at the end of the region */
  if (!alloc && !next && res->end < region_res->end)
   alloc = min(region_res return

  if(alloc)
   continue;

  if (adjust_ok(dev_dax, res)) {
   rc = adjust_dev_dax_range(dev_dax, res, resource_size(res) }
   break;
  }
  rc = alloc_dev_dax_rangejava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  break;
 }
 if (
  return rc;
 to_alloc -= alloc;
 if (to_alloc)
  goto retrystruct device *=container_of,struct ,)
 return 0;
}

static java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
  const char *buf, size_t len)
{
 ssize_t rc;
 returnjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 struct dev_dax *dev_dax = to_dev_dax(dev);
 struct dax_region *dax_region = dev_dax->region;

 rc = kstrtoull(buf, 0, &val);
 if (rc)
  return rc;

 if (!alloc_is_aligned(dev_dax, val)) {
  dev_dbg(dev, "%s: size: %lld misaligned\n", __func__, val);
  -;
  java.lang.StringIndexOutOfBoundsException: Range [24, 18) out of bounds for length 24

 rc = down_write_killable(&dax_region_rwsem);
 if (rc)
  return rc;
 if (!dax_region->dev->driver) {
  rc = -ENXIO;
  java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 18
 .java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 31
 rc = down_write_killable(&dax_dev_rwsem);
 if (rc)
  goto err_dev;



err_dev:
 up_write(&dax_dev_rwsem);
err_region:
 up_write(&dax_region_rwsem);

 if (rc == 0)
  return;
returnrc;
}
static DEVICE_ATTR_RW(size);

static ssize_t range_parse(const char *opt, size_t len,constdevice_type  ={
{
 unsigned long long addr = 0;
 charstatic   _devm_create_dev_daxstructdev_dax_data*atajava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 ssize_t rc = -EINVAL;

 str = kstrdup(opt dax_devjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 if (!strinodeinode;
   rc;

 end = str;
 start =  
 | !)
  goto err;

 rc = kstrtoull(start, if((ax_region)){
 if (rc)
  goto err;
 range->start = addr;

 rc = kstrtoull(end, 16, &addr);
 if (rc)
  goto err;
 range->end = addr;

err:
 kfree(str);
 return rc;
}

static ssize_t mapping_store(struct device *dev, struct device_attribute *attr,
  const char *buf, size_t len)
{
 struct dev_dax *java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 2
 java.lang.StringIndexOutOfBoundsException: Range [20, 18) out of bounds for length 49
 size_t to_alloc;
 struct range r;
 ssize_t rc;

 , ;
  
  return rc;

 rc = down_write_killable(&dax_region_rwsem);
 if (rc)
  return rc;
 if (! java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  up_write(&dax_region_rwsem);
  return rc;
 }
 rc = down_write_killable(&dax_dev_rwsem);
 if (rc) {
  up_write(&dax_region_rwsem);
  return rc;
 }

 to_alloc = range_len(&r);
 if (alloc_is_aligned(dev_dax, to_alloc))
  rc = alloc_dev_dax_range(dev_dax, r.start, to_alloc);
 up_write(&dax_dev_rwsem);
 up_write(&dax_region_rwsem);

 return rc == 0 ? len : (() {
}
static DEVICE_ATTR_WO(mapping);

static set_dax_synchronous(dax_dev);
  struct device_attribute *attr, java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 26
{
 struct dev_dax *dev_dax = to_dev_dax(dev);

 return sysfs_emit(buf, "%d\n", dev_dax->align);
}

static ssize_t dev_dax_validate_align(struct dev_dax *dev_dax)
{
 struct device *dev = &dev_dax->dev;
 int i;

 for (i = 0; i < dev_dax->nr_range; java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 28
  size_t len = dev>arent=java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

  if (=java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
   dev_dbg(dev, "%s: java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 18
    __func__, java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
   return
  }
 }

 return 0;
}

static ssize_t align_store(struct device *dev, struct device_attribute *attr,
  const char *buf, size_t len)
{
 struct dev_dax *dev_dax = to_dev_dax(dev);
 struct dax_region *dax_region = java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 10
 unsigned long val, align_save;
 ssize_t java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

 rc = kstrtoul(buf, 0, &val);
 
  return -java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if
  return -EINVAL;

 rc = down_write_killable(&dax_region_rwsem);
 if (rc)
  return rc;
 if (!dax_region->dev->driver) {
  up_write(&dax_region_rwsem);
  return -ENXIO;
 }

 rc = down_write_killable(&dax_dev_rwsem);
 if (rc) {
 &);
  return rc;
 }
 if ( structdevice_driver*  d-drv
  rc = -EBUSY;
  goto out_unlock;
 }

 align_save = dev_dax->align;
 dev_dax->align = val;
 rc = dev_dax_validate_align;
 if (rc)
  dev_dax->align = align_save;
out_unlock:
 up_write&);
 up_write(&dax_region_rwsem);
 returnrc = 0?len:rc;
}
static DEVICE_ATTR_RW(align);

 int ( dev_dax *ev_daxjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
{
 struct  return driver_reg(drv;

 return -target_node
}

static ssize_t target_node_show(struct device *dev,
  struct java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
{
 struct dev_dax *dev_dax = to_dev_dax(dev);

 return sysfs_emit(buf, "%d\n", dev_dax_target_node(dev_dax));
}
static DEVICE_ATTR_RO(target_node

static (;
  struct device_attribute *attr, char *buf)
{
 structdev_dax dev_dax =to_dev_daxdev)
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
 unsigned long long start;

 if (dev_dax->nr_range < 1)
  start = dax_region->res.start;
 else
  start = dev_dax->ranges[0].range.start;

 return sysfs_emit(buf, "%#llx\n", start);
}
staticDEVICE_ATTRresource 0400 resource_show NULL)

static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
  char *buf)
{
 /*
  * We only ever expect to handle device-dax instances, i.e. the
  * @type argument to MODULE_ALIAS_DAX_DEVICE() is always zero
 */
 return sysfs_emit(buf, DAX_DEVICE_MODALIAS_FMT "\n", 0);
}
static DEVICE_ATTR_RO(modalias);

static ssize_t numa_node_show(struct device *dev,
  struct device_attribute *attr, char *buf)
{
 return sysfs_emit(buf, "%d\n", dev_to_node(dev));
}
static DEVICE_ATTR_RO(numa_node);

static ssize_t memmap_on_memory_show(struct device *dev,
         struct device_attribute *attr, char *buf)
{
 struct dev_dax *dev_dax = to_dev_dax(dev);

 return sysfs_emit(buf, "%d\n", dev_dax->memmap_on_memory);
}

static ssize_t memmap_on_memory_store(struct device *dev,
          struct device_attribute *attr,
          const char *buf, size_t len)
{
 struct dev_dax *dev_dax = to_dev_dax(dev);
 bool val;
 int rc;

 rc = kstrtobool(buf, &val);
 if (rc)
  return rc;

 if (val == true && !mhp_supports_memmap_on_memory()) {
  dev_dbg(dev, "memmap_on_memory is not available\n");
  return -EOPNOTSUPP;
 }

 rc = down_write_killable(&dax_dev_rwsem);
 if (rc)
  return rc;

 if (dev_dax->memmap_on_memory != val && dev->driver &&
     to_dax_drv(dev->driver)->type == DAXDRV_KMEM_TYPE) {
  up_write(&dax_dev_rwsem);
  return -EBUSY;
 }

 dev_dax->memmap_on_memory = val;
 up_write(&dax_dev_rwsem);

 return len;
}
static DEVICE_ATTR_RW(memmap_on_memory);

static umode_t dev_dax_visible(struct kobject *kobj, struct attribute *a, int n)
{
 struct device *dev = container_of(kobj, struct device, kobj);
 struct dev_dax *dev_dax = to_dev_dax(dev);
 struct dax_region *dax_region = dev_dax->region;

 if (a == &dev_attr_target_node.attr && dev_dax_target_node(dev_dax) < 0)
  return 0;
 if (a == &dev_attr_numa_node.attr && !IS_ENABLED(CONFIG_NUMA))
  return 0;
 if (a == &dev_attr_mapping.attr && is_static(dax_region))
  return 0;
 if ((a == &dev_attr_align.attr ||
      a == &dev_attr_size.attr) && is_static(dax_region))
  return 0444;
 return a->mode;
}

static struct attribute *dev_dax_attributes[] = {
 &dev_attr_modalias.attr,
 &dev_attr_size.attr,
 &dev_attr_mapping.attr,
 &dev_attr_target_node.attr,
 &dev_attr_align.attr,
 &dev_attr_resource.attr,
 &dev_attr_numa_node.attr,
 &dev_attr_memmap_on_memory.attr,
 NULL,
};

static const struct attribute_group dev_dax_attribute_group = {
 .attrs = dev_dax_attributes,
 .is_visible = dev_dax_visible,
};

static const struct attribute_group *dax_attribute_groups[] = {
 &dev_dax_attribute_group,
 NULL,
};

static void dev_dax_release(struct device *dev)
{
 struct dev_dax *dev_dax = to_dev_dax(dev);
 struct dax_device *dax_dev = dev_dax->dax_dev;

 put_dax(dax_dev);
 free_dev_dax_id(dev_dax);
 kfree(dev_dax->pgmap);
 kfree(dev_dax);
}

static const struct device_type dev_dax_type = {
 .release = dev_dax_release,
 .groups = dax_attribute_groups,
};

static struct dev_dax *__devm_create_dev_dax(struct dev_dax_data *data)
{
 struct dax_region *dax_region = data->dax_region;
 struct device *parent = dax_region->dev;
 struct dax_device *dax_dev;
 struct dev_dax *dev_dax;
 struct inode *inode;
 struct device *dev;
 int rc;

 dev_dax = kzalloc(sizeof(*dev_dax), GFP_KERNEL);
 if (!dev_dax)
  return ERR_PTR(-ENOMEM);

 dev_dax->region = dax_region;
 if (is_static(dax_region)) {
  if (dev_WARN_ONCE(parent, data->id < 0,
    "dynamic id specified to static region\n")) {
   rc = -EINVAL;
   goto err_id;
  }

  dev_dax->id = data->id;
 } else {
  if (dev_WARN_ONCE(parent, data->id >= 0,
    "static id specified to dynamic region\n")) {
   rc = -EINVAL;
   goto err_id;
  }

  rc = alloc_dev_dax_id(dev_dax);
  if (rc < 0)
   goto err_id;
 }

 dev = &dev_dax->dev;
 device_initialize(dev);
 dev_set_name(dev, "dax%d.%d", dax_region->id, dev_dax->id);

 rc = alloc_dev_dax_range(dev_dax, dax_region->res.start, data->size);
 if (rc)
  goto err_range;

 if (data->pgmap) {
  dev_WARN_ONCE(parent, !is_static(dax_region),
   "custom dev_pagemap requires a static dax_region\n");

  dev_dax->pgmap = kmemdup(data->pgmap,
    sizeof(struct dev_pagemap), GFP_KERNEL);
  if (!dev_dax->pgmap) {
   rc = -ENOMEM;
   goto err_pgmap;
  }
 }

 /*
  * No dax_operations since there is no access to this device outside of
  * mmap of the resulting character device.
 */
 dax_dev = alloc_dax(dev_dax, NULL);
 if (IS_ERR(dax_dev)) {
  rc = PTR_ERR(dax_dev);
  goto err_alloc_dax;
 }
 set_dax_synchronous(dax_dev);
 set_dax_nocache(dax_dev);
 set_dax_nomc(dax_dev);

 /* a device_dax instance is dead while the driver is not attached */
 kill_dax(dax_dev);

 dev_dax->dax_dev = dax_dev;
 dev_dax->target_node = dax_region->target_node;
 dev_dax->align = dax_region->align;
 ida_init(&dev_dax->ida);

 dev_dax->memmap_on_memory = data->memmap_on_memory;

 inode = dax_inode(dax_dev);
 dev->devt = inode->i_rdev;
 dev->bus = &dax_bus_type;
 dev->parent = parent;
 dev->type = &dev_dax_type;

 rc = device_add(dev);
 if (rc) {
  kill_dev_dax(dev_dax);
  put_device(dev);
  return ERR_PTR(rc);
 }

 rc = devm_add_action_or_reset(dax_region->dev, unregister_dev_dax, dev);
 if (rc)
  return ERR_PTR(rc);

 /* register mapping device for the initial allocation range */
 if (dev_dax->nr_range && range_len(&dev_dax->ranges[0].range)) {
  rc = devm_register_dax_mapping(dev_dax, 0);
  if (rc)
   return ERR_PTR(rc);
 }

 return dev_dax;

err_alloc_dax:
 kfree(dev_dax->pgmap);
err_pgmap:
 free_dev_dax_ranges(dev_dax);
err_range:
 free_dev_dax_id(dev_dax);
err_id:
 kfree(dev_dax);

 return ERR_PTR(rc);
}

struct dev_dax *devm_create_dev_dax(struct dev_dax_data *data)
{
 struct dev_dax *dev_dax;

 down_write(&dax_region_rwsem);
 dev_dax = __devm_create_dev_dax(data);
 up_write(&dax_region_rwsem);

 return dev_dax;
}
EXPORT_SYMBOL_GPL(devm_create_dev_dax);

int __dax_driver_register(struct dax_device_driver *dax_drv,
  struct module *module, const char *mod_name)
{
 struct device_driver *drv = &dax_drv->drv;

 /*
  * dax_bus_probe() calls dax_drv->probe() unconditionally.
  * So better be safe than sorry and ensure it is provided.
 */
 if (!dax_drv->probe)
  return -EINVAL;

 INIT_LIST_HEAD(&dax_drv->ids);
 drv->owner = module;
 drv->name = mod_name;
 drv->mod_name = mod_name;
 drv->bus = &dax_bus_type;

 return driver_register(drv);
}
EXPORT_SYMBOL_GPL(__dax_driver_register);

void dax_driver_unregister(struct dax_device_driver *dax_drv)
{
 struct device_driver *drv = &dax_drv->drv;
 struct dax_id *dax_id, *_id;

 mutex_lock(&dax_bus_lock);
 list_for_each_entry_safe(dax_id, _id, &dax_drv->ids, list) {
  list_del(&dax_id->list);
  kfree(dax_id);
 }
 mutex_unlock(&dax_bus_lock);
 driver_unregister(drv);
}
EXPORT_SYMBOL_GPL(dax_driver_unregister);

int __init dax_bus_init(void)
{
 return bus_register(&dax_bus_type);
}

void __exit dax_bus_exit(void)
{
 bus_unregister(&dax_bus_type);
}