Add a new member in the pg_data_t struct to tell whether the node corresponding to that pg_data_t is able to do hardware memory encryption.

This will be read from sysfs.

Signed-off-by: Martin Fernandez martin.fernandez@eclypsium.com --- include/linux/mmzone.h | 3 +++ mm/page_alloc.c | 1 + 2 files changed, 4 insertions(+)

diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h index aab70355d64f..6fd4785f1d05 100644 --- a/include/linux/mmzone.h +++ b/include/linux/mmzone.h @@ -883,6 +883,9 @@ typedef struct pglist_data { struct task_struct *kcompactd; bool proactive_compact_trigger; #endif + + bool crypto_capable; + /* * This is a per-node reserve of pages that are not available * to userspace allocations. diff --git a/mm/page_alloc.c b/mm/page_alloc.c index e008a3df0485..147437329ac7 100644 --- a/mm/page_alloc.c +++ b/mm/page_alloc.c @@ -7729,6 +7729,7 @@ static void __init free_area_init_node(int nid) pgdat->node_id = nid; pgdat->node_start_pfn = start_pfn; pgdat->per_cpu_nodestats = NULL; + pgdat->crypto_capable = memblock_node_is_crypto_capable(nid);

if (start_pfn != end_pfn) { pr_info("Initmem setup node %d [mem %#018Lx-%#018Lx]\n", nid,

__e820__range_update and e820__range_remove had a very similar flow in its implementation with a few lines different from each other, the lines that actually perform the modification over the e820_table. The similiraties were found in the checks for the different cases on how each entry intersects with the given range (if it does at all). These checks were very presice and error prone so it was not a good idea to have them in both places.

Since I need to add a third one, similar to this two, in this and the following patches I'll propose a refactor of these functions.

In this patch I introduce:

- A new type e820_entry_updater that will carry three callbacks, those callbacks will decide WHEN to perform actions over the e820_table and WHAY actions are going to be performed.

Note that there is a void pointer "data". This pointer will carry useful information for the callbacks, like the type that we want to update in e820__range_update or if we want to check the type in e820__range_remove. Check it out in the next patches where I do the rework of __e820__range_update and e820__range_remove.

- A new function __e820__handle_range_update that has the flow of the original two functions to refactor. Together with e820_entry_updater will perform the desired update on the input table.

On version 6 of this patch some people pointed out that this solution was over-complicated. Mike Rapoport suggested a another solution [1].

I took a look at that, and although it is indeed simpler it's more confusing at the same time. I think is manageable to have a single function to update or remove sections of the table (what Mike did), but when I added the functionality to also update the crypto_capable it became really hard to manage.

I think that the approach presented in this patch it's complex but is easier to read, to extend and to test.

[1] https://git.kernel.org/rppt/h/x86/e820-update-range

Signed-off-by: Martin Fernandez martin.fernandez@eclypsium.com

--------------------------------------------------

Changes from v7 to v8:

(Some) Callbacks of e820_entry_updater can now be NULL to avoid defining empty functions

Remove kerneldocs in favor of plain comments just to explain what the functions do. --- arch/x86/kernel/e820.c | 127 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 127 insertions(+)

diff --git a/arch/x86/kernel/e820.c b/arch/x86/kernel/e820.c index f267205f2d5a..e0fa3ab755a5 100644 --- a/arch/x86/kernel/e820.c +++ b/arch/x86/kernel/e820.c @@ -459,6 +459,133 @@ static int __init append_e820_table(struct boot_e820_entry *entries, u32 nr_entr return __append_e820_table(entries, nr_entries); }

+/** + * struct e820_entry_updater - Helper type for + * __e820__handle_range_update(). + * @should_update: Return true if @entry needs to be updated, false + * otherwise. + * @update: Apply desired actions to an @entry that is inside the + * range and satisfies @should_update. Can be set to NULL to avoid empty functions. + * @new: Create new entry in the table with information gathered from + * @original and @data. Can be set to NULL to avoid empty functions. + * + * Each function corresponds to an action that + * __e820__handle_range_update() does. Callbacks need to cast @data back + * to the corresponding type. + */ +struct e820_entry_updater { + bool (*should_update)(const struct e820_entry *entry, const void *data); + void (*update)(struct e820_entry *entry, const void *data); + void (*new)(struct e820_table *table, u64 new_start, u64 new_size, + const struct e820_entry *original, const void *data); +}; + +/* + * Helper for __e820__handle_range_update to handle the case where + * neither the entry completely covers the range nor the range + * completely covers the entry. + */ +static u64 __init +__e820__handle_intersected_range_update(struct e820_table *table, + u64 start, + u64 size, + struct e820_entry *entry, + const struct e820_entry_updater *updater, + const void *data) +{ + u64 end; + u64 entry_end = entry->addr + entry->size; + u64 inner_start; + u64 inner_end; + u64 updated_size = 0; + + if (size > (ULLONG_MAX - start)) + size = ULLONG_MAX - start; + + end = start + size; + inner_start = max(start, entry->addr); + inner_end = min(end, entry_end); + + /* Range and entry do intersect and... */ + if (inner_start < inner_end) { + /* Entry is on the left */ + if (entry->addr < inner_start) { + /* Resize current entry */ + entry->size = inner_start - entry->addr; + /* Entry is on the right */ + } else { + /* Resize and move current section */ + entry->addr = inner_end; + entry->size = entry_end - inner_end; + } + if (updater->new != NULL) + /* Create new entry with intersected region */ + updater->new(table, inner_start, inner_end - inner_start, entry, data); + + updated_size += inner_end - inner_start; + } /* Else: [start, end) doesn't cover entry */ + + return updated_size; +} + +/* + * Update the table @table in [@start, @start + @size) doing the + * actions given in @updater. + */ +static u64 __init +__e820__handle_range_update(struct e820_table *table, + u64 start, + u64 size, + const struct e820_entry_updater *updater, + const void *data) +{ + u64 updated_size = 0; + u64 end; + unsigned int i; + + if (size > (ULLONG_MAX - start)) + size = ULLONG_MAX - start; + + end = start + size; + + for (i = 0; i < table->nr_entries; i++) { + struct e820_entry *entry = &table->entries[i]; + u64 entry_end = entry->addr + entry->size; + + if (updater->should_update(entry, data)) { + /* Range completely covers entry */ + if (entry->addr >= start && entry_end <= end) { + updated_size += entry->size; + if (updater->update != NULL) + updater->update(entry, data); + /* Entry completely covers range */ + } else if (start > entry->addr && end < entry_end) { + /* Resize current entry */ + entry->size = start - entry->addr; + + if (updater->new != NULL) + /* Create new entry with intersection region */ + updater->new(table, start, size, entry, data); + + /* + * Create a new entry for the leftover + * of the current entry + */ + __e820__range_add(table, end, entry_end - end, + entry->type); + + updated_size += size; + } else { + updated_size += + __e820__handle_intersected_range_update(table, start, size, + entry, updater, data); + } + } + } + + return updated_size; +} + static u64 __init __e820__range_update(struct e820_table *table, u64 start, u64 size, enum e820_type old_type, enum e820_type new_type) {

Refactor e820__range_remove with the introduction of e820_remover_data, indented to be used as the void pointer in the e820_entry_updater callbacks, and the implementation of the callbacks remove a range in the e820_table.

Signed-off-by: Martin Fernandez martin.fernandez@eclypsium.com --- arch/x86/kernel/e820.c | 94 ++++++++++++++++++------------------------ 1 file changed, 41 insertions(+), 53 deletions(-)

diff --git a/arch/x86/kernel/e820.c b/arch/x86/kernel/e820.c index 36a22c0a2199..0e5aa13ebdb8 100644 --- a/arch/x86/kernel/e820.c +++ b/arch/x86/kernel/e820.c @@ -669,66 +669,54 @@ static u64 __init e820__range_update_kexec(u64 start, u64 size, return __e820__range_update(e820_table_kexec, start, size, old_type, new_type); }

-/* Remove a range of memory from the E820 table: */ -u64 __init e820__range_remove(u64 start, u64 size, enum e820_type old_type, bool check_type) -{ - int i; - u64 end; - u64 real_removed_size = 0; - - if (size > (ULLONG_MAX - start)) - size = ULLONG_MAX - start; - - end = start + size; - printk(KERN_DEBUG "e820: remove [mem %#010Lx-%#010Lx] ", start, end - 1); - if (check_type) - e820_print_type(old_type); - pr_cont("\n"); - - for (i = 0; i < e820_table->nr_entries; i++) { - struct e820_entry *entry = &e820_table->entries[i]; - u64 final_start, final_end; - u64 entry_end; - - if (check_type && entry->type != old_type) - continue; +/* + * Type helper for the e820_entry_updater callbacks. + */ +struct e820_remover_data { + enum e820_type old_type; + bool check_type; +};

- entry_end = entry->addr + entry->size; +static bool __init remover__should_update(const struct e820_entry *entry, + const void *data) +{ + const struct e820_remover_data *remover_data = data;

- /* Completely covered? */ - if (entry->addr >= start && entry_end <= end) { - real_removed_size += entry->size; - memset(entry, 0, sizeof(*entry)); - continue; - } + return !remover_data->check_type || + entry->type == remover_data->old_type; +}

- /* Is the new range completely covered? */ - if (entry->addr < start && entry_end > end) { - e820__range_add(end, entry_end - end, entry->type); - entry->size = start - entry->addr; - real_removed_size += size; - continue; - } +static void __init remover__update(struct e820_entry *entry, const void *data) +{ + memset(entry, 0, sizeof(*entry)); +}

- /* Partially covered: */ - final_start = max(start, entry->addr); - final_end = min(end, entry_end); - if (final_start >= final_end) - continue; +/* + * Remove [@start, @start + @size) from e820_table. If @check_type is + * true remove only entries with type @old_type. + */ +u64 __init e820__range_remove(u64 start, u64 size, enum e820_type old_type, + bool check_type) +{ + struct e820_entry_updater updater = { + .should_update = remover__should_update, + .update = remover__update, + .new = NULL + };

- real_removed_size += final_end - final_start; + struct e820_remover_data data = { + .check_type = check_type, + .old_type = old_type + };

- /* - * Left range could be head or tail, so need to update - * the size first: - */ - entry->size -= final_end - final_start; - if (entry->addr < final_start) - continue; + printk(KERN_DEBUG "e820: remove [mem %#018Lx-%#018Lx] ", start, + start + size - 1); + if (check_type) + e820_print_type(old_type); + pr_cont("\n");

- entry->addr = final_end; - } - return real_removed_size; + return __e820__handle_range_update(e820_table, start, size, &updater, + &data); }

void __init e820__update_table_print(void)

Add KUnit tests for the e820_range_* functions.

Signed-off-by: Martin Fernandez martin.fernandez@eclypsium.com --- arch/x86/Kconfig.debug | 10 ++ arch/x86/kernel/e820.c | 5 + arch/x86/kernel/e820_test.c | 249 ++++++++++++++++++++++++++++++++++++ 3 files changed, 264 insertions(+) create mode 100644 arch/x86/kernel/e820_test.c

diff --git a/arch/x86/Kconfig.debug b/arch/x86/Kconfig.debug index d872a7522e55..b5040d345fb4 100644 --- a/arch/x86/Kconfig.debug +++ b/arch/x86/Kconfig.debug @@ -225,6 +225,16 @@ config PUNIT_ATOM_DEBUG The current power state can be read from /sys/kernel/debug/punit_atom/dev_power_state

+config E820_KUNIT_TEST + tristate "Tests for E820" if !KUNIT_ALL_TESTS + depends on KUNIT=y + default KUNIT_ALL_TESTS + help + This option enables unit tests for the e820.c code. It + should be enabled only in development environments. + + If unsure, say N. + choice prompt "Choose kernel unwinder" default UNWINDER_ORC if X86_64 diff --git a/arch/x86/kernel/e820.c b/arch/x86/kernel/e820.c index dade59758b9f..a6ced3e306dd 100644 --- a/arch/x86/kernel/e820.c +++ b/arch/x86/kernel/e820.c @@ -1546,3 +1546,8 @@ void __init e820__memblock_setup(void)

memblock_dump_all(); } + +#ifdef CONFIG_E820_KUNIT_TEST +/* Let e820_test have access the static functions in this file */ +#include "e820_test.c" +#endif diff --git a/arch/x86/kernel/e820_test.c b/arch/x86/kernel/e820_test.c new file mode 100644 index 000000000000..6b28ea131380 --- /dev/null +++ b/arch/x86/kernel/e820_test.c @@ -0,0 +1,249 @@ +// SPDX-License-Identifier: GPL-2.0-only +#include <kunit/test.h> + +#include <asm/e820/api.h> +#include <asm/setup.h> + +#define KUNIT_EXPECT_E820_ENTRY_EQ(_test, _entry, _addr, _size, _type, \ + _crypto_capable) \ + do { \ + KUNIT_EXPECT_EQ((_test), (_entry).addr, (_addr)); \ + KUNIT_EXPECT_EQ((_test), (_entry).size, (_size)); \ + KUNIT_EXPECT_EQ((_test), (_entry).type, (_type)); \ + KUNIT_EXPECT_EQ((_test), (_entry).crypto_capable, \ + (_crypto_capable)); \ + } while (0) + +struct e820_table test_table __initdata; + +static void __init test_e820_range_add(struct kunit *test) +{ + u32 full = ARRAY_SIZE(test_table.entries); + /* Add last entry. */ + test_table.nr_entries = full - 1; + __e820__range_add(&test_table, 0, 15, 0, 0); + KUNIT_EXPECT_EQ(test, test_table.nr_entries, full); + /* Skip new entry when full. */ + __e820__range_add(&test_table, 0, 15, 0, 0); + KUNIT_EXPECT_EQ(test, test_table.nr_entries, full); +} + +static void __init test_e820_range_update(struct kunit *test) +{ + u64 entry_size = 15; + u64 updated_size = 0; + /* Initialize table */ + test_table.nr_entries = 0; + __e820__range_add(&test_table, 0, entry_size, E820_TYPE_RAM, + E820_NOT_CRYPTO_CAPABLE); + __e820__range_add(&test_table, entry_size, entry_size, E820_TYPE_RAM, + E820_NOT_CRYPTO_CAPABLE); + __e820__range_add(&test_table, entry_size * 2, entry_size, + E820_TYPE_ACPI, E820_NOT_CRYPTO_CAPABLE); + + updated_size = __e820__range_update(&test_table, 0, entry_size * 2, + E820_TYPE_RAM, E820_TYPE_RESERVED); + + /* The first 2 regions were updated */ + KUNIT_EXPECT_EQ(test, updated_size, entry_size * 2); + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[0], 0, entry_size, + E820_TYPE_RESERVED, E820_NOT_CRYPTO_CAPABLE); + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[1], entry_size, + entry_size, E820_TYPE_RESERVED, + E820_NOT_CRYPTO_CAPABLE); + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[2], entry_size * 2, + entry_size, E820_TYPE_ACPI, + E820_NOT_CRYPTO_CAPABLE); + + updated_size = __e820__range_update(&test_table, 0, entry_size * 3, + E820_TYPE_RESERVED, E820_TYPE_RAM); + + /* + * Only the first 2 regions were updated, + * since E820_TYPE_ACPI > E820_TYPE_RESERVED + */ + KUNIT_EXPECT_EQ(test, updated_size, entry_size * 2); + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[0], 0, entry_size, + E820_TYPE_RAM, E820_NOT_CRYPTO_CAPABLE); + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[1], entry_size, + entry_size, E820_TYPE_RAM, + E820_NOT_CRYPTO_CAPABLE); + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[2], entry_size * 2, + entry_size, E820_TYPE_ACPI, + E820_NOT_CRYPTO_CAPABLE); +} + +static void __init test_e820_range_remove(struct kunit *test) +{ + u64 entry_size = 15; + u64 removed_size = 0; + + struct e820_entry_updater updater = { .should_update = + remover__should_update, + .update = remover__update, + .new = NULL }; + + struct e820_remover_data data = { .check_type = true, + .old_type = E820_TYPE_RAM }; + + /* Initialize table */ + test_table.nr_entries = 0; + __e820__range_add(&test_table, 0, entry_size, E820_TYPE_RAM, + E820_NOT_CRYPTO_CAPABLE); + __e820__range_add(&test_table, entry_size, entry_size, E820_TYPE_RAM, + E820_NOT_CRYPTO_CAPABLE); + __e820__range_add(&test_table, entry_size * 2, entry_size, + E820_TYPE_ACPI, E820_NOT_CRYPTO_CAPABLE); + + /* + * Need to use __e820__handle_range_update because + * e820__range_remove doesn't ask for the table + */ + removed_size = __e820__handle_range_update(&test_table, + 0, entry_size * 2, + &updater, &data); + + /* The first two regions were removed */ + KUNIT_EXPECT_EQ(test, removed_size, entry_size * 2); + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[0], 0, 0, 0, 0); + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[1], 0, 0, 0, 0); + + removed_size = __e820__handle_range_update(&test_table, + 0, entry_size * 3, + &updater, &data); + + /* Nothing was removed, since nothing matched the target type */ + KUNIT_EXPECT_EQ(test, removed_size, 0); + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[0], 0, 0, 0, 0); + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[1], 0, 0, 0, 0); + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[2], entry_size * 2, + entry_size, E820_TYPE_ACPI, + E820_NOT_CRYPTO_CAPABLE); +} + +static void __init test_e820_range_crypto_update(struct kunit *test) +{ + u64 entry_size = 15; + u64 updated_size = 0; + /* Initialize table */ + test_table.nr_entries = 0; + __e820__range_add(&test_table, 0, entry_size, E820_TYPE_RAM, + E820_CRYPTO_CAPABLE); + __e820__range_add(&test_table, entry_size, entry_size, E820_TYPE_RAM, + E820_NOT_CRYPTO_CAPABLE); + __e820__range_add(&test_table, entry_size * 2, entry_size, + E820_TYPE_RAM, E820_CRYPTO_CAPABLE); + + updated_size = __e820__range_update_crypto(&test_table, + 0, entry_size * 3, + E820_CRYPTO_CAPABLE); + + /* Only the region in the middle was updated */ + KUNIT_EXPECT_EQ(test, updated_size, entry_size); + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[0], 0, entry_size, + E820_TYPE_RAM, E820_CRYPTO_CAPABLE); + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[1], entry_size, + entry_size, E820_TYPE_RAM, + E820_CRYPTO_CAPABLE); + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[2], entry_size * 2, + entry_size, E820_TYPE_RAM, + E820_CRYPTO_CAPABLE); +} + +static void __init test_e820_handle_range_update_intersection(struct kunit *test) +{ + struct e820_entry_updater updater = { + .should_update = type_updater__should_update, + .update = type_updater__update, + .new = type_updater__new + }; + + struct e820_type_updater_data data = { .old_type = E820_TYPE_RAM, + .new_type = E820_TYPE_RESERVED }; + + u64 entry_size = 15; + u64 intersection_size = 2; + u64 updated_size = 0; + /* Initialize table */ + test_table.nr_entries = 0; + __e820__range_add(&test_table, 0, entry_size, E820_TYPE_RAM, + E820_NOT_CRYPTO_CAPABLE); + + updated_size = + __e820__handle_range_update(&test_table, 0, + entry_size - intersection_size, + &updater, &data); + + KUNIT_EXPECT_EQ(test, updated_size, entry_size - intersection_size); + + /* There is a new entry */ + KUNIT_EXPECT_EQ(test, test_table.nr_entries, intersection_size); + + /* The original entry now is moved */ + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[0], + entry_size - intersection_size, + intersection_size, E820_TYPE_RAM, + E820_NOT_CRYPTO_CAPABLE); + + /* The new entry has the correct values */ + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[1], 0, + entry_size - intersection_size, + E820_TYPE_RESERVED, E820_NOT_CRYPTO_CAPABLE); +} + +static void __init test_e820_handle_range_update_inside(struct kunit *test) +{ + struct e820_entry_updater updater = { + .should_update = type_updater__should_update, + .update = type_updater__update, + .new = type_updater__new + }; + + struct e820_type_updater_data data = { .old_type = E820_TYPE_RAM, + .new_type = E820_TYPE_RESERVED }; + + u64 entry_size = 15; + u64 updated_size = 0; + /* Initialize table */ + test_table.nr_entries = 0; + __e820__range_add(&test_table, 0, entry_size, E820_TYPE_RAM, + E820_NOT_CRYPTO_CAPABLE); + + updated_size = __e820__handle_range_update(&test_table, 5, + entry_size - 10, + &updater, &data); + + KUNIT_EXPECT_EQ(test, updated_size, entry_size - 10); + + /* There are two new entrie */ + KUNIT_EXPECT_EQ(test, test_table.nr_entries, 3); + + /* The original entry now shrunk */ + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[0], 0, 5, + E820_TYPE_RAM, E820_NOT_CRYPTO_CAPABLE); + + /* The new entries have the correct values */ + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[1], 5, + entry_size - 10, E820_TYPE_RESERVED, + E820_NOT_CRYPTO_CAPABLE); + /* Left over of the original region */ + KUNIT_EXPECT_E820_ENTRY_EQ(test, test_table.entries[2], entry_size - 5, + 5, E820_TYPE_RAM, E820_NOT_CRYPTO_CAPABLE); +} + +static struct kunit_case e820_test_cases[] __initdata = { + KUNIT_CASE(test_e820_range_add), + KUNIT_CASE(test_e820_range_update), + KUNIT_CASE(test_e820_range_remove), + KUNIT_CASE(test_e820_range_crypto_update), + KUNIT_CASE(test_e820_handle_range_update_intersection), + KUNIT_CASE(test_e820_handle_range_update_inside), + {} +}; + +static struct kunit_suite e820_test_suite __initdata = { + .name = "e820", + .test_cases = e820_test_cases, +}; + +kunit_test_init_section_suite(e820_test_suite);

Show in each node in sysfs if its memory is able to do be encrypted by the CPU; on EFI systems: if all its memory is marked with EFI_MEMORY_CPU_CRYPTO in the EFI memory map.

Signed-off-by: Martin Fernandez martin.fernandez@eclypsium.com --- Documentation/ABI/testing/sysfs-devices-node | 10 ++++++++++ drivers/base/node.c | 10 ++++++++++ 2 files changed, 20 insertions(+) create mode 100644 Documentation/ABI/testing/sysfs-devices-node

diff --git a/Documentation/ABI/testing/sysfs-devices-node b/Documentation/ABI/testing/sysfs-devices-node new file mode 100644 index 000000000000..0e95420bd7c5 --- /dev/null +++ b/Documentation/ABI/testing/sysfs-devices-node @@ -0,0 +1,10 @@ +What: /sys/devices/system/node/nodeX/crypto_capable +Date: April 2022 +Contact: Martin Fernandez martin.fernandez@eclypsium.com +Users: fwupd (https://fwupd.org) +Description: + This value is 1 if all system memory in this node is + capable of being protected with the CPU's memory + cryptographic capabilities. It is 0 otherwise. + On EFI systems the node will be marked with + EFI_MEMORY_CPU_CRYPTO. \ No newline at end of file diff --git a/drivers/base/node.c b/drivers/base/node.c index 0ac6376ef7a1..f081fa48c8e6 100644 --- a/drivers/base/node.c +++ b/drivers/base/node.c @@ -560,11 +560,21 @@ static ssize_t node_read_distance(struct device *dev, } static DEVICE_ATTR(distance, 0444, node_read_distance, NULL);

+static ssize_t crypto_capable_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct pglist_data *pgdat = NODE_DATA(dev->id); + + return sysfs_emit(buf, "%d\n", pgdat->crypto_capable); +} +static DEVICE_ATTR_RO(crypto_capable); + static struct attribute *node_dev_attrs[] = { &dev_attr_meminfo.attr, &dev_attr_numastat.attr, &dev_attr_distance.attr, &dev_attr_vmstat.attr, + &dev_attr_crypto_capable.attr, NULL };