Commit | Line | Data |
---|---|---|
c221c0b0 DH |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* Copyright(c) 2016-2019 Intel Corporation. All rights reserved. */ | |
3 | #include <linux/memremap.h> | |
4 | #include <linux/pagemap.h> | |
5 | #include <linux/memory.h> | |
6 | #include <linux/module.h> | |
7 | #include <linux/device.h> | |
8 | #include <linux/pfn_t.h> | |
9 | #include <linux/slab.h> | |
10 | #include <linux/dax.h> | |
11 | #include <linux/fs.h> | |
12 | #include <linux/mm.h> | |
13 | #include <linux/mman.h> | |
14 | #include "dax-private.h" | |
15 | #include "bus.h" | |
16 | ||
17 | int dev_dax_kmem_probe(struct device *dev) | |
18 | { | |
19 | struct dev_dax *dev_dax = to_dev_dax(dev); | |
20 | struct resource *res = &dev_dax->region->res; | |
21 | resource_size_t kmem_start; | |
22 | resource_size_t kmem_size; | |
23 | resource_size_t kmem_end; | |
24 | struct resource *new_res; | |
25 | int numa_node; | |
26 | int rc; | |
27 | ||
28 | /* | |
29 | * Ensure good NUMA information for the persistent memory. | |
30 | * Without this check, there is a risk that slow memory | |
31 | * could be mixed in a node with faster memory, causing | |
32 | * unavoidable performance issues. | |
33 | */ | |
34 | numa_node = dev_dax->target_node; | |
35 | if (numa_node < 0) { | |
36 | dev_warn(dev, "rejecting DAX region %pR with invalid node: %d\n", | |
37 | res, numa_node); | |
38 | return -EINVAL; | |
39 | } | |
40 | ||
41 | /* Hotplug starting at the beginning of the next block: */ | |
42 | kmem_start = ALIGN(res->start, memory_block_size_bytes()); | |
43 | ||
44 | kmem_size = resource_size(res); | |
45 | /* Adjust the size down to compensate for moving up kmem_start: */ | |
46 | kmem_size -= kmem_start - res->start; | |
47 | /* Align the size down to cover only complete blocks: */ | |
48 | kmem_size &= ~(memory_block_size_bytes() - 1); | |
49 | kmem_end = kmem_start + kmem_size; | |
50 | ||
51 | /* Region is permanently reserved. Hot-remove not yet implemented. */ | |
52 | new_res = request_mem_region(kmem_start, kmem_size, dev_name(dev)); | |
53 | if (!new_res) { | |
54 | dev_warn(dev, "could not reserve region [%pa-%pa]\n", | |
55 | &kmem_start, &kmem_end); | |
56 | return -EBUSY; | |
57 | } | |
58 | ||
59 | /* | |
60 | * Set flags appropriate for System RAM. Leave ..._BUSY clear | |
61 | * so that add_memory() can add a child resource. Do not | |
62 | * inherit flags from the parent since it may set new flags | |
63 | * unknown to us that will break add_memory() below. | |
64 | */ | |
65 | new_res->flags = IORESOURCE_SYSTEM_RAM; | |
66 | new_res->name = dev_name(dev); | |
67 | ||
68 | rc = add_memory(numa_node, new_res->start, resource_size(new_res)); | |
31e4ca92 PT |
69 | if (rc) { |
70 | release_resource(new_res); | |
71 | kfree(new_res); | |
c221c0b0 | 72 | return rc; |
31e4ca92 | 73 | } |
9f960da7 | 74 | dev_dax->dax_kmem_res = new_res; |
c221c0b0 DH |
75 | |
76 | return 0; | |
77 | } | |
78 | ||
9f960da7 PT |
79 | #ifdef CONFIG_MEMORY_HOTREMOVE |
80 | static int dev_dax_kmem_remove(struct device *dev) | |
81 | { | |
82 | struct dev_dax *dev_dax = to_dev_dax(dev); | |
83 | struct resource *res = dev_dax->dax_kmem_res; | |
84 | resource_size_t kmem_start = res->start; | |
85 | resource_size_t kmem_size = resource_size(res); | |
86 | int rc; | |
87 | ||
88 | /* | |
89 | * We have one shot for removing memory, if some memory blocks were not | |
90 | * offline prior to calling this function remove_memory() will fail, and | |
91 | * there is no way to hotremove this memory until reboot because device | |
92 | * unbind will succeed even if we return failure. | |
93 | */ | |
94 | rc = remove_memory(dev_dax->target_node, kmem_start, kmem_size); | |
95 | if (rc) { | |
96 | dev_err(dev, | |
97 | "DAX region %pR cannot be hotremoved until the next reboot\n", | |
98 | res); | |
99 | return rc; | |
100 | } | |
101 | ||
102 | /* Release and free dax resources */ | |
103 | release_resource(res); | |
104 | kfree(res); | |
105 | dev_dax->dax_kmem_res = NULL; | |
106 | ||
107 | return 0; | |
108 | } | |
109 | #else | |
c221c0b0 DH |
110 | static int dev_dax_kmem_remove(struct device *dev) |
111 | { | |
112 | /* | |
9f960da7 PT |
113 | * Without hotremove purposely leak the request_mem_region() for the |
114 | * device-dax range and return '0' to ->remove() attempts. The removal | |
115 | * of the device from the driver always succeeds, but the region is | |
116 | * permanently pinned as reserved by the unreleased | |
c221c0b0 DH |
117 | * request_mem_region(). |
118 | */ | |
119 | return 0; | |
120 | } | |
9f960da7 | 121 | #endif /* CONFIG_MEMORY_HOTREMOVE */ |
c221c0b0 DH |
122 | |
123 | static struct dax_device_driver device_dax_kmem_driver = { | |
124 | .drv = { | |
125 | .probe = dev_dax_kmem_probe, | |
126 | .remove = dev_dax_kmem_remove, | |
127 | }, | |
128 | }; | |
129 | ||
130 | static int __init dax_kmem_init(void) | |
131 | { | |
132 | return dax_driver_register(&device_dax_kmem_driver); | |
133 | } | |
134 | ||
135 | static void __exit dax_kmem_exit(void) | |
136 | { | |
137 | dax_driver_unregister(&device_dax_kmem_driver); | |
138 | } | |
139 | ||
140 | MODULE_AUTHOR("Intel Corporation"); | |
141 | MODULE_LICENSE("GPL v2"); | |
142 | module_init(dax_kmem_init); | |
143 | module_exit(dax_kmem_exit); | |
144 | MODULE_ALIAS_DAX_DEVICE(0); |