| Message ID | 20230721012932.190742-5-ying.huang@intel.com (mailing list archive) |
|---|---|
| State | New |
| Headers | show |
| Series | memory tiering: calculate abstract distance based on ACPI HMAT | expand |
Huang Ying <ying.huang@intel.com> writes: > Previously, a fixed abstract distance MEMTIER_DEFAULT_DAX_ADISTANCE is > used for slow memory type in kmem driver. This limits the usage of > kmem driver, for example, it cannot be used for HBM (high bandwidth > memory). > > So, we use the general abstract distance calculation mechanism in kmem > drivers to get more accurate abstract distance on systems with proper > support. The original MEMTIER_DEFAULT_DAX_ADISTANCE is used as > fallback only. > > Now, multiple memory types may be managed by kmem. These memory types > are put into the "kmem_memory_types" list and protected by > kmem_memory_type_lock. See below but I wonder if kmem_memory_types could be a common helper rather than kdax specific? > Signed-off-by: "Huang, Ying" <ying.huang@intel.com> > Cc: Aneesh Kumar K.V <aneesh.kumar@linux.ibm.com> > Cc: Wei Xu <weixugc@google.com> > Cc: Alistair Popple <apopple@nvidia.com> > Cc: Dan Williams <dan.j.williams@intel.com> > Cc: Dave Hansen <dave.hansen@intel.com> > Cc: Davidlohr Bueso <dave@stgolabs.net> > Cc: Johannes Weiner <hannes@cmpxchg.org> > Cc: Jonathan Cameron <Jonathan.Cameron@huawei.com> > Cc: Michal Hocko <mhocko@kernel.org> > Cc: Yang Shi <shy828301@gmail.com> > Cc: Rafael J Wysocki <rafael.j.wysocki@intel.com> > --- > drivers/dax/kmem.c | 54 +++++++++++++++++++++++++++--------- > include/linux/memory-tiers.h | 2 ++ > mm/memory-tiers.c | 2 +- > 3 files changed, 44 insertions(+), 14 deletions(-) > > diff --git a/drivers/dax/kmem.c b/drivers/dax/kmem.c > index 898ca9505754..837165037231 100644 > --- a/drivers/dax/kmem.c > +++ b/drivers/dax/kmem.c > @@ -49,14 +49,40 @@ struct dax_kmem_data { > struct resource *res[]; > }; > > -static struct memory_dev_type *dax_slowmem_type; > +static DEFINE_MUTEX(kmem_memory_type_lock); > +static LIST_HEAD(kmem_memory_types); > + > +static struct memory_dev_type *kmem_find_alloc_memorty_type(int adist) > +{ > + bool found = false; > + struct memory_dev_type *mtype; > + > + mutex_lock(&kmem_memory_type_lock); > + list_for_each_entry(mtype, &kmem_memory_types, list) { > + if (mtype->adistance == adist) { > + found = true; > + break; > + } > + } > + if (!found) { > + mtype = alloc_memory_type(adist); > + if (!IS_ERR(mtype)) > + list_add(&mtype->list, &kmem_memory_types); > + } > + mutex_unlock(&kmem_memory_type_lock); > + > + return mtype; > +} > + > static int dev_dax_kmem_probe(struct dev_dax *dev_dax) > { > struct device *dev = &dev_dax->dev; > unsigned long total_len = 0; > struct dax_kmem_data *data; > + struct memory_dev_type *mtype; > int i, rc, mapped = 0; > int numa_node; > + int adist = MEMTIER_DEFAULT_DAX_ADISTANCE; > > /* > * Ensure good NUMA information for the persistent memory. > @@ -71,6 +97,11 @@ static int dev_dax_kmem_probe(struct dev_dax *dev_dax) > return -EINVAL; > } > > + mt_calc_adistance(numa_node, &adist); > + mtype = kmem_find_alloc_memorty_type(adist); > + if (IS_ERR(mtype)) > + return PTR_ERR(mtype); > + I wrote my own quick and dirty module to test this and wrote basically the same code sequence. I notice your using a list of memory types here though. I think it would be nice to have a common helper that other users could call to do the mt_calc_adistance() / kmem_find_alloc_memory_type() / init_node_memory_type() sequence and cleanup as my naive approach would result in a new memory_dev_type per device even though adist might be the same. A common helper would make it easy to de-dup those. > for (i = 0; i < dev_dax->nr_range; i++) { > struct range range; > > @@ -88,7 +119,7 @@ static int dev_dax_kmem_probe(struct dev_dax *dev_dax) > return -EINVAL; > } > > - init_node_memory_type(numa_node, dax_slowmem_type); > + init_node_memory_type(numa_node, mtype); > > rc = -ENOMEM; > data = kzalloc(struct_size(data, res, dev_dax->nr_range), GFP_KERNEL); > @@ -167,7 +198,7 @@ static int dev_dax_kmem_probe(struct dev_dax *dev_dax) > err_res_name: > kfree(data); > err_dax_kmem_data: > - clear_node_memory_type(numa_node, dax_slowmem_type); > + clear_node_memory_type(numa_node, mtype); > return rc; > } > > @@ -219,7 +250,7 @@ static void dev_dax_kmem_remove(struct dev_dax *dev_dax) > * for that. This implies this reference will be around > * till next reboot. > */ > - clear_node_memory_type(node, dax_slowmem_type); > + clear_node_memory_type(node, NULL); > } > } > #else > @@ -251,12 +282,6 @@ static int __init dax_kmem_init(void) > if (!kmem_name) > return -ENOMEM; > > - dax_slowmem_type = alloc_memory_type(MEMTIER_DEFAULT_DAX_ADISTANCE); > - if (IS_ERR(dax_slowmem_type)) { > - rc = PTR_ERR(dax_slowmem_type); > - goto err_dax_slowmem_type; > - } > - > rc = dax_driver_register(&device_dax_kmem_driver); > if (rc) > goto error_dax_driver; > @@ -264,18 +289,21 @@ static int __init dax_kmem_init(void) > return rc; > > error_dax_driver: > - destroy_memory_type(dax_slowmem_type); > -err_dax_slowmem_type: > kfree_const(kmem_name); > return rc; > } > > static void __exit dax_kmem_exit(void) > { > + struct memory_dev_type *mtype, *mtn; > + > dax_driver_unregister(&device_dax_kmem_driver); > if (!any_hotremove_failed) > kfree_const(kmem_name); > - destroy_memory_type(dax_slowmem_type); > + list_for_each_entry_safe(mtype, mtn, &kmem_memory_types, list) { > + list_del(&mtype->list); > + destroy_memory_type(mtype); > + } > } > > MODULE_AUTHOR("Intel Corporation"); > diff --git a/include/linux/memory-tiers.h b/include/linux/memory-tiers.h > index 9377239c8d34..aca22220cb5c 100644 > --- a/include/linux/memory-tiers.h > +++ b/include/linux/memory-tiers.h > @@ -24,6 +24,8 @@ struct memory_tier; > struct memory_dev_type { > /* list of memory types that are part of same tier as this type */ > struct list_head tier_sibiling; > + /* list of memory types that are managed by one driver */ > + struct list_head list; > /* abstract distance for this specific memory type */ > int adistance; > /* Nodes of same abstract distance */ > diff --git a/mm/memory-tiers.c b/mm/memory-tiers.c > index 9a734ef2edfb..38005c60fa2d 100644 > --- a/mm/memory-tiers.c > +++ b/mm/memory-tiers.c > @@ -581,7 +581,7 @@ EXPORT_SYMBOL_GPL(init_node_memory_type); > void clear_node_memory_type(int node, struct memory_dev_type *memtype) > { > mutex_lock(&memory_tier_lock); > - if (node_memory_types[node].memtype == memtype) > + if (node_memory_types[node].memtype == memtype || !memtype) > node_memory_types[node].map_count--; > /* > * If we umapped all the attached devices to this node,
Alistair Popple <apopple@nvidia.com> writes: > Huang Ying <ying.huang@intel.com> writes: > >> Previously, a fixed abstract distance MEMTIER_DEFAULT_DAX_ADISTANCE is >> used for slow memory type in kmem driver. This limits the usage of >> kmem driver, for example, it cannot be used for HBM (high bandwidth >> memory). >> >> So, we use the general abstract distance calculation mechanism in kmem >> drivers to get more accurate abstract distance on systems with proper >> support. The original MEMTIER_DEFAULT_DAX_ADISTANCE is used as >> fallback only. >> >> Now, multiple memory types may be managed by kmem. These memory types >> are put into the "kmem_memory_types" list and protected by >> kmem_memory_type_lock. > > See below but I wonder if kmem_memory_types could be a common helper > rather than kdax specific? > >> Signed-off-by: "Huang, Ying" <ying.huang@intel.com> >> Cc: Aneesh Kumar K.V <aneesh.kumar@linux.ibm.com> >> Cc: Wei Xu <weixugc@google.com> >> Cc: Alistair Popple <apopple@nvidia.com> >> Cc: Dan Williams <dan.j.williams@intel.com> >> Cc: Dave Hansen <dave.hansen@intel.com> >> Cc: Davidlohr Bueso <dave@stgolabs.net> >> Cc: Johannes Weiner <hannes@cmpxchg.org> >> Cc: Jonathan Cameron <Jonathan.Cameron@huawei.com> >> Cc: Michal Hocko <mhocko@kernel.org> >> Cc: Yang Shi <shy828301@gmail.com> >> Cc: Rafael J Wysocki <rafael.j.wysocki@intel.com> >> --- >> drivers/dax/kmem.c | 54 +++++++++++++++++++++++++++--------- >> include/linux/memory-tiers.h | 2 ++ >> mm/memory-tiers.c | 2 +- >> 3 files changed, 44 insertions(+), 14 deletions(-) >> >> diff --git a/drivers/dax/kmem.c b/drivers/dax/kmem.c >> index 898ca9505754..837165037231 100644 >> --- a/drivers/dax/kmem.c >> +++ b/drivers/dax/kmem.c >> @@ -49,14 +49,40 @@ struct dax_kmem_data { >> struct resource *res[]; >> }; >> >> -static struct memory_dev_type *dax_slowmem_type; >> +static DEFINE_MUTEX(kmem_memory_type_lock); >> +static LIST_HEAD(kmem_memory_types); >> + >> +static struct memory_dev_type *kmem_find_alloc_memorty_type(int adist) >> +{ >> + bool found = false; >> + struct memory_dev_type *mtype; >> + >> + mutex_lock(&kmem_memory_type_lock); >> + list_for_each_entry(mtype, &kmem_memory_types, list) { >> + if (mtype->adistance == adist) { >> + found = true; >> + break; >> + } >> + } >> + if (!found) { >> + mtype = alloc_memory_type(adist); >> + if (!IS_ERR(mtype)) >> + list_add(&mtype->list, &kmem_memory_types); >> + } >> + mutex_unlock(&kmem_memory_type_lock); >> + >> + return mtype; >> +} >> + >> static int dev_dax_kmem_probe(struct dev_dax *dev_dax) >> { >> struct device *dev = &dev_dax->dev; >> unsigned long total_len = 0; >> struct dax_kmem_data *data; >> + struct memory_dev_type *mtype; >> int i, rc, mapped = 0; >> int numa_node; >> + int adist = MEMTIER_DEFAULT_DAX_ADISTANCE; >> >> /* >> * Ensure good NUMA information for the persistent memory. >> @@ -71,6 +97,11 @@ static int dev_dax_kmem_probe(struct dev_dax *dev_dax) >> return -EINVAL; >> } >> >> + mt_calc_adistance(numa_node, &adist); >> + mtype = kmem_find_alloc_memorty_type(adist); >> + if (IS_ERR(mtype)) >> + return PTR_ERR(mtype); >> + > > I wrote my own quick and dirty module to test this and wrote basically > the same code sequence. > > I notice your using a list of memory types here though. I think it would > be nice to have a common helper that other users could call to do the > mt_calc_adistance() / kmem_find_alloc_memory_type() / > init_node_memory_type() sequence and cleanup as my naive approach would > result in a new memory_dev_type per device even though adist might be > the same. A common helper would make it easy to de-dup those. If it's useful, we can move kmem_find_alloc_memory_type() to memory-tier.c after some revision. But I tend to move it after we have the second user. What do you think about that? -- Best Regards, Huang, Ying >> for (i = 0; i < dev_dax->nr_range; i++) { >> struct range range; >> >> @@ -88,7 +119,7 @@ static int dev_dax_kmem_probe(struct dev_dax *dev_dax) >> return -EINVAL; >> } >> >> - init_node_memory_type(numa_node, dax_slowmem_type); >> + init_node_memory_type(numa_node, mtype); >> >> rc = -ENOMEM; >> data = kzalloc(struct_size(data, res, dev_dax->nr_range), GFP_KERNEL); >> @@ -167,7 +198,7 @@ static int dev_dax_kmem_probe(struct dev_dax *dev_dax) >> err_res_name: >> kfree(data); >> err_dax_kmem_data: >> - clear_node_memory_type(numa_node, dax_slowmem_type); >> + clear_node_memory_type(numa_node, mtype); >> return rc; >> } >> >> @@ -219,7 +250,7 @@ static void dev_dax_kmem_remove(struct dev_dax *dev_dax) >> * for that. This implies this reference will be around >> * till next reboot. >> */ >> - clear_node_memory_type(node, dax_slowmem_type); >> + clear_node_memory_type(node, NULL); >> } >> } >> #else >> @@ -251,12 +282,6 @@ static int __init dax_kmem_init(void) >> if (!kmem_name) >> return -ENOMEM; >> >> - dax_slowmem_type = alloc_memory_type(MEMTIER_DEFAULT_DAX_ADISTANCE); >> - if (IS_ERR(dax_slowmem_type)) { >> - rc = PTR_ERR(dax_slowmem_type); >> - goto err_dax_slowmem_type; >> - } >> - >> rc = dax_driver_register(&device_dax_kmem_driver); >> if (rc) >> goto error_dax_driver; >> @@ -264,18 +289,21 @@ static int __init dax_kmem_init(void) >> return rc; >> >> error_dax_driver: >> - destroy_memory_type(dax_slowmem_type); >> -err_dax_slowmem_type: >> kfree_const(kmem_name); >> return rc; >> } >> >> static void __exit dax_kmem_exit(void) >> { >> + struct memory_dev_type *mtype, *mtn; >> + >> dax_driver_unregister(&device_dax_kmem_driver); >> if (!any_hotremove_failed) >> kfree_const(kmem_name); >> - destroy_memory_type(dax_slowmem_type); >> + list_for_each_entry_safe(mtype, mtn, &kmem_memory_types, list) { >> + list_del(&mtype->list); >> + destroy_memory_type(mtype); >> + } >> } >> >> MODULE_AUTHOR("Intel Corporation"); >> diff --git a/include/linux/memory-tiers.h b/include/linux/memory-tiers.h >> index 9377239c8d34..aca22220cb5c 100644 >> --- a/include/linux/memory-tiers.h >> +++ b/include/linux/memory-tiers.h >> @@ -24,6 +24,8 @@ struct memory_tier; >> struct memory_dev_type { >> /* list of memory types that are part of same tier as this type */ >> struct list_head tier_sibiling; >> + /* list of memory types that are managed by one driver */ >> + struct list_head list; >> /* abstract distance for this specific memory type */ >> int adistance; >> /* Nodes of same abstract distance */ >> diff --git a/mm/memory-tiers.c b/mm/memory-tiers.c >> index 9a734ef2edfb..38005c60fa2d 100644 >> --- a/mm/memory-tiers.c >> +++ b/mm/memory-tiers.c >> @@ -581,7 +581,7 @@ EXPORT_SYMBOL_GPL(init_node_memory_type); >> void clear_node_memory_type(int node, struct memory_dev_type *memtype) >> { >> mutex_lock(&memory_tier_lock); >> - if (node_memory_types[node].memtype == memtype) >> + if (node_memory_types[node].memtype == memtype || !memtype) >> node_memory_types[node].map_count--; >> /* >> * If we umapped all the attached devices to this node,
"Huang, Ying" <ying.huang@intel.com> writes: > Alistair Popple <apopple@nvidia.com> writes: > >> Huang Ying <ying.huang@intel.com> writes: >> >>> Previously, a fixed abstract distance MEMTIER_DEFAULT_DAX_ADISTANCE is >>> used for slow memory type in kmem driver. This limits the usage of >>> kmem driver, for example, it cannot be used for HBM (high bandwidth >>> memory). >>> >>> So, we use the general abstract distance calculation mechanism in kmem >>> drivers to get more accurate abstract distance on systems with proper >>> support. The original MEMTIER_DEFAULT_DAX_ADISTANCE is used as >>> fallback only. >>> >>> Now, multiple memory types may be managed by kmem. These memory types >>> are put into the "kmem_memory_types" list and protected by >>> kmem_memory_type_lock. >> >> See below but I wonder if kmem_memory_types could be a common helper >> rather than kdax specific? >> >>> Signed-off-by: "Huang, Ying" <ying.huang@intel.com> >>> Cc: Aneesh Kumar K.V <aneesh.kumar@linux.ibm.com> >>> Cc: Wei Xu <weixugc@google.com> >>> Cc: Alistair Popple <apopple@nvidia.com> >>> Cc: Dan Williams <dan.j.williams@intel.com> >>> Cc: Dave Hansen <dave.hansen@intel.com> >>> Cc: Davidlohr Bueso <dave@stgolabs.net> >>> Cc: Johannes Weiner <hannes@cmpxchg.org> >>> Cc: Jonathan Cameron <Jonathan.Cameron@huawei.com> >>> Cc: Michal Hocko <mhocko@kernel.org> >>> Cc: Yang Shi <shy828301@gmail.com> >>> Cc: Rafael J Wysocki <rafael.j.wysocki@intel.com> >>> --- >>> drivers/dax/kmem.c | 54 +++++++++++++++++++++++++++--------- >>> include/linux/memory-tiers.h | 2 ++ >>> mm/memory-tiers.c | 2 +- >>> 3 files changed, 44 insertions(+), 14 deletions(-) >>> >>> diff --git a/drivers/dax/kmem.c b/drivers/dax/kmem.c >>> index 898ca9505754..837165037231 100644 >>> --- a/drivers/dax/kmem.c >>> +++ b/drivers/dax/kmem.c >>> @@ -49,14 +49,40 @@ struct dax_kmem_data { >>> struct resource *res[]; >>> }; >>> >>> -static struct memory_dev_type *dax_slowmem_type; >>> +static DEFINE_MUTEX(kmem_memory_type_lock); >>> +static LIST_HEAD(kmem_memory_types); >>> + >>> +static struct memory_dev_type *kmem_find_alloc_memorty_type(int adist) >>> +{ >>> + bool found = false; >>> + struct memory_dev_type *mtype; >>> + >>> + mutex_lock(&kmem_memory_type_lock); >>> + list_for_each_entry(mtype, &kmem_memory_types, list) { >>> + if (mtype->adistance == adist) { >>> + found = true; >>> + break; >>> + } >>> + } >>> + if (!found) { >>> + mtype = alloc_memory_type(adist); >>> + if (!IS_ERR(mtype)) >>> + list_add(&mtype->list, &kmem_memory_types); >>> + } >>> + mutex_unlock(&kmem_memory_type_lock); >>> + >>> + return mtype; >>> +} >>> + >>> static int dev_dax_kmem_probe(struct dev_dax *dev_dax) >>> { >>> struct device *dev = &dev_dax->dev; >>> unsigned long total_len = 0; >>> struct dax_kmem_data *data; >>> + struct memory_dev_type *mtype; >>> int i, rc, mapped = 0; >>> int numa_node; >>> + int adist = MEMTIER_DEFAULT_DAX_ADISTANCE; >>> >>> /* >>> * Ensure good NUMA information for the persistent memory. >>> @@ -71,6 +97,11 @@ static int dev_dax_kmem_probe(struct dev_dax *dev_dax) >>> return -EINVAL; >>> } >>> >>> + mt_calc_adistance(numa_node, &adist); >>> + mtype = kmem_find_alloc_memorty_type(adist); >>> + if (IS_ERR(mtype)) >>> + return PTR_ERR(mtype); >>> + >> >> I wrote my own quick and dirty module to test this and wrote basically >> the same code sequence. >> >> I notice your using a list of memory types here though. I think it would >> be nice to have a common helper that other users could call to do the >> mt_calc_adistance() / kmem_find_alloc_memory_type() / >> init_node_memory_type() sequence and cleanup as my naive approach would >> result in a new memory_dev_type per device even though adist might be >> the same. A common helper would make it easy to de-dup those. > > If it's useful, we can move kmem_find_alloc_memory_type() to > memory-tier.c after some revision. But I tend to move it after we have > the second user. What do you think about that? Usually I would agree, but this series already introduces a general interface for calculating adist even though there's only one user and implementation. So if we're going to add a general interface I think it would be better to make it more usable now rather than after variations of it have been cut and pasted into other drivers.
Alistair Popple <apopple@nvidia.com> writes: > "Huang, Ying" <ying.huang@intel.com> writes: > >> Alistair Popple <apopple@nvidia.com> writes: >> >>> Huang Ying <ying.huang@intel.com> writes: >>> >>>> Previously, a fixed abstract distance MEMTIER_DEFAULT_DAX_ADISTANCE is >>>> used for slow memory type in kmem driver. This limits the usage of >>>> kmem driver, for example, it cannot be used for HBM (high bandwidth >>>> memory). >>>> >>>> So, we use the general abstract distance calculation mechanism in kmem >>>> drivers to get more accurate abstract distance on systems with proper >>>> support. The original MEMTIER_DEFAULT_DAX_ADISTANCE is used as >>>> fallback only. >>>> >>>> Now, multiple memory types may be managed by kmem. These memory types >>>> are put into the "kmem_memory_types" list and protected by >>>> kmem_memory_type_lock. >>> >>> See below but I wonder if kmem_memory_types could be a common helper >>> rather than kdax specific? >>> >>>> Signed-off-by: "Huang, Ying" <ying.huang@intel.com> >>>> Cc: Aneesh Kumar K.V <aneesh.kumar@linux.ibm.com> >>>> Cc: Wei Xu <weixugc@google.com> >>>> Cc: Alistair Popple <apopple@nvidia.com> >>>> Cc: Dan Williams <dan.j.williams@intel.com> >>>> Cc: Dave Hansen <dave.hansen@intel.com> >>>> Cc: Davidlohr Bueso <dave@stgolabs.net> >>>> Cc: Johannes Weiner <hannes@cmpxchg.org> >>>> Cc: Jonathan Cameron <Jonathan.Cameron@huawei.com> >>>> Cc: Michal Hocko <mhocko@kernel.org> >>>> Cc: Yang Shi <shy828301@gmail.com> >>>> Cc: Rafael J Wysocki <rafael.j.wysocki@intel.com> >>>> --- >>>> drivers/dax/kmem.c | 54 +++++++++++++++++++++++++++--------- >>>> include/linux/memory-tiers.h | 2 ++ >>>> mm/memory-tiers.c | 2 +- >>>> 3 files changed, 44 insertions(+), 14 deletions(-) >>>> >>>> diff --git a/drivers/dax/kmem.c b/drivers/dax/kmem.c >>>> index 898ca9505754..837165037231 100644 >>>> --- a/drivers/dax/kmem.c >>>> +++ b/drivers/dax/kmem.c >>>> @@ -49,14 +49,40 @@ struct dax_kmem_data { >>>> struct resource *res[]; >>>> }; >>>> >>>> -static struct memory_dev_type *dax_slowmem_type; >>>> +static DEFINE_MUTEX(kmem_memory_type_lock); >>>> +static LIST_HEAD(kmem_memory_types); >>>> + >>>> +static struct memory_dev_type *kmem_find_alloc_memorty_type(int adist) >>>> +{ >>>> + bool found = false; >>>> + struct memory_dev_type *mtype; >>>> + >>>> + mutex_lock(&kmem_memory_type_lock); >>>> + list_for_each_entry(mtype, &kmem_memory_types, list) { >>>> + if (mtype->adistance == adist) { >>>> + found = true; >>>> + break; >>>> + } >>>> + } >>>> + if (!found) { >>>> + mtype = alloc_memory_type(adist); >>>> + if (!IS_ERR(mtype)) >>>> + list_add(&mtype->list, &kmem_memory_types); >>>> + } >>>> + mutex_unlock(&kmem_memory_type_lock); >>>> + >>>> + return mtype; >>>> +} >>>> + >>>> static int dev_dax_kmem_probe(struct dev_dax *dev_dax) >>>> { >>>> struct device *dev = &dev_dax->dev; >>>> unsigned long total_len = 0; >>>> struct dax_kmem_data *data; >>>> + struct memory_dev_type *mtype; >>>> int i, rc, mapped = 0; >>>> int numa_node; >>>> + int adist = MEMTIER_DEFAULT_DAX_ADISTANCE; >>>> >>>> /* >>>> * Ensure good NUMA information for the persistent memory. >>>> @@ -71,6 +97,11 @@ static int dev_dax_kmem_probe(struct dev_dax *dev_dax) >>>> return -EINVAL; >>>> } >>>> >>>> + mt_calc_adistance(numa_node, &adist); >>>> + mtype = kmem_find_alloc_memorty_type(adist); >>>> + if (IS_ERR(mtype)) >>>> + return PTR_ERR(mtype); >>>> + >>> >>> I wrote my own quick and dirty module to test this and wrote basically >>> the same code sequence. >>> >>> I notice your using a list of memory types here though. I think it would >>> be nice to have a common helper that other users could call to do the >>> mt_calc_adistance() / kmem_find_alloc_memory_type() / >>> init_node_memory_type() sequence and cleanup as my naive approach would >>> result in a new memory_dev_type per device even though adist might be >>> the same. A common helper would make it easy to de-dup those. >> >> If it's useful, we can move kmem_find_alloc_memory_type() to >> memory-tier.c after some revision. But I tend to move it after we have >> the second user. What do you think about that? > > Usually I would agree, but this series already introduces a general > interface for calculating adist even though there's only one user and > implementation. So if we're going to add a general interface I think it > would be better to make it more usable now rather than after variations > of it have been cut and pasted into other drivers. In general, I would like to introduce complexity when necessary. So, we can discuss the necessity of the general interface firstly. We can do that in [1/4] of the series. -- Best Regards, Huang, Ying
"Huang, Ying" <ying.huang@intel.com> writes: > Alistair Popple <apopple@nvidia.com> writes: > >> "Huang, Ying" <ying.huang@intel.com> writes: >> >>> Alistair Popple <apopple@nvidia.com> writes: >>> >>>> Huang Ying <ying.huang@intel.com> writes: >>>> >>>>> Previously, a fixed abstract distance MEMTIER_DEFAULT_DAX_ADISTANCE is >>>>> used for slow memory type in kmem driver. This limits the usage of >>>>> kmem driver, for example, it cannot be used for HBM (high bandwidth >>>>> memory). >>>>> >>>>> So, we use the general abstract distance calculation mechanism in kmem >>>>> drivers to get more accurate abstract distance on systems with proper >>>>> support. The original MEMTIER_DEFAULT_DAX_ADISTANCE is used as >>>>> fallback only. >>>>> >>>>> Now, multiple memory types may be managed by kmem. These memory types >>>>> are put into the "kmem_memory_types" list and protected by >>>>> kmem_memory_type_lock. >>>> >>>> See below but I wonder if kmem_memory_types could be a common helper >>>> rather than kdax specific? >>>> >>>>> Signed-off-by: "Huang, Ying" <ying.huang@intel.com> >>>>> Cc: Aneesh Kumar K.V <aneesh.kumar@linux.ibm.com> >>>>> Cc: Wei Xu <weixugc@google.com> >>>>> Cc: Alistair Popple <apopple@nvidia.com> >>>>> Cc: Dan Williams <dan.j.williams@intel.com> >>>>> Cc: Dave Hansen <dave.hansen@intel.com> >>>>> Cc: Davidlohr Bueso <dave@stgolabs.net> >>>>> Cc: Johannes Weiner <hannes@cmpxchg.org> >>>>> Cc: Jonathan Cameron <Jonathan.Cameron@huawei.com> >>>>> Cc: Michal Hocko <mhocko@kernel.org> >>>>> Cc: Yang Shi <shy828301@gmail.com> >>>>> Cc: Rafael J Wysocki <rafael.j.wysocki@intel.com> >>>>> --- >>>>> drivers/dax/kmem.c | 54 +++++++++++++++++++++++++++--------- >>>>> include/linux/memory-tiers.h | 2 ++ >>>>> mm/memory-tiers.c | 2 +- >>>>> 3 files changed, 44 insertions(+), 14 deletions(-) >>>>> >>>>> diff --git a/drivers/dax/kmem.c b/drivers/dax/kmem.c >>>>> index 898ca9505754..837165037231 100644 >>>>> --- a/drivers/dax/kmem.c >>>>> +++ b/drivers/dax/kmem.c >>>>> @@ -49,14 +49,40 @@ struct dax_kmem_data { >>>>> struct resource *res[]; >>>>> }; >>>>> >>>>> -static struct memory_dev_type *dax_slowmem_type; >>>>> +static DEFINE_MUTEX(kmem_memory_type_lock); >>>>> +static LIST_HEAD(kmem_memory_types); >>>>> + >>>>> +static struct memory_dev_type *kmem_find_alloc_memorty_type(int adist) >>>>> +{ >>>>> + bool found = false; >>>>> + struct memory_dev_type *mtype; >>>>> + >>>>> + mutex_lock(&kmem_memory_type_lock); >>>>> + list_for_each_entry(mtype, &kmem_memory_types, list) { >>>>> + if (mtype->adistance == adist) { >>>>> + found = true; >>>>> + break; >>>>> + } >>>>> + } >>>>> + if (!found) { >>>>> + mtype = alloc_memory_type(adist); >>>>> + if (!IS_ERR(mtype)) >>>>> + list_add(&mtype->list, &kmem_memory_types); >>>>> + } >>>>> + mutex_unlock(&kmem_memory_type_lock); >>>>> + >>>>> + return mtype; >>>>> +} >>>>> + >>>>> static int dev_dax_kmem_probe(struct dev_dax *dev_dax) >>>>> { >>>>> struct device *dev = &dev_dax->dev; >>>>> unsigned long total_len = 0; >>>>> struct dax_kmem_data *data; >>>>> + struct memory_dev_type *mtype; >>>>> int i, rc, mapped = 0; >>>>> int numa_node; >>>>> + int adist = MEMTIER_DEFAULT_DAX_ADISTANCE; >>>>> >>>>> /* >>>>> * Ensure good NUMA information for the persistent memory. >>>>> @@ -71,6 +97,11 @@ static int dev_dax_kmem_probe(struct dev_dax *dev_dax) >>>>> return -EINVAL; >>>>> } >>>>> >>>>> + mt_calc_adistance(numa_node, &adist); >>>>> + mtype = kmem_find_alloc_memorty_type(adist); >>>>> + if (IS_ERR(mtype)) >>>>> + return PTR_ERR(mtype); >>>>> + >>>> >>>> I wrote my own quick and dirty module to test this and wrote basically >>>> the same code sequence. >>>> >>>> I notice your using a list of memory types here though. I think it would >>>> be nice to have a common helper that other users could call to do the >>>> mt_calc_adistance() / kmem_find_alloc_memory_type() / >>>> init_node_memory_type() sequence and cleanup as my naive approach would >>>> result in a new memory_dev_type per device even though adist might be >>>> the same. A common helper would make it easy to de-dup those. >>> >>> If it's useful, we can move kmem_find_alloc_memory_type() to >>> memory-tier.c after some revision. But I tend to move it after we have >>> the second user. What do you think about that? >> >> Usually I would agree, but this series already introduces a general >> interface for calculating adist even though there's only one user and >> implementation. So if we're going to add a general interface I think it >> would be better to make it more usable now rather than after variations >> of it have been cut and pasted into other drivers. > > In general, I would like to introduce complexity when necessary. So, we > can discuss the necessity of the general interface firstly. We can do > that in [1/4] of the series. Do we need one memory_dev_type per adistance or per adistance+device? If IUC correctly I think it's the former. Logically that means memory_dev_types should be managed by the memory-tiering subsystem because they are system wide rather than driver specific resources. That we need to add the list field to struct memory_dev_type specifically for use by dax/kmem supports that idea. Also I'm not sure why you consider moving the kmem_memory_types/kmem_find_alloc_memory_type()/etc. functions into mm/memory-tiers.c to add complexity. Isn't it just moving code around or am I missing some other subtlety that makes this hard? I really think logically memory-tiering.c is where management of the various memory_dev_types belongs. Thanks. Alistair
Alistair Popple <apopple@nvidia.com> writes: > "Huang, Ying" <ying.huang@intel.com> writes: > >> Alistair Popple <apopple@nvidia.com> writes: >> >>> "Huang, Ying" <ying.huang@intel.com> writes: >>> >>>> Alistair Popple <apopple@nvidia.com> writes: >>>> >>>>> Huang Ying <ying.huang@intel.com> writes: >>>>> >>>>>> Previously, a fixed abstract distance MEMTIER_DEFAULT_DAX_ADISTANCE is >>>>>> used for slow memory type in kmem driver. This limits the usage of >>>>>> kmem driver, for example, it cannot be used for HBM (high bandwidth >>>>>> memory). >>>>>> >>>>>> So, we use the general abstract distance calculation mechanism in kmem >>>>>> drivers to get more accurate abstract distance on systems with proper >>>>>> support. The original MEMTIER_DEFAULT_DAX_ADISTANCE is used as >>>>>> fallback only. >>>>>> >>>>>> Now, multiple memory types may be managed by kmem. These memory types >>>>>> are put into the "kmem_memory_types" list and protected by >>>>>> kmem_memory_type_lock. >>>>> >>>>> See below but I wonder if kmem_memory_types could be a common helper >>>>> rather than kdax specific? >>>>> >>>>>> Signed-off-by: "Huang, Ying" <ying.huang@intel.com> >>>>>> Cc: Aneesh Kumar K.V <aneesh.kumar@linux.ibm.com> >>>>>> Cc: Wei Xu <weixugc@google.com> >>>>>> Cc: Alistair Popple <apopple@nvidia.com> >>>>>> Cc: Dan Williams <dan.j.williams@intel.com> >>>>>> Cc: Dave Hansen <dave.hansen@intel.com> >>>>>> Cc: Davidlohr Bueso <dave@stgolabs.net> >>>>>> Cc: Johannes Weiner <hannes@cmpxchg.org> >>>>>> Cc: Jonathan Cameron <Jonathan.Cameron@huawei.com> >>>>>> Cc: Michal Hocko <mhocko@kernel.org> >>>>>> Cc: Yang Shi <shy828301@gmail.com> >>>>>> Cc: Rafael J Wysocki <rafael.j.wysocki@intel.com> >>>>>> --- >>>>>> drivers/dax/kmem.c | 54 +++++++++++++++++++++++++++--------- >>>>>> include/linux/memory-tiers.h | 2 ++ >>>>>> mm/memory-tiers.c | 2 +- >>>>>> 3 files changed, 44 insertions(+), 14 deletions(-) >>>>>> >>>>>> diff --git a/drivers/dax/kmem.c b/drivers/dax/kmem.c >>>>>> index 898ca9505754..837165037231 100644 >>>>>> --- a/drivers/dax/kmem.c >>>>>> +++ b/drivers/dax/kmem.c >>>>>> @@ -49,14 +49,40 @@ struct dax_kmem_data { >>>>>> struct resource *res[]; >>>>>> }; >>>>>> >>>>>> -static struct memory_dev_type *dax_slowmem_type; >>>>>> +static DEFINE_MUTEX(kmem_memory_type_lock); >>>>>> +static LIST_HEAD(kmem_memory_types); >>>>>> + >>>>>> +static struct memory_dev_type *kmem_find_alloc_memorty_type(int adist) >>>>>> +{ >>>>>> + bool found = false; >>>>>> + struct memory_dev_type *mtype; >>>>>> + >>>>>> + mutex_lock(&kmem_memory_type_lock); >>>>>> + list_for_each_entry(mtype, &kmem_memory_types, list) { >>>>>> + if (mtype->adistance == adist) { >>>>>> + found = true; >>>>>> + break; >>>>>> + } >>>>>> + } >>>>>> + if (!found) { >>>>>> + mtype = alloc_memory_type(adist); >>>>>> + if (!IS_ERR(mtype)) >>>>>> + list_add(&mtype->list, &kmem_memory_types); >>>>>> + } >>>>>> + mutex_unlock(&kmem_memory_type_lock); >>>>>> + >>>>>> + return mtype; >>>>>> +} >>>>>> + >>>>>> static int dev_dax_kmem_probe(struct dev_dax *dev_dax) >>>>>> { >>>>>> struct device *dev = &dev_dax->dev; >>>>>> unsigned long total_len = 0; >>>>>> struct dax_kmem_data *data; >>>>>> + struct memory_dev_type *mtype; >>>>>> int i, rc, mapped = 0; >>>>>> int numa_node; >>>>>> + int adist = MEMTIER_DEFAULT_DAX_ADISTANCE; >>>>>> >>>>>> /* >>>>>> * Ensure good NUMA information for the persistent memory. >>>>>> @@ -71,6 +97,11 @@ static int dev_dax_kmem_probe(struct dev_dax *dev_dax) >>>>>> return -EINVAL; >>>>>> } >>>>>> >>>>>> + mt_calc_adistance(numa_node, &adist); >>>>>> + mtype = kmem_find_alloc_memorty_type(adist); >>>>>> + if (IS_ERR(mtype)) >>>>>> + return PTR_ERR(mtype); >>>>>> + >>>>> >>>>> I wrote my own quick and dirty module to test this and wrote basically >>>>> the same code sequence. >>>>> >>>>> I notice your using a list of memory types here though. I think it would >>>>> be nice to have a common helper that other users could call to do the >>>>> mt_calc_adistance() / kmem_find_alloc_memory_type() / >>>>> init_node_memory_type() sequence and cleanup as my naive approach would >>>>> result in a new memory_dev_type per device even though adist might be >>>>> the same. A common helper would make it easy to de-dup those. >>>> >>>> If it's useful, we can move kmem_find_alloc_memory_type() to >>>> memory-tier.c after some revision. But I tend to move it after we have >>>> the second user. What do you think about that? >>> >>> Usually I would agree, but this series already introduces a general >>> interface for calculating adist even though there's only one user and >>> implementation. So if we're going to add a general interface I think it >>> would be better to make it more usable now rather than after variations >>> of it have been cut and pasted into other drivers. >> >> In general, I would like to introduce complexity when necessary. So, we >> can discuss the necessity of the general interface firstly. We can do >> that in [1/4] of the series. > > Do we need one memory_dev_type per adistance or per adistance+device? > > If IUC correctly I think it's the former. Logically that means > memory_dev_types should be managed by the memory-tiering subsystem > because they are system wide rather than driver specific resources. That > we need to add the list field to struct memory_dev_type specifically for > use by dax/kmem supports that idea. In the original design (page 9/10/11 of [1]), memory_dev_type (Memory Type) is driver specific. [1] https://lpc.events/event/16/contributions/1209/attachments/1042/1995/Live%20In%20a%20World%20With%20Multiple%20Memory%20Types.pdf Memory devices with same adistance but was enumerated by different drivers will be put in different memory_dev_type. As a not-so-realistic example, even if the PMEM devices in DIMM slots and the CXL.mem devices in CXL slots have same adistance, their memory_dev_type will be different. Because the memory devices enumerated by the same driver should be managed in the same way, but memory devices enumerated by different drivers may be not. For example, if we adjust the adistance of the PMEM devices to put them in the lower memory tier via not-yet-implemented abstract_distance_offset sysfs knob, we may not want to adjust it of CXL.mem devices at the same time. > Also I'm not sure why you consider moving the > kmem_memory_types/kmem_find_alloc_memory_type()/etc. functions into > mm/memory-tiers.c to add complexity. Isn't it just moving code around or > am I missing some other subtlety that makes this hard? I really think > logically memory-tiering.c is where management of the various > memory_dev_types belongs. IMHO, it depends on whether these functions are shared by at least 2 drivers. If so, we can put them in mm/memory-tiers.c. Otherwise, we should keep them in the driver. -- Best Regards, Huang, Ying
"Huang, Ying" <ying.huang@intel.com> writes: > Alistair Popple <apopple@nvidia.com> writes: > >> "Huang, Ying" <ying.huang@intel.com> writes: >> >>> Alistair Popple <apopple@nvidia.com> writes: >>> >>>> "Huang, Ying" <ying.huang@intel.com> writes: >>>> >>>>> Alistair Popple <apopple@nvidia.com> writes: >>>>> >>>>>> Huang Ying <ying.huang@intel.com> writes: >>>>>> >>>>>>> Previously, a fixed abstract distance MEMTIER_DEFAULT_DAX_ADISTANCE is >>>>>>> used for slow memory type in kmem driver. This limits the usage of >>>>>>> kmem driver, for example, it cannot be used for HBM (high bandwidth >>>>>>> memory). >>>>>>> >>>>>>> So, we use the general abstract distance calculation mechanism in kmem >>>>>>> drivers to get more accurate abstract distance on systems with proper >>>>>>> support. The original MEMTIER_DEFAULT_DAX_ADISTANCE is used as >>>>>>> fallback only. >>>>>>> >>>>>>> Now, multiple memory types may be managed by kmem. These memory types >>>>>>> are put into the "kmem_memory_types" list and protected by >>>>>>> kmem_memory_type_lock. >>>>>> >>>>>> See below but I wonder if kmem_memory_types could be a common helper >>>>>> rather than kdax specific? >>>>>> >>>>>>> Signed-off-by: "Huang, Ying" <ying.huang@intel.com> >>>>>>> Cc: Aneesh Kumar K.V <aneesh.kumar@linux.ibm.com> >>>>>>> Cc: Wei Xu <weixugc@google.com> >>>>>>> Cc: Alistair Popple <apopple@nvidia.com> >>>>>>> Cc: Dan Williams <dan.j.williams@intel.com> >>>>>>> Cc: Dave Hansen <dave.hansen@intel.com> >>>>>>> Cc: Davidlohr Bueso <dave@stgolabs.net> >>>>>>> Cc: Johannes Weiner <hannes@cmpxchg.org> >>>>>>> Cc: Jonathan Cameron <Jonathan.Cameron@huawei.com> >>>>>>> Cc: Michal Hocko <mhocko@kernel.org> >>>>>>> Cc: Yang Shi <shy828301@gmail.com> >>>>>>> Cc: Rafael J Wysocki <rafael.j.wysocki@intel.com> >>>>>>> --- >>>>>>> drivers/dax/kmem.c | 54 +++++++++++++++++++++++++++--------- >>>>>>> include/linux/memory-tiers.h | 2 ++ >>>>>>> mm/memory-tiers.c | 2 +- >>>>>>> 3 files changed, 44 insertions(+), 14 deletions(-) >>>>>>> >>>>>>> diff --git a/drivers/dax/kmem.c b/drivers/dax/kmem.c >>>>>>> index 898ca9505754..837165037231 100644 >>>>>>> --- a/drivers/dax/kmem.c >>>>>>> +++ b/drivers/dax/kmem.c >>>>>>> @@ -49,14 +49,40 @@ struct dax_kmem_data { >>>>>>> struct resource *res[]; >>>>>>> }; >>>>>>> >>>>>>> -static struct memory_dev_type *dax_slowmem_type; >>>>>>> +static DEFINE_MUTEX(kmem_memory_type_lock); >>>>>>> +static LIST_HEAD(kmem_memory_types); >>>>>>> + >>>>>>> +static struct memory_dev_type *kmem_find_alloc_memorty_type(int adist) >>>>>>> +{ >>>>>>> + bool found = false; >>>>>>> + struct memory_dev_type *mtype; >>>>>>> + >>>>>>> + mutex_lock(&kmem_memory_type_lock); >>>>>>> + list_for_each_entry(mtype, &kmem_memory_types, list) { >>>>>>> + if (mtype->adistance == adist) { >>>>>>> + found = true; >>>>>>> + break; >>>>>>> + } >>>>>>> + } >>>>>>> + if (!found) { >>>>>>> + mtype = alloc_memory_type(adist); >>>>>>> + if (!IS_ERR(mtype)) >>>>>>> + list_add(&mtype->list, &kmem_memory_types); >>>>>>> + } >>>>>>> + mutex_unlock(&kmem_memory_type_lock); >>>>>>> + >>>>>>> + return mtype; >>>>>>> +} >>>>>>> + >>>>>>> static int dev_dax_kmem_probe(struct dev_dax *dev_dax) >>>>>>> { >>>>>>> struct device *dev = &dev_dax->dev; >>>>>>> unsigned long total_len = 0; >>>>>>> struct dax_kmem_data *data; >>>>>>> + struct memory_dev_type *mtype; >>>>>>> int i, rc, mapped = 0; >>>>>>> int numa_node; >>>>>>> + int adist = MEMTIER_DEFAULT_DAX_ADISTANCE; >>>>>>> >>>>>>> /* >>>>>>> * Ensure good NUMA information for the persistent memory. >>>>>>> @@ -71,6 +97,11 @@ static int dev_dax_kmem_probe(struct dev_dax *dev_dax) >>>>>>> return -EINVAL; >>>>>>> } >>>>>>> >>>>>>> + mt_calc_adistance(numa_node, &adist); >>>>>>> + mtype = kmem_find_alloc_memorty_type(adist); >>>>>>> + if (IS_ERR(mtype)) >>>>>>> + return PTR_ERR(mtype); >>>>>>> + >>>>>> >>>>>> I wrote my own quick and dirty module to test this and wrote basically >>>>>> the same code sequence. >>>>>> >>>>>> I notice your using a list of memory types here though. I think it would >>>>>> be nice to have a common helper that other users could call to do the >>>>>> mt_calc_adistance() / kmem_find_alloc_memory_type() / >>>>>> init_node_memory_type() sequence and cleanup as my naive approach would >>>>>> result in a new memory_dev_type per device even though adist might be >>>>>> the same. A common helper would make it easy to de-dup those. >>>>> >>>>> If it's useful, we can move kmem_find_alloc_memory_type() to >>>>> memory-tier.c after some revision. But I tend to move it after we have >>>>> the second user. What do you think about that? >>>> >>>> Usually I would agree, but this series already introduces a general >>>> interface for calculating adist even though there's only one user and >>>> implementation. So if we're going to add a general interface I think it >>>> would be better to make it more usable now rather than after variations >>>> of it have been cut and pasted into other drivers. >>> >>> In general, I would like to introduce complexity when necessary. So, we >>> can discuss the necessity of the general interface firstly. We can do >>> that in [1/4] of the series. >> >> Do we need one memory_dev_type per adistance or per adistance+device? >> >> If IUC correctly I think it's the former. Logically that means >> memory_dev_types should be managed by the memory-tiering subsystem >> because they are system wide rather than driver specific resources. That >> we need to add the list field to struct memory_dev_type specifically for >> use by dax/kmem supports that idea. > > In the original design (page 9/10/11 of [1]), memory_dev_type (Memory > Type) is driver specific. Oh fair enough. I was making these comments based on the incorrect understanding that these were a global rather than driver specific resource. Thanks for correcting that! >> Also I'm not sure why you consider moving the >> kmem_memory_types/kmem_find_alloc_memory_type()/etc. functions into >> mm/memory-tiers.c to add complexity. Isn't it just moving code around or >> am I missing some other subtlety that makes this hard? I really think >> logically memory-tiering.c is where management of the various >> memory_dev_types belongs. > > IMHO, it depends on whether these functions are shared by at least 2 > drivers. If so, we can put them in mm/memory-tiers.c. Otherwise, we > should keep them in the driver. Ok. Not sure I entirely agree because I suspect it would still make the code clearer even for a single user. But generally you're correct and as these memory_dev_type's are *supposed* to be driver specific (rather than one per adistance) I don't think it's such a big issue.
diff --git a/drivers/dax/kmem.c b/drivers/dax/kmem.c index 898ca9505754..837165037231 100644 --- a/drivers/dax/kmem.c +++ b/drivers/dax/kmem.c @@ -49,14 +49,40 @@ struct dax_kmem_data { struct resource *res[]; }; -static struct memory_dev_type *dax_slowmem_type; +static DEFINE_MUTEX(kmem_memory_type_lock); +static LIST_HEAD(kmem_memory_types); + +static struct memory_dev_type *kmem_find_alloc_memorty_type(int adist) +{ + bool found = false; + struct memory_dev_type *mtype; + + mutex_lock(&kmem_memory_type_lock); + list_for_each_entry(mtype, &kmem_memory_types, list) { + if (mtype->adistance == adist) { + found = true; + break; + } + } + if (!found) { + mtype = alloc_memory_type(adist); + if (!IS_ERR(mtype)) + list_add(&mtype->list, &kmem_memory_types); + } + mutex_unlock(&kmem_memory_type_lock); + + return mtype; +} + static int dev_dax_kmem_probe(struct dev_dax *dev_dax) { struct device *dev = &dev_dax->dev; unsigned long total_len = 0; struct dax_kmem_data *data; + struct memory_dev_type *mtype; int i, rc, mapped = 0; int numa_node; + int adist = MEMTIER_DEFAULT_DAX_ADISTANCE; /* * Ensure good NUMA information for the persistent memory. @@ -71,6 +97,11 @@ static int dev_dax_kmem_probe(struct dev_dax *dev_dax) return -EINVAL; } + mt_calc_adistance(numa_node, &adist); + mtype = kmem_find_alloc_memorty_type(adist); + if (IS_ERR(mtype)) + return PTR_ERR(mtype); + for (i = 0; i < dev_dax->nr_range; i++) { struct range range; @@ -88,7 +119,7 @@ static int dev_dax_kmem_probe(struct dev_dax *dev_dax) return -EINVAL; } - init_node_memory_type(numa_node, dax_slowmem_type); + init_node_memory_type(numa_node, mtype); rc = -ENOMEM; data = kzalloc(struct_size(data, res, dev_dax->nr_range), GFP_KERNEL); @@ -167,7 +198,7 @@ static int dev_dax_kmem_probe(struct dev_dax *dev_dax) err_res_name: kfree(data); err_dax_kmem_data: - clear_node_memory_type(numa_node, dax_slowmem_type); + clear_node_memory_type(numa_node, mtype); return rc; } @@ -219,7 +250,7 @@ static void dev_dax_kmem_remove(struct dev_dax *dev_dax) * for that. This implies this reference will be around * till next reboot. */ - clear_node_memory_type(node, dax_slowmem_type); + clear_node_memory_type(node, NULL); } } #else @@ -251,12 +282,6 @@ static int __init dax_kmem_init(void) if (!kmem_name) return -ENOMEM; - dax_slowmem_type = alloc_memory_type(MEMTIER_DEFAULT_DAX_ADISTANCE); - if (IS_ERR(dax_slowmem_type)) { - rc = PTR_ERR(dax_slowmem_type); - goto err_dax_slowmem_type; - } - rc = dax_driver_register(&device_dax_kmem_driver); if (rc) goto error_dax_driver; @@ -264,18 +289,21 @@ static int __init dax_kmem_init(void) return rc; error_dax_driver: - destroy_memory_type(dax_slowmem_type); -err_dax_slowmem_type: kfree_const(kmem_name); return rc; } static void __exit dax_kmem_exit(void) { + struct memory_dev_type *mtype, *mtn; + dax_driver_unregister(&device_dax_kmem_driver); if (!any_hotremove_failed) kfree_const(kmem_name); - destroy_memory_type(dax_slowmem_type); + list_for_each_entry_safe(mtype, mtn, &kmem_memory_types, list) { + list_del(&mtype->list); + destroy_memory_type(mtype); + } } MODULE_AUTHOR("Intel Corporation"); diff --git a/include/linux/memory-tiers.h b/include/linux/memory-tiers.h index 9377239c8d34..aca22220cb5c 100644 --- a/include/linux/memory-tiers.h +++ b/include/linux/memory-tiers.h @@ -24,6 +24,8 @@ struct memory_tier; struct memory_dev_type { /* list of memory types that are part of same tier as this type */ struct list_head tier_sibiling; + /* list of memory types that are managed by one driver */ + struct list_head list; /* abstract distance for this specific memory type */ int adistance; /* Nodes of same abstract distance */ diff --git a/mm/memory-tiers.c b/mm/memory-tiers.c index 9a734ef2edfb..38005c60fa2d 100644 --- a/mm/memory-tiers.c +++ b/mm/memory-tiers.c @@ -581,7 +581,7 @@ EXPORT_SYMBOL_GPL(init_node_memory_type); void clear_node_memory_type(int node, struct memory_dev_type *memtype) { mutex_lock(&memory_tier_lock); - if (node_memory_types[node].memtype == memtype) + if (node_memory_types[node].memtype == memtype || !memtype) node_memory_types[node].map_count--; /* * If we umapped all the attached devices to this node,
Previously, a fixed abstract distance MEMTIER_DEFAULT_DAX_ADISTANCE is used for slow memory type in kmem driver. This limits the usage of kmem driver, for example, it cannot be used for HBM (high bandwidth memory). So, we use the general abstract distance calculation mechanism in kmem drivers to get more accurate abstract distance on systems with proper support. The original MEMTIER_DEFAULT_DAX_ADISTANCE is used as fallback only. Now, multiple memory types may be managed by kmem. These memory types are put into the "kmem_memory_types" list and protected by kmem_memory_type_lock. Signed-off-by: "Huang, Ying" <ying.huang@intel.com> Cc: Aneesh Kumar K.V <aneesh.kumar@linux.ibm.com> Cc: Wei Xu <weixugc@google.com> Cc: Alistair Popple <apopple@nvidia.com> Cc: Dan Williams <dan.j.williams@intel.com> Cc: Dave Hansen <dave.hansen@intel.com> Cc: Davidlohr Bueso <dave@stgolabs.net> Cc: Johannes Weiner <hannes@cmpxchg.org> Cc: Jonathan Cameron <Jonathan.Cameron@huawei.com> Cc: Michal Hocko <mhocko@kernel.org> Cc: Yang Shi <shy828301@gmail.com> Cc: Rafael J Wysocki <rafael.j.wysocki@intel.com> --- drivers/dax/kmem.c | 54 +++++++++++++++++++++++++++--------- include/linux/memory-tiers.h | 2 ++ mm/memory-tiers.c | 2 +- 3 files changed, 44 insertions(+), 14 deletions(-)