1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/slab.h>
3 #include <linux/lockdep.h>
4 #include <linux/sysfs.h>
5 #include <linux/kobject.h>
6 #include <linux/memory.h>
7 #include <linux/memory-tiers.h>
8 #include <linux/notifier.h>
9
10 #include "internal.h"
11
12 struct memory_tier {
13 /* hierarchy of memory tiers */
14 struct list_head list;
15 /* list of all memory types part of this tier */
16 struct list_head memory_types;
17 /*
18 * start value of abstract distance. memory tier maps
19 * an abstract distance range,
20 * adistance_start .. adistance_start + MEMTIER_CHUNK_SIZE
21 */
22 int adistance_start;
23 struct device dev;
24 /* All the nodes that are part of all the lower memory tiers. */
25 nodemask_t lower_tier_mask;
26 };
27
28 struct demotion_nodes {
29 nodemask_t preferred;
30 };
31
32 struct node_memory_type_map {
33 struct memory_dev_type *memtype;
34 int map_count;
35 };
36
37 static DEFINE_MUTEX(memory_tier_lock);
38 static LIST_HEAD(memory_tiers);
39 /*
40 * The list is used to store all memory types that are not created
41 * by a device driver.
42 */
43 static LIST_HEAD(default_memory_types);
44 static struct node_memory_type_map node_memory_types[MAX_NUMNODES];
45 struct memory_dev_type *default_dram_type;
46 nodemask_t default_dram_nodes __initdata = NODE_MASK_NONE;
47
48 static const struct bus_type memory_tier_subsys = {
49 .name = "memory_tiering",
50 .dev_name = "memory_tier",
51 };
52
53 #ifdef CONFIG_MIGRATION
54 static int top_tier_adistance;
55 /*
56 * node_demotion[] examples:
57 *
58 * Example 1:
59 *
60 * Node 0 & 1 are CPU + DRAM nodes, node 2 & 3 are PMEM nodes.
61 *
62 * node distances:
63 * node 0 1 2 3
64 * 0 10 20 30 40
65 * 1 20 10 40 30
66 * 2 30 40 10 40
67 * 3 40 30 40 10
68 *
69 * memory_tiers0 = 0-1
70 * memory_tiers1 = 2-3
71 *
72 * node_demotion[0].preferred = 2
73 * node_demotion[1].preferred = 3
74 * node_demotion[2].preferred = <empty>
75 * node_demotion[3].preferred = <empty>
76 *
77 * Example 2:
78 *
79 * Node 0 & 1 are CPU + DRAM nodes, node 2 is memory-only DRAM node.
80 *
81 * node distances:
82 * node 0 1 2
83 * 0 10 20 30
84 * 1 20 10 30
85 * 2 30 30 10
86 *
87 * memory_tiers0 = 0-2
88 *
89 * node_demotion[0].preferred = <empty>
90 * node_demotion[1].preferred = <empty>
91 * node_demotion[2].preferred = <empty>
92 *
93 * Example 3:
94 *
95 * Node 0 is CPU + DRAM nodes, Node 1 is HBM node, node 2 is PMEM node.
96 *
97 * node distances:
98 * node 0 1 2
99 * 0 10 20 30
100 * 1 20 10 40
101 * 2 30 40 10
102 *
103 * memory_tiers0 = 1
104 * memory_tiers1 = 0
105 * memory_tiers2 = 2
106 *
107 * node_demotion[0].preferred = 2
108 * node_demotion[1].preferred = 0
109 * node_demotion[2].preferred = <empty>
110 *
111 */
112 static struct demotion_nodes *node_demotion __read_mostly;
113 #endif /* CONFIG_MIGRATION */
114
115 static BLOCKING_NOTIFIER_HEAD(mt_adistance_algorithms);
116
117 /* The lock is used to protect `default_dram_perf*` info and nid. */
118 static DEFINE_MUTEX(default_dram_perf_lock);
119 static bool default_dram_perf_error;
120 static struct access_coordinate default_dram_perf;
121 static int default_dram_perf_ref_nid = NUMA_NO_NODE;
122 static const char *default_dram_perf_ref_source;
123
124 static inline struct memory_tier *to_memory_tier(struct device *device)
125 {
126 return container_of(device, struct memory_tier, dev);
127 }
128
129 static __always_inline nodemask_t get_memtier_nodemask(struct memory_tier *memtier)
130 {
131 nodemask_t nodes = NODE_MASK_NONE;
132 struct memory_dev_type *memtype;
133
134 list_for_each_entry(memtype, &memtier->memory_types, tier_sibling)
135 nodes_or(nodes, nodes, memtype->nodes);
136
137 return nodes;
138 }
139
140 static void memory_tier_device_release(struct device *dev)
141 {
142 struct memory_tier *tier = to_memory_tier(dev);
143 /*
144 * synchronize_rcu in clear_node_memory_tier makes sure
145 * we don't have rcu access to this memory tier.
146 */
147 kfree(tier);
148 }
149
150 static ssize_t nodelist_show(struct device *dev,
151 struct device_attribute *attr, char *buf)
152 {
153 int ret;
154 nodemask_t nmask;
155
156 mutex_lock(&memory_tier_lock);
157 nmask = get_memtier_nodemask(to_memory_tier(dev));
158 ret = sysfs_emit(buf, "%*pbl\n", nodemask_pr_args(&nmask));
159 mutex_unlock(&memory_tier_lock);
160 return ret;
161 }
162 static DEVICE_ATTR_RO(nodelist);
163
164 static struct attribute *memtier_dev_attrs[] = {
165 &dev_attr_nodelist.attr,
166 NULL
167 };
168
169 static const struct attribute_group memtier_dev_group = {
170 .attrs = memtier_dev_attrs,
171 };
172
173 static const struct attribute_group *memtier_dev_groups[] = {
174 &memtier_dev_group,
175 NULL
176 };
177
178 static struct memory_tier *find_create_memory_tier(struct memory_dev_type *memtype)
179 {
180 int ret;
181 bool found_slot = false;
182 struct memory_tier *memtier, *new_memtier;
183 int adistance = memtype->adistance;
184 unsigned int memtier_adistance_chunk_size = MEMTIER_CHUNK_SIZE;
185
186 lockdep_assert_held_once(&memory_tier_lock);
187
188 adistance = round_down(adistance, memtier_adistance_chunk_size);
189 /*
190 * If the memtype is already part of a memory tier,
191 * just return that.
192 */
193 if (!list_empty(&memtype->tier_sibling)) {
194 list_for_each_entry(memtier, &memory_tiers, list) {
195 if (adistance == memtier->adistance_start)
196 return memtier;
197 }
198 WARN_ON(1);
199 return ERR_PTR(-EINVAL);
200 }
201
202 list_for_each_entry(memtier, &memory_tiers, list) {
203 if (adistance == memtier->adistance_start) {
204 goto link_memtype;
205 } else if (adistance < memtier->adistance_start) {
206 found_slot = true;
207 break;
208 }
209 }
210
211 new_memtier = kzalloc(sizeof(struct memory_tier), GFP_KERNEL);
212 if (!new_memtier)
213 return ERR_PTR(-ENOMEM);
214
215 new_memtier->adistance_start = adistance;
216 INIT_LIST_HEAD(&new_memtier->list);
217 INIT_LIST_HEAD(&new_memtier->memory_types);
218 if (found_slot)
219 list_add_tail(&new_memtier->list, &memtier->list);
220 else
221 list_add_tail(&new_memtier->list, &memory_tiers);
222
223 new_memtier->dev.id = adistance >> MEMTIER_CHUNK_BITS;
224 new_memtier->dev.bus = &memory_tier_subsys;
225 new_memtier->dev.release = memory_tier_device_release;
226 new_memtier->dev.groups = memtier_dev_groups;
227
228 ret = device_register(&new_memtier->dev);
229 if (ret) {
230 list_del(&new_memtier->list);
231 put_device(&new_memtier->dev);
232 return ERR_PTR(ret);
233 }
234 memtier = new_memtier;
235
236 link_memtype:
237 list_add(&memtype->tier_sibling, &memtier->memory_types);
238 return memtier;
239 }
240
241 static struct memory_tier *__node_get_memory_tier(int node)
242 {
243 pg_data_t *pgdat;
244
245 pgdat = NODE_DATA(node);
246 if (!pgdat)
247 return NULL;
248 /*
249 * Since we hold memory_tier_lock, we can avoid
250 * RCU read locks when accessing the details. No
251 * parallel updates are possible here.
252 */
253 return rcu_dereference_check(pgdat->memtier,
254 lockdep_is_held(&memory_tier_lock));
255 }
256
257 #ifdef CONFIG_MIGRATION
258 bool node_is_toptier(int node)
259 {
260 bool toptier;
261 pg_data_t *pgdat;
262 struct memory_tier *memtier;
263
264 pgdat = NODE_DATA(node);
265 if (!pgdat)
266 return false;
267
268 rcu_read_lock();
269 memtier = rcu_dereference(pgdat->memtier);
270 if (!memtier) {
271 toptier = true;
272 goto out;
273 }
274 if (memtier->adistance_start <= top_tier_adistance)
275 toptier = true;
276 else
277 toptier = false;
278 out:
279 rcu_read_unlock();
280 return toptier;
281 }
282
283 void node_get_allowed_targets(pg_data_t *pgdat, nodemask_t *targets)
284 {
285 struct memory_tier *memtier;
286
287 /*
288 * pg_data_t.memtier updates includes a synchronize_rcu()
289 * which ensures that we either find NULL or a valid memtier
290 * in NODE_DATA. protect the access via rcu_read_lock();
291 */
292 rcu_read_lock();
293 memtier = rcu_dereference(pgdat->memtier);
294 if (memtier)
295 *targets = memtier->lower_tier_mask;
296 else
297 *targets = NODE_MASK_NONE;
298 rcu_read_unlock();
299 }
300
301 /**
302 * next_demotion_node() - Get the next node in the demotion path
303 * @node: The starting node to lookup the next node
304 *
305 * Return: node id for next memory node in the demotion path hierarchy
306 * from @node; NUMA_NO_NODE if @node is terminal. This does not keep
307 * @node online or guarantee that it *continues* to be the next demotion
308 * target.
309 */
310 int next_demotion_node(int node)
311 {
312 struct demotion_nodes *nd;
313 int target;
314
315 if (!node_demotion)
316 return NUMA_NO_NODE;
317
318 nd = &node_demotion[node];
319
320 /*
321 * node_demotion[] is updated without excluding this
322 * function from running.
323 *
324 * Make sure to use RCU over entire code blocks if
325 * node_demotion[] reads need to be consistent.
326 */
327 rcu_read_lock();
328 /*
329 * If there are multiple target nodes, just select one
330 * target node randomly.
331 *
332 * In addition, we can also use round-robin to select
333 * target node, but we should introduce another variable
334 * for node_demotion[] to record last selected target node,
335 * that may cause cache ping-pong due to the changing of
336 * last target node. Or introducing per-cpu data to avoid
337 * caching issue, which seems more complicated. So selecting
338 * target node randomly seems better until now.
339 */
340 target = node_random(&nd->preferred);
341 rcu_read_unlock();
342
343 return target;
344 }
345
346 static void disable_all_demotion_targets(void)
347 {
348 struct memory_tier *memtier;
349 int node;
350
351 for_each_node_state(node, N_MEMORY) {
352 node_demotion[node].preferred = NODE_MASK_NONE;
353 /*
354 * We are holding memory_tier_lock, it is safe
355 * to access pgda->memtier.
356 */
357 memtier = __node_get_memory_tier(node);
358 if (memtier)
359 memtier->lower_tier_mask = NODE_MASK_NONE;
360 }
361 /*
362 * Ensure that the "disable" is visible across the system.
363 * Readers will see either a combination of before+disable
364 * state or disable+after. They will never see before and
365 * after state together.
366 */
367 synchronize_rcu();
368 }
369
370 static void dump_demotion_targets(void)
371 {
372 int node;
373
374 for_each_node_state(node, N_MEMORY) {
375 struct memory_tier *memtier = __node_get_memory_tier(node);
376 nodemask_t preferred = node_demotion[node].preferred;
377
378 if (!memtier)
379 continue;
380
381 if (nodes_empty(preferred))
382 pr_info("Demotion targets for Node %d: null\n", node);
383 else
384 pr_info("Demotion targets for Node %d: preferred: %*pbl, fallback: %*pbl\n",
385 node, nodemask_pr_args(&preferred),
386 nodemask_pr_args(&memtier->lower_tier_mask));
387 }
388 }
389
390 /*
391 * Find an automatic demotion target for all memory
392 * nodes. Failing here is OK. It might just indicate
393 * being at the end of a chain.
394 */
395 static void establish_demotion_targets(void)
396 {
397 struct memory_tier *memtier;
398 struct demotion_nodes *nd;
399 int target = NUMA_NO_NODE, node;
400 int distance, best_distance;
401 nodemask_t tier_nodes, lower_tier;
402
403 lockdep_assert_held_once(&memory_tier_lock);
404
405 if (!node_demotion)
406 return;
407
408 disable_all_demotion_targets();
409
410 for_each_node_state(node, N_MEMORY) {
411 best_distance = -1;
412 nd = &node_demotion[node];
413
414 memtier = __node_get_memory_tier(node);
415 if (!memtier || list_is_last(&memtier->list, &memory_tiers))
416 continue;
417 /*
418 * Get the lower memtier to find the demotion node list.
419 */
420 memtier = list_next_entry(memtier, list);
421 tier_nodes = get_memtier_nodemask(memtier);
422 /*
423 * find_next_best_node, use 'used' nodemask as a skip list.
424 * Add all memory nodes except the selected memory tier
425 * nodelist to skip list so that we find the best node from the
426 * memtier nodelist.
427 */
428 nodes_andnot(tier_nodes, node_states[N_MEMORY], tier_nodes);
429
430 /*
431 * Find all the nodes in the memory tier node list of same best distance.
432 * add them to the preferred mask. We randomly select between nodes
433 * in the preferred mask when allocating pages during demotion.
434 */
435 do {
436 target = find_next_best_node(node, &tier_nodes);
437 if (target == NUMA_NO_NODE)
438 break;
439
440 distance = node_distance(node, target);
441 if (distance == best_distance || best_distance == -1) {
442 best_distance = distance;
443 node_set(target, nd->preferred);
444 } else {
445 break;
446 }
447 } while (1);
448 }
449 /*
450 * Promotion is allowed from a memory tier to higher
451 * memory tier only if the memory tier doesn't include
452 * compute. We want to skip promotion from a memory tier,
453 * if any node that is part of the memory tier have CPUs.
454 * Once we detect such a memory tier, we consider that tier
455 * as top tiper from which promotion is not allowed.
456 */
457 list_for_each_entry_reverse(memtier, &memory_tiers, list) {
458 tier_nodes = get_memtier_nodemask(memtier);
459 nodes_and(tier_nodes, node_states[N_CPU], tier_nodes);
460 if (!nodes_empty(tier_nodes)) {
461 /*
462 * abstract distance below the max value of this memtier
463 * is considered toptier.
464 */
465 top_tier_adistance = memtier->adistance_start +
466 MEMTIER_CHUNK_SIZE - 1;
467 break;
468 }
469 }
470 /*
471 * Now build the lower_tier mask for each node collecting node mask from
472 * all memory tier below it. This allows us to fallback demotion page
473 * allocation to a set of nodes that is closer the above selected
474 * preferred node.
475 */
476 lower_tier = node_states[N_MEMORY];
477 list_for_each_entry(memtier, &memory_tiers, list) {
478 /*
479 * Keep removing current tier from lower_tier nodes,
480 * This will remove all nodes in current and above
481 * memory tier from the lower_tier mask.
482 */
483 tier_nodes = get_memtier_nodemask(memtier);
484 nodes_andnot(lower_tier, lower_tier, tier_nodes);
485 memtier->lower_tier_mask = lower_tier;
486 }
487
488 dump_demotion_targets();
489 }
490
491 #else
492 static inline void establish_demotion_targets(void) {}
493 #endif /* CONFIG_MIGRATION */
494
495 static inline void __init_node_memory_type(int node, struct memory_dev_type *memtype)
496 {
497 if (!node_memory_types[node].memtype)
498 node_memory_types[node].memtype = memtype;
499 /*
500 * for each device getting added in the same NUMA node
501 * with this specific memtype, bump the map count. We
502 * Only take memtype device reference once, so that
503 * changing a node memtype can be done by droping the
504 * only reference count taken here.
505 */
506
507 if (node_memory_types[node].memtype == memtype) {
508 if (!node_memory_types[node].map_count++)
509 kref_get(&memtype->kref);
510 }
511 }
512
513 static struct memory_tier *set_node_memory_tier(int node)
514 {
515 struct memory_tier *memtier;
516 struct memory_dev_type *memtype = default_dram_type;
517 int adist = MEMTIER_ADISTANCE_DRAM;
518 pg_data_t *pgdat = NODE_DATA(node);
519
520
521 lockdep_assert_held_once(&memory_tier_lock);
522
523 if (!node_state(node, N_MEMORY))
524 return ERR_PTR(-EINVAL);
525
526 mt_calc_adistance(node, &adist);
527 if (!node_memory_types[node].memtype) {
528 memtype = mt_find_alloc_memory_type(adist, &default_memory_types);
529 if (IS_ERR(memtype)) {
530 memtype = default_dram_type;
531 pr_info("Failed to allocate a memory type. Fall back.\n");
532 }
533 }
534
535 __init_node_memory_type(node, memtype);
536
537 memtype = node_memory_types[node].memtype;
538 node_set(node, memtype->nodes);
539 memtier = find_create_memory_tier(memtype);
540 if (!IS_ERR(memtier))
541 rcu_assign_pointer(pgdat->memtier, memtier);
542 return memtier;
543 }
544
545 static void destroy_memory_tier(struct memory_tier *memtier)
546 {
547 list_del(&memtier->list);
548 device_unregister(&memtier->dev);
549 }
550
551 static bool clear_node_memory_tier(int node)
552 {
553 bool cleared = false;
554 pg_data_t *pgdat;
555 struct memory_tier *memtier;
556
557 pgdat = NODE_DATA(node);
558 if (!pgdat)
559 return false;
560
561 /*
562 * Make sure that anybody looking at NODE_DATA who finds
563 * a valid memtier finds memory_dev_types with nodes still
564 * linked to the memtier. We achieve this by waiting for
565 * rcu read section to finish using synchronize_rcu.
566 * This also enables us to free the destroyed memory tier
567 * with kfree instead of kfree_rcu
568 */
569 memtier = __node_get_memory_tier(node);
570 if (memtier) {
571 struct memory_dev_type *memtype;
572
573 rcu_assign_pointer(pgdat->memtier, NULL);
574 synchronize_rcu();
575 memtype = node_memory_types[node].memtype;
576 node_clear(node, memtype->nodes);
577 if (nodes_empty(memtype->nodes)) {
578 list_del_init(&memtype->tier_sibling);
579 if (list_empty(&memtier->memory_types))
580 destroy_memory_tier(memtier);
581 }
582 cleared = true;
583 }
584 return cleared;
585 }
586
587 static void release_memtype(struct kref *kref)
588 {
589 struct memory_dev_type *memtype;
590
591 memtype = container_of(kref, struct memory_dev_type, kref);
592 kfree(memtype);
593 }
594
595 struct memory_dev_type *alloc_memory_type(int adistance)
596 {
597 struct memory_dev_type *memtype;
598
599 memtype = kmalloc(sizeof(*memtype), GFP_KERNEL);
600 if (!memtype)
601 return ERR_PTR(-ENOMEM);
602
603 memtype->adistance = adistance;
604 INIT_LIST_HEAD(&memtype->tier_sibling);
605 memtype->nodes = NODE_MASK_NONE;
606 kref_init(&memtype->kref);
607 return memtype;
608 }
609 EXPORT_SYMBOL_GPL(alloc_memory_type);
610
611 void put_memory_type(struct memory_dev_type *memtype)
612 {
613 kref_put(&memtype->kref, release_memtype);
614 }
615 EXPORT_SYMBOL_GPL(put_memory_type);
616
617 void init_node_memory_type(int node, struct memory_dev_type *memtype)
618 {
619
620 mutex_lock(&memory_tier_lock);
621 __init_node_memory_type(node, memtype);
622 mutex_unlock(&memory_tier_lock);
623 }
624 EXPORT_SYMBOL_GPL(init_node_memory_type);
625
626 void clear_node_memory_type(int node, struct memory_dev_type *memtype)
627 {
628 mutex_lock(&memory_tier_lock);
629 if (node_memory_types[node].memtype == memtype || !memtype)
630 node_memory_types[node].map_count--;
631 /*
632 * If we umapped all the attached devices to this node,
633 * clear the node memory type.
634 */
635 if (!node_memory_types[node].map_count) {
636 memtype = node_memory_types[node].memtype;
637 node_memory_types[node].memtype = NULL;
638 put_memory_type(memtype);
639 }
640 mutex_unlock(&memory_tier_lock);
641 }
642 EXPORT_SYMBOL_GPL(clear_node_memory_type);
643
644 struct memory_dev_type *mt_find_alloc_memory_type(int adist, struct list_head *memory_types)
645 {
646 struct memory_dev_type *mtype;
647
648 list_for_each_entry(mtype, memory_types, list)
649 if (mtype->adistance == adist)
650 return mtype;
651
652 mtype = alloc_memory_type(adist);
653 if (IS_ERR(mtype))
654 return mtype;
655
656 list_add(&mtype->list, memory_types);
657
658 return mtype;
659 }
660 EXPORT_SYMBOL_GPL(mt_find_alloc_memory_type);
661
662 void mt_put_memory_types(struct list_head *memory_types)
663 {
664 struct memory_dev_type *mtype, *mtn;
665
666 list_for_each_entry_safe(mtype, mtn, memory_types, list) {
667 list_del(&mtype->list);
668 put_memory_type(mtype);
669 }
670 }
671 EXPORT_SYMBOL_GPL(mt_put_memory_types);
672
673 /*
674 * This is invoked via `late_initcall()` to initialize memory tiers for
675 * memory nodes, both with and without CPUs. After the initialization of
676 * firmware and devices, adistance algorithms are expected to be provided.
677 */
678 static int __init memory_tier_late_init(void)
679 {
680 int nid;
681 struct memory_tier *memtier;
682
683 get_online_mems();
684 guard(mutex)(&memory_tier_lock);
685
686 /* Assign each uninitialized N_MEMORY node to a memory tier. */
687 for_each_node_state(nid, N_MEMORY) {
688 /*
689 * Some device drivers may have initialized
690 * memory tiers, potentially bringing memory nodes
691 * online and configuring memory tiers.
692 * Exclude them here.
693 */
694 if (node_memory_types[nid].memtype)
695 continue;
696
697 memtier = set_node_memory_tier(nid);
698 if (IS_ERR(memtier))
699 continue;
700 }
701
702 establish_demotion_targets();
703 put_online_mems();
704
705 return 0;
706 }
707 late_initcall(memory_tier_late_init);
708
709 static void dump_hmem_attrs(struct access_coordinate *coord, const char *prefix)
710 {
711 pr_info(
712 "%sread_latency: %u, write_latency: %u, read_bandwidth: %u, write_bandwidth: %u\n",
713 prefix, coord->read_latency, coord->write_latency,
714 coord->read_bandwidth, coord->write_bandwidth);
715 }
716
717 int mt_set_default_dram_perf(int nid, struct access_coordinate *perf,
718 const char *source)
719 {
720 guard(mutex)(&default_dram_perf_lock);
721 if (default_dram_perf_error)
722 return -EIO;
723
724 if (perf->read_latency + perf->write_latency == 0 ||
725 perf->read_bandwidth + perf->write_bandwidth == 0)
726 return -EINVAL;
727
728 if (default_dram_perf_ref_nid == NUMA_NO_NODE) {
729 default_dram_perf = *perf;
730 default_dram_perf_ref_nid = nid;
731 default_dram_perf_ref_source = kstrdup(source, GFP_KERNEL);
732 return 0;
733 }
734
735 /*
736 * The performance of all default DRAM nodes is expected to be
737 * same (that is, the variation is less than 10%). And it
738 * will be used as base to calculate the abstract distance of
739 * other memory nodes.
740 */
741 if (abs(perf->read_latency - default_dram_perf.read_latency) * 10 >
742 default_dram_perf.read_latency ||
743 abs(perf->write_latency - default_dram_perf.write_latency) * 10 >
744 default_dram_perf.write_latency ||
745 abs(perf->read_bandwidth - default_dram_perf.read_bandwidth) * 10 >
746 default_dram_perf.read_bandwidth ||
747 abs(perf->write_bandwidth - default_dram_perf.write_bandwidth) * 10 >
748 default_dram_perf.write_bandwidth) {
749 pr_info(
750 "memory-tiers: the performance of DRAM node %d mismatches that of the reference\n"
751 "DRAM node %d.\n", nid, default_dram_perf_ref_nid);
752 pr_info(" performance of reference DRAM node %d:\n",
753 default_dram_perf_ref_nid);
754 dump_hmem_attrs(&default_dram_perf, " ");
755 pr_info(" performance of DRAM node %d:\n", nid);
756 dump_hmem_attrs(perf, " ");
757 pr_info(
758 " disable default DRAM node performance based abstract distance algorithm.\n");
759 default_dram_perf_error = true;
760 return -EINVAL;
761 }
762
763 return 0;
764 }
765
766 int mt_perf_to_adistance(struct access_coordinate *perf, int *adist)
767 {
768 guard(mutex)(&default_dram_perf_lock);
769 if (default_dram_perf_error)
770 return -EIO;
771
772 if (perf->read_latency + perf->write_latency == 0 ||
773 perf->read_bandwidth + perf->write_bandwidth == 0)
774 return -EINVAL;
775
776 if (default_dram_perf_ref_nid == NUMA_NO_NODE)
777 return -ENOENT;
778
779 /*
780 * The abstract distance of a memory node is in direct proportion to
781 * its memory latency (read + write) and inversely proportional to its
782 * memory bandwidth (read + write). The abstract distance, memory
783 * latency, and memory bandwidth of the default DRAM nodes are used as
784 * the base.
785 */
786 *adist = MEMTIER_ADISTANCE_DRAM *
787 (perf->read_latency + perf->write_latency) /
788 (default_dram_perf.read_latency + default_dram_perf.write_latency) *
789 (default_dram_perf.read_bandwidth + default_dram_perf.write_bandwidth) /
790 (perf->read_bandwidth + perf->write_bandwidth);
791
792 return 0;
793 }
794 EXPORT_SYMBOL_GPL(mt_perf_to_adistance);
795
796 /**
797 * register_mt_adistance_algorithm() - Register memory tiering abstract distance algorithm
798 * @nb: The notifier block which describe the algorithm
799 *
800 * Return: 0 on success, errno on error.
801 *
802 * Every memory tiering abstract distance algorithm provider needs to
803 * register the algorithm with register_mt_adistance_algorithm(). To
804 * calculate the abstract distance for a specified memory node, the
805 * notifier function will be called unless some high priority
806 * algorithm has provided result. The prototype of the notifier
807 * function is as follows,
808 *
809 * int (*algorithm_notifier)(struct notifier_block *nb,
810 * unsigned long nid, void *data);
811 *
812 * Where "nid" specifies the memory node, "data" is the pointer to the
813 * returned abstract distance (that is, "int *adist"). If the
814 * algorithm provides the result, NOTIFY_STOP should be returned.
815 * Otherwise, return_value & %NOTIFY_STOP_MASK == 0 to allow the next
816 * algorithm in the chain to provide the result.
817 */
818 int register_mt_adistance_algorithm(struct notifier_block *nb)
819 {
820 return blocking_notifier_chain_register(&mt_adistance_algorithms, nb);
821 }
822 EXPORT_SYMBOL_GPL(register_mt_adistance_algorithm);
823
824 /**
825 * unregister_mt_adistance_algorithm() - Unregister memory tiering abstract distance algorithm
826 * @nb: the notifier block which describe the algorithm
827 *
828 * Return: 0 on success, errno on error.
829 */
830 int unregister_mt_adistance_algorithm(struct notifier_block *nb)
831 {
832 return blocking_notifier_chain_unregister(&mt_adistance_algorithms, nb);
833 }
834 EXPORT_SYMBOL_GPL(unregister_mt_adistance_algorithm);
835
836 /**
837 * mt_calc_adistance() - Calculate abstract distance with registered algorithms
838 * @node: the node to calculate abstract distance for
839 * @adist: the returned abstract distance
840 *
841 * Return: if return_value & %NOTIFY_STOP_MASK != 0, then some
842 * abstract distance algorithm provides the result, and return it via
843 * @adist. Otherwise, no algorithm can provide the result and @adist
844 * will be kept as it is.
845 */
846 int mt_calc_adistance(int node, int *adist)
847 {
848 return blocking_notifier_call_chain(&mt_adistance_algorithms, node, adist);
849 }
850 EXPORT_SYMBOL_GPL(mt_calc_adistance);
851
852 static int __meminit memtier_hotplug_callback(struct notifier_block *self,
853 unsigned long action, void *_arg)
854 {
855 struct memory_tier *memtier;
856 struct memory_notify *arg = _arg;
857
858 /*
859 * Only update the node migration order when a node is
860 * changing status, like online->offline.
861 */
862 if (arg->status_change_nid < 0)
863 return notifier_from_errno(0);
864
865 switch (action) {
866 case MEM_OFFLINE:
867 mutex_lock(&memory_tier_lock);
868 if (clear_node_memory_tier(arg->status_change_nid))
869 establish_demotion_targets();
870 mutex_unlock(&memory_tier_lock);
871 break;
872 case MEM_ONLINE:
873 mutex_lock(&memory_tier_lock);
874 memtier = set_node_memory_tier(arg->status_change_nid);
875 if (!IS_ERR(memtier))
876 establish_demotion_targets();
877 mutex_unlock(&memory_tier_lock);
878 break;
879 }
880
881 return notifier_from_errno(0);
882 }
883
884 static int __init memory_tier_init(void)
885 {
886 int ret;
887
888 ret = subsys_virtual_register(&memory_tier_subsys, NULL);
889 if (ret)
890 panic("%s() failed to register memory tier subsystem\n", __func__);
891
892 #ifdef CONFIG_MIGRATION
893 node_demotion = kcalloc(nr_node_ids, sizeof(struct demotion_nodes),
894 GFP_KERNEL);
895 WARN_ON(!node_demotion);
896 #endif
897
898 guard(mutex)(&memory_tier_lock);
899 /*
900 * For now we can have 4 faster memory tiers with smaller adistance
901 * than default DRAM tier.
902 */
903 default_dram_type = mt_find_alloc_memory_type(MEMTIER_ADISTANCE_DRAM,
904 &default_memory_types);
905 if (IS_ERR(default_dram_type))
906 panic("%s() failed to allocate default DRAM tier\n", __func__);
907
908 /* Record nodes with memory and CPU to set default DRAM performance. */
909 nodes_and(default_dram_nodes, node_states[N_MEMORY],
910 node_states[N_CPU]);
911
912 hotplug_memory_notifier(memtier_hotplug_callback, MEMTIER_HOTPLUG_PRI);
913 return 0;
914 }
915 subsys_initcall(memory_tier_init);
916
917 bool numa_demotion_enabled = false;
918
919 #ifdef CONFIG_MIGRATION
920 #ifdef CONFIG_SYSFS
921 static ssize_t demotion_enabled_show(struct kobject *kobj,
922 struct kobj_attribute *attr, char *buf)
923 {
924 return sysfs_emit(buf, "%s\n",
925 numa_demotion_enabled ? "true" : "false");
926 }
927
928 static ssize_t demotion_enabled_store(struct kobject *kobj,
929 struct kobj_attribute *attr,
930 const char *buf, size_t count)
931 {
932 ssize_t ret;
933
934 ret = kstrtobool(buf, &numa_demotion_enabled);
935 if (ret)
936 return ret;
937
938 return count;
939 }
940
941 static struct kobj_attribute numa_demotion_enabled_attr =
942 __ATTR_RW(demotion_enabled);
943
944 static struct attribute *numa_attrs[] = {
945 &numa_demotion_enabled_attr.attr,
946 NULL,
947 };
948
949 static const struct attribute_group numa_attr_group = {
950 .attrs = numa_attrs,
951 };
952
953 static int __init numa_init_sysfs(void)
954 {
955 int err;
956 struct kobject *numa_kobj;
957
958 numa_kobj = kobject_create_and_add("numa", mm_kobj);
959 if (!numa_kobj) {
960 pr_err("failed to create numa kobject\n");
961 return -ENOMEM;
962 }
963 err = sysfs_create_group(numa_kobj, &numa_attr_group);
964 if (err) {
965 pr_err("failed to register numa group\n");
966 goto delete_obj;
967 }
968 return 0;
969
970 delete_obj:
971 kobject_put(numa_kobj);
972 return err;
973 }
974 subsys_initcall(numa_init_sysfs);
975 #endif /* CONFIG_SYSFS */
976 #endif
977
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.