From 9c6628f0595b92ec44c737cf24a79efe0ef5d708 Mon Sep 17 00:00:00 2001 From: "Isaac J. Manjarres" Date: Thu, 10 Oct 2019 13:26:47 -0700 Subject: [PATCH 1/2] soc: qcom: mem-offline: Add a snapshot of the mem-offline driver This is a snapshot of the mem-offline driver as of msm-4.19 commit ef9b421ba16b ("sched: walt: Improve the scheduler"). Change-Id: I81be12ce85033d5d5ab6be8b10aa76a2685d5720 Signed-off-by: Isaac J. Manjarres --- drivers/soc/qcom/Kconfig | 31 ++ drivers/soc/qcom/Makefile | 1 + drivers/soc/qcom/mem-offline.c | 631 +++++++++++++++++++++++++++++++++ 3 files changed, 663 insertions(+) create mode 100644 drivers/soc/qcom/mem-offline.c diff --git a/drivers/soc/qcom/Kconfig b/drivers/soc/qcom/Kconfig index 37d9392a8158..717163231ccd 100644 --- a/drivers/soc/qcom/Kconfig +++ b/drivers/soc/qcom/Kconfig @@ -26,6 +26,37 @@ config QCOM_COMMAND_DB resource on a RPM-hardened platform must use this database to get SoC specific identifier and information for the shared resources. +config QCOM_MEM_OFFLINE + bool "Dynamic Memory Region Offline driver" + depends on MEMORY_HOTPLUG + help + Add support for DDR Self-Refresh power management through the dynamic + memory offline framework. This driver interfaces between the memory + hotplug subsystem and AOP which hot adds or removes memory blocks and + controls the start/stop of self-refresh of these DDR regions. This + helps reduce power consumption during idle mode of the system. + If unsure, say N + +config BUG_ON_HW_MEM_ONLINE_FAIL + bool "Trigger a BUG when HW memory online fails" + depends on QCOM_MEM_OFFLINE + help + Select this option if kernel should BUG when the hardware + onlining of memory hotplug blocks fails. This helps to catch + online failures much quicker and avoids the later side effects + of such memory online failures. + If unsure, say N + +config OVERRIDE_MEMORY_LIMIT + bool "Override memory limit set by the kernel boot parameter" + depends on QCOM_MEM_OFFLINE + help + Override any memory limit set by the kernel boot parameter with + limit set by mem-offline dt entry so that memory offline framework + can initialize remaining memory with movable pages for memory + hot-plugging. + If unsure, say N + config QCOM_GENI_SE tristate "QCOM GENI Serial Engine Driver" depends on ARCH_QCOM || COMPILE_TEST diff --git a/drivers/soc/qcom/Makefile b/drivers/soc/qcom/Makefile index e6ac0b5abba2..18758227c27f 100644 --- a/drivers/soc/qcom/Makefile +++ b/drivers/soc/qcom/Makefile @@ -38,6 +38,7 @@ obj-$(CONFIG_QCOM_APR) += apr.o obj-$(CONFIG_QCOM_LLCC) += llcc-slice.o obj-$(CONFIG_QCOM_LAHAINA_LLCC) += llcc-lahaina.o obj-$(CONFIG_QCOM_MINIDUMP) += msm_minidump.o minidump_log.o +obj-$(CONFIG_QCOM_MEM_OFFLINE) += mem-offline.o obj-$(CONFIG_QCOM_MEMORY_DUMP_V2) += memory_dump_v2.o obj-$(CONFIG_QCOM_DCC_V2) += dcc_v2.o obj-$(CONFIG_MSM_JTAGV8) += jtagv8.o jtagv8-etm.o diff --git a/drivers/soc/qcom/mem-offline.c b/drivers/soc/qcom/mem-offline.c new file mode 100644 index 000000000000..928184e96c7a --- /dev/null +++ b/drivers/soc/qcom/mem-offline.c @@ -0,0 +1,631 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (c) 2018-2019, The Linux Foundation. All rights reserved. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define AOP_MSG_ADDR_MASK 0xffffffff +#define AOP_MSG_ADDR_HIGH_SHIFT 32 +#define MAX_LEN 96 + +static unsigned long start_section_nr, end_section_nr; +static struct kobject *kobj; +static unsigned int sections_per_block; +static u32 offline_granule; +#define MODULE_CLASS_NAME "mem-offline" +#define BUF_LEN 100 + +struct section_stat { + unsigned long success_count; + unsigned long fail_count; + unsigned long avg_time; + unsigned long best_time; + unsigned long worst_time; + unsigned long total_time; + unsigned long last_recorded_time; +}; + +enum memory_states { + MEMORY_ONLINE, + MEMORY_OFFLINE, + MAX_STATE, +}; + +static enum memory_states *mem_sec_state; + +static struct mem_offline_mailbox { + struct mbox_client cl; + struct mbox_chan *mbox; +} mailbox; + +static struct section_stat *mem_info; + +static void clear_pgtable_mapping(phys_addr_t start, phys_addr_t end) +{ + unsigned long size = end - start; + unsigned long virt = (unsigned long)phys_to_virt(start); + unsigned long addr_end = virt + size; + pgd_t *pgd; + pud_t *pud; + pmd_t *pmd; + + pgd = pgd_offset_k(virt); + + while (virt < addr_end) { + + /* Check if we have PUD section mapping */ + pud = pud_offset(pgd, virt); + if (pud_sect(*pud)) { + pud_clear(pud); + virt += PUD_SIZE; + continue; + } + + /* Check if we have PMD section mapping */ + pmd = pmd_offset(pud, virt); + if (pmd_sect(*pmd)) { + pmd_clear(pmd); + virt += PMD_SIZE; + continue; + } + + /* Clear mapping for page entry */ + set_memory_valid(virt, 1, (int)false); + virt += PAGE_SIZE; + } + + virt = (unsigned long)phys_to_virt(start); + flush_tlb_kernel_range(virt, addr_end); +} + +static void record_stat(unsigned long sec, ktime_t delay, int mode) +{ + unsigned int total_sec = end_section_nr - start_section_nr + 1; + unsigned int blk_nr = (sec - start_section_nr + mode * total_sec) / + sections_per_block; + + if (sec > end_section_nr) + return; + + if (delay < mem_info[blk_nr].best_time || !mem_info[blk_nr].best_time) + mem_info[blk_nr].best_time = delay; + + if (delay > mem_info[blk_nr].worst_time) + mem_info[blk_nr].worst_time = delay; + + ++mem_info[blk_nr].success_count; + if (mem_info[blk_nr].fail_count) + --mem_info[blk_nr].fail_count; + + mem_info[blk_nr].total_time += delay; + + mem_info[blk_nr].avg_time = + mem_info[blk_nr].total_time / mem_info[blk_nr].success_count; + + mem_info[blk_nr].last_recorded_time = delay; +} + +static int aop_send_msg(unsigned long addr, bool online) +{ + struct qmp_pkt pkt; + char mbox_msg[MAX_LEN]; + unsigned long addr_low, addr_high; + + addr_low = addr & AOP_MSG_ADDR_MASK; + addr_high = (addr >> AOP_MSG_ADDR_HIGH_SHIFT) & AOP_MSG_ADDR_MASK; + + snprintf(mbox_msg, MAX_LEN, + "{class: ddr, event: pasr, addr_hi: 0x%08lx, addr_lo: 0x%08lx, refresh: %s}", + addr_high, addr_low, online ? "on" : "off"); + + pkt.size = MAX_LEN; + pkt.data = mbox_msg; + return (mbox_send_message(mailbox.mbox, &pkt) < 0); +} + +/* + * When offline_granule >= memory block size, this returns the number of + * sections in a offlineable segment. + * When offline_granule < memory block size, returns the sections_per_block. + */ +static unsigned long get_rounded_sections_per_segment(void) +{ + + return max(((offline_granule * SZ_1M) / memory_block_size_bytes()) * + sections_per_block, + (unsigned long)sections_per_block); +} + +static int send_msg(struct memory_notify *mn, bool online, int count) +{ + unsigned long segment_size = offline_granule * SZ_1M; + unsigned long start, base_sec_nr, sec_nr, sections_per_segment; + int ret, idx, i; + + sections_per_segment = get_rounded_sections_per_segment(); + sec_nr = pfn_to_section_nr(SECTION_ALIGN_DOWN(mn->start_pfn)); + idx = (sec_nr - start_section_nr) / sections_per_segment; + base_sec_nr = start_section_nr + (idx * sections_per_segment); + start = section_nr_to_pfn(base_sec_nr); + + for (i = 0; i < count; ++i) { + ret = aop_send_msg(__pfn_to_phys(start), online); + if (ret) { + pr_err("PASR: AOP %s request addr:0x%llx failed\n", + online ? "online" : "offline", + __pfn_to_phys(start)); + goto undo; + } + + start = __phys_to_pfn(__pfn_to_phys(start) + segment_size); + } + + return 0; +undo: + start = section_nr_to_pfn(base_sec_nr); + while (i-- > 0) { + int ret; + + ret = aop_send_msg(__pfn_to_phys(start), !online); + if (ret) + panic("Failed to completely online/offline a hotpluggable segment. A quasi state of memblock can cause randomn system failures."); + start = __phys_to_pfn(__pfn_to_phys(start) + segment_size); + } + + return ret; +} + +static bool need_to_send_remote_request(struct memory_notify *mn, + enum memory_states request) +{ + int i, idx, cur_idx; + int base_sec_nr, sec_nr; + unsigned long sections_per_segment; + + sections_per_segment = get_rounded_sections_per_segment(); + sec_nr = pfn_to_section_nr(SECTION_ALIGN_DOWN(mn->start_pfn)); + idx = (sec_nr - start_section_nr) / sections_per_segment; + cur_idx = (sec_nr - start_section_nr) / sections_per_block; + base_sec_nr = start_section_nr + (idx * sections_per_segment); + + /* + * For MEM_OFFLINE, don't send the request if there are other online + * blocks in the segment. + * For MEM_ONLINE, don't send the request if there is already one + * online block in the segment. + */ + if (request == MEMORY_OFFLINE || request == MEMORY_ONLINE) { + for (i = base_sec_nr; + i < (base_sec_nr + sections_per_segment); + i += sections_per_block) { + idx = (i - start_section_nr) / sections_per_block; + /* current operating block */ + if (idx == cur_idx) + continue; + if (mem_sec_state[idx] == MEMORY_ONLINE) + goto out; + } + return true; + } +out: + return false; +} + +/* + * This returns the number of hotpluggable segments in a memory block. + */ +static int get_num_memblock_hotplug_segments(void) +{ + unsigned long segment_size = offline_granule * SZ_1M; + unsigned long block_size = memory_block_size_bytes(); + + if (segment_size < block_size) { + if (block_size % segment_size) { + pr_warn("PASR is unusable. Offline granule size should be in multiples for memory_block_size_bytes.\n"); + return 0; + } + return block_size / segment_size; + } + + return 1; +} + +static int mem_change_refresh_state(struct memory_notify *mn, + enum memory_states state) +{ + int start = SECTION_ALIGN_DOWN(mn->start_pfn); + unsigned long sec_nr = pfn_to_section_nr(start); + bool online = (state == MEMORY_ONLINE) ? true : false; + unsigned long idx = (sec_nr - start_section_nr) / sections_per_block; + int ret, count; + + if (mem_sec_state[idx] == state) { + /* we shouldn't be getting this request */ + pr_warn("mem-offline: state of mem%d block already in %s state. Ignoring refresh state change request\n", + sec_nr, online ? "online" : "offline"); + return 0; + } + + count = get_num_memblock_hotplug_segments(); + if (!count) + return -EINVAL; + + if (!need_to_send_remote_request(mn, state)) + goto out; + + ret = send_msg(mn, online, count); + if (ret) { + /* online failures are critical failures */ + if (online) + BUG_ON(IS_ENABLED(CONFIG_BUG_ON_HW_MEM_ONLINE_FAIL)); + return -EINVAL; + } +out: + mem_sec_state[idx] = state; + return 0; +} + +static int mem_event_callback(struct notifier_block *self, + unsigned long action, void *arg) +{ + struct memory_notify *mn = arg; + unsigned long start, end, sec_nr; + static ktime_t cur; + ktime_t delay = 0; + phys_addr_t start_addr, end_addr; + unsigned int idx = end_section_nr - start_section_nr + 1; + + start = SECTION_ALIGN_DOWN(mn->start_pfn); + end = SECTION_ALIGN_UP(mn->start_pfn + mn->nr_pages); + + if ((start != mn->start_pfn) || (end != mn->start_pfn + mn->nr_pages)) { + WARN("mem-offline: %s pfn not aligned to section\n", __func__); + pr_err("mem-offline: start pfn = %lu end pfn = %lu\n", + mn->start_pfn, mn->start_pfn + mn->nr_pages); + return -EINVAL; + } + + start_addr = __pfn_to_phys(start); + end_addr = __pfn_to_phys(end); + sec_nr = pfn_to_section_nr(start); + + if (sec_nr > end_section_nr || sec_nr < start_section_nr) { + if (action == MEM_ONLINE || action == MEM_OFFLINE) + pr_info("mem-offline: %s mem%ld, but not our block. Not performing any action\n", + action == MEM_ONLINE ? "Onlined" : "Offlined", + sec_nr); + return NOTIFY_OK; + } + switch (action) { + case MEM_GOING_ONLINE: + pr_debug("mem-offline: MEM_GOING_ONLINE : start = 0x%llx end = 0x%llx\n", + start_addr, end_addr); + ++mem_info[(sec_nr - start_section_nr + MEMORY_ONLINE * + idx) / sections_per_block].fail_count; + cur = ktime_get(); + + if (mem_change_refresh_state(mn, MEMORY_ONLINE)) + return NOTIFY_BAD; + + if (!debug_pagealloc_enabled()) { + /* Create kernel page-tables */ + create_pgtable_mapping(start_addr, end_addr); + } + + break; + case MEM_ONLINE: + delay = ktime_ms_delta(ktime_get(), cur); + record_stat(sec_nr, delay, MEMORY_ONLINE); + cur = 0; + pr_info("mem-offline: Onlined memory block mem%pK\n", + (void *)sec_nr); + break; + case MEM_GOING_OFFLINE: + pr_debug("mem-offline: MEM_GOING_OFFLINE : start = 0x%llx end = 0x%llx\n", + start_addr, end_addr); + ++mem_info[(sec_nr - start_section_nr + MEMORY_OFFLINE * + idx) / sections_per_block].fail_count; + cur = ktime_get(); + break; + case MEM_OFFLINE: + if (!debug_pagealloc_enabled()) { + /* Clear kernel page-tables */ + clear_pgtable_mapping(start_addr, end_addr); + } + mem_change_refresh_state(mn, MEMORY_OFFLINE); + /* + * Notifying that something went bad at this stage won't + * help since this is the last stage of memory hotplug. + */ + + delay = ktime_ms_delta(ktime_get(), cur); + record_stat(sec_nr, delay, MEMORY_OFFLINE); + cur = 0; + pr_info("mem-offline: Offlined memory block mem%pK\n", + (void *)sec_nr); + break; + case MEM_CANCEL_ONLINE: + pr_info("mem-offline: MEM_CANCEL_ONLINE: start = 0x%llx end = 0x%llx\n", + start_addr, end_addr); + mem_change_refresh_state(mn, MEMORY_OFFLINE); + break; + default: + break; + } + return NOTIFY_OK; +} + +static int mem_online_remaining_blocks(void) +{ + unsigned long memblock_end_pfn = __phys_to_pfn(memblock_end_of_DRAM()); + unsigned long ram_end_pfn = __phys_to_pfn(bootloader_memory_limit - 1); + unsigned long block_size, memblock, pfn; + unsigned int nid; + phys_addr_t phys_addr; + int fail = 0; + + block_size = memory_block_size_bytes(); + sections_per_block = block_size / MIN_MEMORY_BLOCK_SIZE; + + start_section_nr = pfn_to_section_nr(memblock_end_pfn); + end_section_nr = pfn_to_section_nr(ram_end_pfn); + + if (memblock_end_of_DRAM() >= bootloader_memory_limit) { + pr_info("mem-offline: System booted with no zone movable memory blocks. Cannot perform memory offlining\n"); + return -EINVAL; + } + for (memblock = start_section_nr; memblock <= end_section_nr; + memblock += sections_per_block) { + pfn = section_nr_to_pfn(memblock); + phys_addr = __pfn_to_phys(pfn); + + if (phys_addr & (((PAGES_PER_SECTION * sections_per_block) + << PAGE_SHIFT) - 1)) { + fail = 1; + pr_warn("mem-offline: PFN of mem%lu block not aligned to section start. Not adding this memory block\n", + memblock); + continue; + } + nid = memory_add_physaddr_to_nid(phys_addr); + if (add_memory(nid, phys_addr, + MIN_MEMORY_BLOCK_SIZE * sections_per_block)) { + pr_warn("mem-offline: Adding memory block mem%lu failed\n", + memblock); + fail = 1; + } + } + + max_pfn = PFN_DOWN(memblock_end_of_DRAM()); + return fail; +} + +static ssize_t show_mem_offline_granule(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + return snprintf(buf, BUF_LEN, "%lu\n", (unsigned long)offline_granule * + SZ_1M); +} + +static ssize_t show_mem_perf_stats(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + + unsigned int blk_start = start_section_nr / sections_per_block; + unsigned int blk_end = end_section_nr / sections_per_block; + unsigned int idx = blk_end - blk_start + 1; + unsigned int char_count = 0; + unsigned int i, j; + + for (j = 0; j < MAX_STATE; j++) { + char_count += snprintf(buf + char_count, BUF_LEN, + "\n\t%s\n\t\t\t", j == 0 ? "ONLINE" : "OFFLINE"); + for (i = blk_start; i <= blk_end; i++) + char_count += snprintf(buf + char_count, BUF_LEN, + "%s%d\t\t", "mem", i); + char_count += snprintf(buf + char_count, BUF_LEN, "\n"); + char_count += snprintf(buf + char_count, BUF_LEN, + "\tLast recd time:\t"); + for (i = 0; i <= blk_end - blk_start; i++) + char_count += snprintf(buf + char_count, BUF_LEN, + "%lums\t\t", mem_info[i+j*idx].last_recorded_time); + char_count += snprintf(buf + char_count, BUF_LEN, "\n"); + char_count += snprintf(buf + char_count, BUF_LEN, + "\tAvg time:\t"); + for (i = 0; i <= blk_end - blk_start; i++) + char_count += snprintf(buf + char_count, BUF_LEN, + "%lums\t\t", mem_info[i+j*idx].avg_time); + char_count += snprintf(buf + char_count, BUF_LEN, "\n"); + char_count += snprintf(buf + char_count, BUF_LEN, + "\tBest time:\t"); + for (i = 0; i <= blk_end - blk_start; i++) + char_count += snprintf(buf + char_count, BUF_LEN, + "%lums\t\t", mem_info[i+j*idx].best_time); + char_count += snprintf(buf + char_count, BUF_LEN, "\n"); + char_count += snprintf(buf + char_count, BUF_LEN, + "\tWorst time:\t"); + for (i = 0; i <= blk_end - blk_start; i++) + char_count += snprintf(buf + char_count, BUF_LEN, + "%lums\t\t", mem_info[i+j*idx].worst_time); + char_count += snprintf(buf + char_count, BUF_LEN, "\n"); + char_count += snprintf(buf + char_count, BUF_LEN, + "\tSuccess count:\t"); + for (i = 0; i <= blk_end - blk_start; i++) + char_count += snprintf(buf + char_count, BUF_LEN, + "%lu\t\t", mem_info[i+j*idx].success_count); + char_count += snprintf(buf + char_count, BUF_LEN, "\n"); + char_count += snprintf(buf + char_count, BUF_LEN, + "\tFail count:\t"); + for (i = 0; i <= blk_end - blk_start; i++) + char_count += snprintf(buf + char_count, BUF_LEN, + "%lu\t\t", mem_info[i+j*idx].fail_count); + char_count += snprintf(buf + char_count, BUF_LEN, "\n"); + } + return char_count; +} + +static struct kobj_attribute perf_stats_attr = + __ATTR(perf_stats, 0444, show_mem_perf_stats, NULL); + +static struct kobj_attribute offline_granule_attr = + __ATTR(offline_granule, 0444, show_mem_offline_granule, NULL); + +static struct attribute *mem_root_attrs[] = { + &perf_stats_attr.attr, + &offline_granule_attr.attr, + NULL, +}; + +static struct attribute_group mem_attr_group = { + .attrs = mem_root_attrs, +}; + +static int mem_sysfs_init(void) +{ + if (start_section_nr == end_section_nr) + return -EINVAL; + + kobj = kobject_create_and_add(MODULE_CLASS_NAME, kernel_kobj); + if (!kobj) + return -ENOMEM; + + if (sysfs_create_group(kobj, &mem_attr_group)) + kobject_put(kobj); + + return 0; +} + +static int mem_parse_dt(struct platform_device *pdev) +{ + const __be32 *val; + struct device_node *node = pdev->dev.of_node; + + val = of_get_property(node, "granule", NULL); + if (!val) { + pr_err("mem-offine: granule property not found in DT\n"); + return -EINVAL; + } + if (!*val) { + pr_err("mem-offine: invalid granule property\n"); + return -EINVAL; + } + offline_granule = be32_to_cpup(val); + if (!offline_granule || (offline_granule & (offline_granule - 1)) || + ((offline_granule * SZ_1M < MIN_MEMORY_BLOCK_SIZE) && + (MIN_MEMORY_BLOCK_SIZE % (offline_granule * SZ_1M)))) { + pr_err("mem-offine: invalid granule property\n"); + return -EINVAL; + } + + mailbox.cl.dev = &pdev->dev; + mailbox.cl.tx_block = true; + mailbox.cl.tx_tout = 1000; + mailbox.cl.knows_txdone = false; + + mailbox.mbox = mbox_request_channel(&mailbox.cl, 0); + if (IS_ERR(mailbox.mbox)) { + if (PTR_ERR(mailbox.mbox) != -EPROBE_DEFER) + pr_err("mem-offline: failed to get mailbox channel %pK %ld\n", + mailbox.mbox, PTR_ERR(mailbox.mbox)); + return PTR_ERR(mailbox.mbox); + } + + return 0; +} + +static struct notifier_block hotplug_memory_callback_nb = { + .notifier_call = mem_event_callback, + .priority = 0, +}; + +static int mem_offline_driver_probe(struct platform_device *pdev) +{ + unsigned int total_blks; + int ret, i; + + ret = mem_parse_dt(pdev); + if (ret) + return ret; + + ret = mem_online_remaining_blocks(); + if (ret < 0) + return -ENODEV; + + if (ret > 0) + pr_err("mem-offline: !!ERROR!! Auto onlining some memory blocks failed. System could run with less RAM\n"); + + total_blks = (end_section_nr - start_section_nr + 1) / + sections_per_block; + mem_info = kcalloc(total_blks * MAX_STATE, sizeof(*mem_info), + GFP_KERNEL); + if (!mem_info) + return -ENOMEM; + + mem_sec_state = kcalloc(total_blks, sizeof(*mem_sec_state), GFP_KERNEL); + if (!mem_sec_state) { + ret = -ENOMEM; + goto err_free_mem_info; + } + + /* we assume that hardware state of mem blocks are online after boot */ + for (i = 0; i < total_blks; i++) + mem_sec_state[i] = MEMORY_ONLINE; + + if (mem_sysfs_init()) { + ret = -ENODEV; + goto err_free_mem_sec_state; + } + + if (register_hotmemory_notifier(&hotplug_memory_callback_nb)) { + pr_err("mem-offline: Registering memory hotplug notifier failed\n"); + ret = -ENODEV; + goto err_sysfs_remove_group; + } + pr_info("mem-offline: Added memory blocks ranging from mem%lu - mem%lu\n", + start_section_nr, end_section_nr); + + return 0; + +err_sysfs_remove_group: + sysfs_remove_group(kobj, &mem_attr_group); + kobject_put(kobj); +err_free_mem_sec_state: + kfree(mem_sec_state); +err_free_mem_info: + kfree(mem_info); + return ret; +} + +static const struct of_device_id mem_offline_match_table[] = { + {.compatible = "qcom,mem-offline"}, + {} +}; + +static struct platform_driver mem_offline_driver = { + .probe = mem_offline_driver_probe, + .driver = { + .name = "mem_offline", + .of_match_table = mem_offline_match_table, + }, +}; + +static int __init mem_module_init(void) +{ + return platform_driver_register(&mem_offline_driver); +} + +subsys_initcall(mem_module_init); From e39b3da82e65da93934df483903464b2c3c3510a Mon Sep 17 00:00:00 2001 From: Sudarshan Rajagopalan Date: Fri, 27 Apr 2018 14:41:03 -0700 Subject: [PATCH 2/2] arm64: Override memory limit set by boot parameter To guarantee successful hot-plugging of memory blocks, these blocks should belong to ZONE_MOVABLE which has migratable pages. Linux kernel during boot initializes all the available memory blocks to ZONE_DMA and ZONE_NORMAL. Hence, boot the system with less memory whose percentage is given by mem-offline DT property 'mem-percent' and override any memory limit imposed by kernel boot params and let mem-offline driver initialize the remaining with ZONE_MOVABLE. The memory blocks in this zone are applicable for memory offlining. Change-Id: Ia7b804522fe9425101ee83d1ee354ed09483df13 Signed-off-by: Sudarshan Rajagopalan [swatsrid@codeaurora.org: Fix merge conflicts] Signed-off-by: Swathi Sridhar Signed-off-by: Isaac J. Manjarres --- arch/arm64/mm/init.c | 48 ++++++++++++++++++++++++++++++++++++++++ drivers/soc/qcom/Kconfig | 10 +++++++++ 2 files changed, 58 insertions(+) diff --git a/arch/arm64/mm/init.c b/arch/arm64/mm/init.c index 3184ceccc288..3710fb71b50b 100644 --- a/arch/arm64/mm/init.c +++ b/arch/arm64/mm/init.c @@ -28,6 +28,8 @@ #include #include #include +#include +#include #include #include @@ -259,6 +261,51 @@ EXPORT_SYMBOL(pfn_valid); static phys_addr_t memory_limit = PHYS_ADDR_MAX; phys_addr_t bootloader_memory_limit; +#ifdef CONFIG_OVERRIDE_MEMORY_LIMIT +static void __init update_memory_limit(void) +{ + unsigned long dt_root = of_get_flat_dt_root(); + unsigned long node, mp; + const char *p; + unsigned long long ram_sz, sz; + int ret; + + ram_sz = memblock_end_of_DRAM() - memblock_start_of_DRAM(); + node = of_get_flat_dt_subnode_by_name(dt_root, "mem-offline"); + if (node == -FDT_ERR_NOTFOUND) { + pr_err("mem-offine node not found in FDT\n"); + return; + } + p = of_get_flat_dt_prop(node, "mem-percent", NULL); + if (!p) { + pr_err("mem-offine: mem-percent property not found in FDT\n"); + return; + } + + ret = kstrtoul(p, 10, &mp); + if (ret) { + pr_err("mem-offine: kstrtoul failed\n"); + return; + } + + if (mp > 100) { + pr_err("mem-offine: Invalid mem-percent DT property\n"); + return; + } + sz = ram_sz - ((ram_sz * mp) / 100); + memory_limit = (phys_addr_t)sz; + memory_limit = ALIGN(memory_limit, MIN_MEMORY_BLOCK_SIZE); + + pr_notice("Memory limit set/overridden to %lldMB\n", + memory_limit >> 20); +} +#else +static void __init update_memory_limit(void) +{ + +} +#endif + /* * Limit the memory size that was specified via FDT. */ @@ -350,6 +397,7 @@ void __init arm64_memblock_init(void) memblock_remove(0, memstart_addr); } + update_memory_limit(); /* * Save bootloader imposed memory limit before we overwirte * memblock. diff --git a/drivers/soc/qcom/Kconfig b/drivers/soc/qcom/Kconfig index 717163231ccd..67f6406240c8 100644 --- a/drivers/soc/qcom/Kconfig +++ b/drivers/soc/qcom/Kconfig @@ -66,6 +66,16 @@ config QCOM_GENI_SE driver is also used to manage the common aspects of multiple Serial Engines present in the QUP. +config OVERRIDE_MEMORY_LIMIT + bool "Override memory limit set by the kernel boot parameter" + depends on QCOM_MEM_OFFLINE + help + Override any memory limit set by the kernel boot parameter with + limit set by mem-offline dt entry so that memory offline framework + can initialize remaining memory with movable pages for memory + hot-plugging. + If unsure, say N + config QCOM_GLINK_SSR tristate "Qualcomm Glink SSR driver" depends on RPMSG