* [PATCH v11 08/14] powerpc/vas: Update CSB and notify process for fault CRBs
From: Haren Myneni @ 2020-04-16 6:03 UTC (permalink / raw)
To: mpe
Cc: mikey, srikar, frederic.barrat, ajd, linux-kernel, npiggin, hch,
oohall, clg, sukadev, linuxppc-dev, herbert
In-Reply-To: <1587016214.2275.1036.camel@hbabu-laptop>
Applications polls on CSB for the status update after requests are
issued. NX process these requests and update the CSB with the status.
If it encounters translation error, pastes CRB in fault FIFO and
raises an interrupt. The kernel handles fault by reading CRB from
fault FIFO and process the fault CRB.
For each fault CRB, update fault address in CRB (fault_storage_addr)
and translation error status in CSB so that user space can touch the
fault address and resend the request. If the user space passed invalid
CSB address send signal to process with SIGSEGV.
In the case of multi-thread applications, child thread may not be
available. So if the task is not running, send signal to tgid.
Signed-off-by: Sukadev Bhattiprolu <sukadev@linux.vnet.ibm.com>
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
---
arch/powerpc/platforms/powernv/vas-fault.c | 126 ++++++++++++++++++++++++++++-
1 file changed, 125 insertions(+), 1 deletion(-)
diff --git a/arch/powerpc/platforms/powernv/vas-fault.c b/arch/powerpc/platforms/powernv/vas-fault.c
index 0da8358..354577d 100644
--- a/arch/powerpc/platforms/powernv/vas-fault.c
+++ b/arch/powerpc/platforms/powernv/vas-fault.c
@@ -11,6 +11,7 @@
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/kthread.h>
+#include <linux/sched/signal.h>
#include <linux/mmu_context.h>
#include <asm/icswx.h>
@@ -26,6 +27,128 @@
#define VAS_FAULT_WIN_FIFO_SIZE (4 << 20)
/*
+ * Update the CSB to indicate a translation error.
+ *
+ * User space will be polling on CSB after the request is issued.
+ * If NX can handle the request without any issues, it updates CSB.
+ * Whereas if NX encounters page fault, the kernel will handle the
+ * fault and update CSB with translation error.
+ *
+ * If we are unable to update the CSB means copy_to_user failed due to
+ * invalid csb_addr, send a signal to the process.
+ */
+static void update_csb(struct vas_window *window,
+ struct coprocessor_request_block *crb)
+{
+ struct coprocessor_status_block csb;
+ struct kernel_siginfo info;
+ struct task_struct *tsk;
+ void __user *csb_addr;
+ struct pid *pid;
+ int rc;
+
+ /*
+ * NX user space windows can not be opened for task->mm=NULL
+ * and faults will not be generated for kernel requests.
+ */
+ if (WARN_ON_ONCE(!window->mm || !window->user_win))
+ return;
+
+ csb_addr = (void __user *)be64_to_cpu(crb->csb_addr);
+
+ memset(&csb, 0, sizeof(csb));
+ csb.cc = CSB_CC_TRANSLATION;
+ csb.ce = CSB_CE_TERMINATION;
+ csb.cs = 0;
+ csb.count = 0;
+
+ /*
+ * NX operates and returns in BE format as defined CRB struct.
+ * So saves fault_storage_addr in BE as NX pastes in FIFO and
+ * expects user space to convert to CPU format.
+ */
+ csb.address = crb->stamp.nx.fault_storage_addr;
+ csb.flags = 0;
+
+ pid = window->pid;
+ tsk = get_pid_task(pid, PIDTYPE_PID);
+ /*
+ * Process closes send window after all pending NX requests are
+ * completed. In multi-thread applications, a child thread can
+ * open a window and can exit without closing it. May be some
+ * requests are pending or this window can be used by other
+ * threads later. We should handle faults if NX encounters
+ * pages faults on these requests. Update CSB with translation
+ * error and fault address. If csb_addr passed by user space is
+ * invalid, send SEGV signal to pid saved in window. If the
+ * child thread is not running, send the signal to tgid.
+ * Parent thread (tgid) will close this window upon its exit.
+ *
+ * pid and mm references are taken when window is opened by
+ * process (pid). So tgid is used only when child thread opens
+ * a window and exits without closing it.
+ */
+ if (!tsk) {
+ pid = window->tgid;
+ tsk = get_pid_task(pid, PIDTYPE_PID);
+ /*
+ * Parent thread (tgid) will be closing window when it
+ * exits. So should not get here.
+ */
+ if (WARN_ON_ONCE(!tsk))
+ return;
+ }
+
+ /* Return if the task is exiting. */
+ if (tsk->flags & PF_EXITING) {
+ put_task_struct(tsk);
+ return;
+ }
+
+ use_mm(window->mm);
+ rc = copy_to_user(csb_addr, &csb, sizeof(csb));
+ /*
+ * User space polls on csb.flags (first byte). So add barrier
+ * then copy first byte with csb flags update.
+ */
+ if (!rc) {
+ csb.flags = CSB_V;
+ /* Make sure update to csb.flags is visible now */
+ smp_mb();
+ rc = copy_to_user(csb_addr, &csb, sizeof(u8));
+ }
+ unuse_mm(window->mm);
+ put_task_struct(tsk);
+
+ /* Success */
+ if (!rc)
+ return;
+
+ pr_debug("Invalid CSB address 0x%p signalling pid(%d)\n",
+ csb_addr, pid_vnr(pid));
+
+ clear_siginfo(&info);
+ info.si_signo = SIGSEGV;
+ info.si_errno = EFAULT;
+ info.si_code = SEGV_MAPERR;
+ info.si_addr = csb_addr;
+
+ /*
+ * process will be polling on csb.flags after request is sent to
+ * NX. So generally CSB update should not fail except when an
+ * application passes invalid csb_addr. So an error message will
+ * be displayed and leave it to user space whether to ignore or
+ * handle this signal.
+ */
+ rcu_read_lock();
+ rc = kill_pid_info(SIGSEGV, &info, pid);
+ rcu_read_unlock();
+
+ pr_devel("%s(): pid %d kill_proc_info() rc %d\n", __func__,
+ pid_vnr(pid), rc);
+}
+
+/*
* Process valid CRBs in fault FIFO.
* NX process user space requests, return credit and update the status
* in CRB. If it encounters transalation error when accessing CRB or
@@ -124,8 +247,9 @@ irqreturn_t vas_fault_thread_fn(int irq, void *data)
vinst->fault_crbs);
WARN_ON_ONCE(1);
+ } else {
+ update_csb(window, crb);
}
-
}
}
--
1.8.3.1
^ permalink raw reply related
* [PATCH v11 06/14] powerpc/vas: Take reference to PID and mm for user space windows
From: Haren Myneni @ 2020-04-16 6:02 UTC (permalink / raw)
To: mpe
Cc: mikey, srikar, frederic.barrat, ajd, linux-kernel, npiggin, hch,
oohall, clg, sukadev, linuxppc-dev, herbert
In-Reply-To: <1587016214.2275.1036.camel@hbabu-laptop>
When process opens a window, its pid and tgid will be saved in the
vas_window struct. This window will be closed when the process exits.
The kernel handles NX faults by updating CSB or send SEGV signal to pid
of the process if the userspace csb addr is invalid.
In multi-thread applications, a window can be opened by a child thread,
but it will not be closed when this thread exits. It is expected that
the parent will clean up all resources including NX windows opened by
child threads. A child thread can send NX requests using this window
and could be killed before completion is reported. If the pid assigned
to this thread is reused while requests are pending, a failure SEGV
would be directed to the wrong place.
To prevent reusing the pid, take references to pid and mm when the window
is opened and release them when when the window is closed. Then if child
thread is not running, SEGV signal will be sent to thread group leader
(tgid).
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
---
arch/powerpc/platforms/powernv/vas-debug.c | 2 +-
arch/powerpc/platforms/powernv/vas-window.c | 50 ++++++++++++++++++++++++++---
arch/powerpc/platforms/powernv/vas.h | 9 +++++-
3 files changed, 55 insertions(+), 6 deletions(-)
diff --git a/arch/powerpc/platforms/powernv/vas-debug.c b/arch/powerpc/platforms/powernv/vas-debug.c
index 09e63df..ef9a717 100644
--- a/arch/powerpc/platforms/powernv/vas-debug.c
+++ b/arch/powerpc/platforms/powernv/vas-debug.c
@@ -38,7 +38,7 @@ static int info_show(struct seq_file *s, void *private)
seq_printf(s, "Type: %s, %s\n", cop_to_str(window->cop),
window->tx_win ? "Send" : "Receive");
- seq_printf(s, "Pid : %d\n", window->pid);
+ seq_printf(s, "Pid : %d\n", vas_window_pid(window));
unlock:
mutex_unlock(&vas_mutex);
diff --git a/arch/powerpc/platforms/powernv/vas-window.c b/arch/powerpc/platforms/powernv/vas-window.c
index dc46bf6..063cda2 100644
--- a/arch/powerpc/platforms/powernv/vas-window.c
+++ b/arch/powerpc/platforms/powernv/vas-window.c
@@ -12,6 +12,8 @@
#include <linux/log2.h>
#include <linux/rcupdate.h>
#include <linux/cred.h>
+#include <linux/sched/mm.h>
+#include <linux/mmu_context.h>
#include <asm/switch_to.h>
#include <asm/ppc-opcode.h>
#include "vas.h"
@@ -876,8 +878,6 @@ struct vas_window *vas_rx_win_open(int vasid, enum vas_cop_type cop,
rxwin->user_win = rxattr->user_win;
rxwin->cop = cop;
rxwin->wcreds_max = rxattr->wcreds_max ?: VAS_WCREDS_DEFAULT;
- if (rxattr->user_win)
- rxwin->pid = task_pid_vnr(current);
init_winctx_for_rxwin(rxwin, rxattr, &winctx);
init_winctx_regs(rxwin, &winctx);
@@ -1027,7 +1027,6 @@ struct vas_window *vas_tx_win_open(int vasid, enum vas_cop_type cop,
txwin->tx_win = 1;
txwin->rxwin = rxwin;
txwin->nx_win = txwin->rxwin->nx_win;
- txwin->pid = attr->pid;
txwin->user_win = attr->user_win;
txwin->wcreds_max = attr->wcreds_max ?: VAS_WCREDS_DEFAULT;
@@ -1057,6 +1056,40 @@ struct vas_window *vas_tx_win_open(int vasid, enum vas_cop_type cop,
rc = set_thread_uses_vas();
if (rc)
goto free_window;
+
+ /*
+ * Window opened by a child thread may not be closed when
+ * it exits. So take reference to its pid and release it
+ * when the window is free by parent thread.
+ * Acquire a reference to the task's pid to make sure
+ * pid will not be re-used - needed only for multithread
+ * applications.
+ */
+ txwin->pid = get_task_pid(current, PIDTYPE_PID);
+ /*
+ * Acquire a reference to the task's mm.
+ */
+ txwin->mm = get_task_mm(current);
+
+ if (!txwin->mm) {
+ put_pid(txwin->pid);
+ pr_err("VAS: pid(%d): mm_struct is not found\n",
+ current->pid);
+ rc = -EPERM;
+ goto free_window;
+ }
+
+ mmgrab(txwin->mm);
+ mmput(txwin->mm);
+ mm_context_add_copro(txwin->mm);
+ /*
+ * Process closes window during exit. In the case of
+ * multithread application, the child thread can open
+ * window and can exit without closing it. Expects parent
+ * thread to use and close the window. So do not need
+ * to take pid reference for parent thread.
+ */
+ txwin->tgid = find_get_pid(task_tgid_vnr(current));
}
set_vinst_win(vinst, txwin);
@@ -1257,8 +1290,17 @@ int vas_win_close(struct vas_window *window)
poll_window_castout(window);
/* if send window, drop reference to matching receive window */
- if (window->tx_win)
+ if (window->tx_win) {
+ if (window->user_win) {
+ /* Drop references to pid and mm */
+ put_pid(window->pid);
+ if (window->mm) {
+ mm_context_remove_copro(window->mm);
+ mmdrop(window->mm);
+ }
+ }
put_rx_win(window->rxwin);
+ }
vas_window_free(window);
diff --git a/arch/powerpc/platforms/powernv/vas.h b/arch/powerpc/platforms/powernv/vas.h
index 88d084d..2a04072 100644
--- a/arch/powerpc/platforms/powernv/vas.h
+++ b/arch/powerpc/platforms/powernv/vas.h
@@ -355,7 +355,9 @@ struct vas_window {
bool user_win; /* True if user space window */
void *hvwc_map; /* HV window context */
void *uwc_map; /* OS/User window context */
- pid_t pid; /* Linux process id of owner */
+ struct pid *pid; /* Linux process id of owner */
+ struct pid *tgid; /* Thread group ID of owner */
+ struct mm_struct *mm; /* Linux process mm_struct */
int wcreds_max; /* Window credits */
char *dbgname;
@@ -430,6 +432,11 @@ struct vas_winctx {
extern void vas_window_free_dbgdir(struct vas_window *win);
extern int vas_setup_fault_window(struct vas_instance *vinst);
+static inline int vas_window_pid(struct vas_window *window)
+{
+ return pid_vnr(window->pid);
+}
+
static inline void vas_log_write(struct vas_window *win, char *name,
void *regptr, u64 val)
{
--
1.8.3.1
^ permalink raw reply related
* Re: [PATCH v2,5/5] drivers: uio: new driver for fsl_85xx_cache_sram
From: Christophe Leroy @ 2020-04-16 6:02 UTC (permalink / raw)
To: Wang Wenhu; +Cc: linux-kernel, oss, kernel, gregkh, linuxppc-dev
In-Reply-To: <20200416052247.112887-1-wenhu.wang@vivo.com>
Le 16/04/2020 à 07:22, Wang Wenhu a écrit :
> Yes, kzalloc() would clean the allocated areas and the init of remaining array
> elements are redundant. I will remove the block in v3.
>
>>>> + dev_err(&pdev->dev, "error no valid uio-map configured\n");
>>>> + ret = -EINVAL;
>>>> + goto err_info_free_internel;
>>>> + }
>>>> +
>>>> + info->version = "0.1.0";
>>>
>>> Could you define some DRIVER_VERSION in the top of the file next to
>>> DRIVER_NAME instead of hard coding in the middle on a function ?
>>
>> That's what v1 had, and Greg KH said to remove it. I'm guessing that he
>> thought it was the common-but-pointless practice of having the driver print a
>> version number that never gets updated, rather than something the UIO API
>> (unfortunately, compared to a feature query interface) expects. That said,
>> I'm not sure what the value is of making it a macro since it should only be
>> used once, that use is self documenting, it isn't tunable, etc. Though if
>> this isn't a macro, UIO_NAME also shouldn't be (and if it is made a macro
>> again, it should be UIO_VERSION, not DRIVER_VERSION).
>>
>> Does this really need a three-part version scheme? What's wrong with a
>> version of "1", to be changed to "2" in the hopefully-unlikely event that the
>> userspace API changes? Assuming UIO is used for this at all, which doesn't
>> seem like a great fit to me.
>>
>> -Scott
>>
>
> As Scott mentioned, the version define as necessity by uio core but actually
> useless for us here(and for many other type of devices I guess). So maybe the better
> way is to set it optionally, but this belong first to uio core.
>
> For the cache-sram uio driver, I will define an UIO_VERSION micro as a compromise
> fit all wonders, no confusing as Greg first mentioned.
Yes I like it.
>
>>> +static const struct of_device_id uio_mpc85xx_l2ctlr_of_match[] = {
>>> + { .compatible = "uio,fsl,p2020-l2-cache-controller", },
>>> + { .compatible = "uio,fsl,p2010-l2-cache-controller", },
>>> + { .compatible = "uio,fsl,p1020-l2-cache-controller", },
>>> + { .compatible = "uio,fsl,p1011-l2-cache-controller", },
>>> + { .compatible = "uio,fsl,p1013-l2-cache-controller", },
>>> + { .compatible = "uio,fsl,p1022-l2-cache-controller", },
>>> + { .compatible = "uio,fsl,mpc8548-l2-cache-controller", },
>>> + { .compatible = "uio,fsl,mpc8544-l2-cache-controller", },
>>> + { .compatible = "uio,fsl,mpc8572-l2-cache-controller", },
>>> + { .compatible = "uio,fsl,mpc8536-l2-cache-controller", },
>>> + { .compatible = "uio,fsl,p1021-l2-cache-controller", },
>>> + { .compatible = "uio,fsl,p1012-l2-cache-controller", },
>>> + { .compatible = "uio,fsl,p1025-l2-cache-controller", },
>>> + { .compatible = "uio,fsl,p1016-l2-cache-controller", },
>>> + { .compatible = "uio,fsl,p1024-l2-cache-controller", },
>>> + { .compatible = "uio,fsl,p1015-l2-cache-controller", },
>>> + { .compatible = "uio,fsl,p1010-l2-cache-controller", },
>>> + { .compatible = "uio,fsl,bsc9131-l2-cache-controller", },
>>> + {},
>>> +};
>>
>> NACK
>>
>> The device tree describes the hardware, not what driver you want to bind the
>> hardware to, or how you want to allocate the resources. And even if defining
>> nodes for sram allocation were the right way to go, why do you have a separate
>> compatible for each chip when you're just describing software configuration?
>>
>> Instead, have module parameters that take the sizes and alignments you'd like
>> to allocate and expose to userspace. Better still would be some sort of
>> dynamic allocation (e.g. open a fd, ioctl to set the requested size/alignment,
>> if it succeeds you can mmap it, and when the fd is closed the region is
>> freed).
>>
>> -Scott
>>
>
> Can not agree more. But what if I want to define more than one cache-sram uio devices?
> How about use the device tree for pseudo uio cache-sram driver?
>
> static const struct of_device_id uio_mpc85xx_l2ctlr_of_match[] = {
> { .compatible = "uio,cache-sram", },
> {},
> };
>
You can still give it a name in line with your driver, ie:
"uio,mpc85xx-cache-sram"
After, it you have different behaviours depending on the compatible,
then you have to add a .data field which will tell the driver which
behaviour to implement.
Christophe
^ permalink raw reply
* [PATCH v11 05/14] powerpc/vas: Register NX with fault window ID and IRQ port value
From: Haren Myneni @ 2020-04-16 6:01 UTC (permalink / raw)
To: mpe
Cc: mikey, srikar, frederic.barrat, ajd, linux-kernel, npiggin, hch,
oohall, clg, sukadev, linuxppc-dev, herbert
In-Reply-To: <1587016214.2275.1036.camel@hbabu-laptop>
For each user space send window, register NX with fault window ID
and port value so that NX paste CRBs in this fault FIFO when it
sees fault on the request buffer.
Signed-off-by: Sukadev Bhattiprolu <sukadev@linux.vnet.ibm.com>
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
---
arch/powerpc/platforms/powernv/vas-window.c | 15 +++++++++++++--
arch/powerpc/platforms/powernv/vas.h | 15 +++++++++++++++
2 files changed, 28 insertions(+), 2 deletions(-)
diff --git a/arch/powerpc/platforms/powernv/vas-window.c b/arch/powerpc/platforms/powernv/vas-window.c
index 1783fa9..dc46bf6 100644
--- a/arch/powerpc/platforms/powernv/vas-window.c
+++ b/arch/powerpc/platforms/powernv/vas-window.c
@@ -373,7 +373,7 @@ int init_winctx_regs(struct vas_window *window, struct vas_winctx *winctx)
init_xlate_regs(window, winctx->user_win);
val = 0ULL;
- val = SET_FIELD(VAS_FAULT_TX_WIN, val, 0);
+ val = SET_FIELD(VAS_FAULT_TX_WIN, val, winctx->fault_win_id);
write_hvwc_reg(window, VREG(FAULT_TX_WIN), val);
/* In PowerNV, interrupts go to HV. */
@@ -748,6 +748,8 @@ static void init_winctx_for_rxwin(struct vas_window *rxwin,
winctx->min_scope = VAS_SCOPE_LOCAL;
winctx->max_scope = VAS_SCOPE_VECTORED_GROUP;
+ if (rxwin->vinst->virq)
+ winctx->irq_port = rxwin->vinst->irq_port;
}
static bool rx_win_args_valid(enum vas_cop_type cop,
@@ -944,13 +946,22 @@ static void init_winctx_for_txwin(struct vas_window *txwin,
winctx->lpid = txattr->lpid;
winctx->pidr = txattr->pidr;
winctx->rx_win_id = txwin->rxwin->winid;
+ /*
+ * IRQ and fault window setup is successful. Set fault window
+ * for the send window so that ready to handle faults.
+ */
+ if (txwin->vinst->virq)
+ winctx->fault_win_id = txwin->vinst->fault_win->winid;
winctx->dma_type = VAS_DMA_TYPE_INJECT;
winctx->tc_mode = txattr->tc_mode;
winctx->min_scope = VAS_SCOPE_LOCAL;
winctx->max_scope = VAS_SCOPE_VECTORED_GROUP;
+ if (txwin->vinst->virq)
+ winctx->irq_port = txwin->vinst->irq_port;
- winctx->pswid = 0;
+ winctx->pswid = txattr->pswid ? txattr->pswid :
+ encode_pswid(txwin->vinst->vas_id, txwin->winid);
}
static bool tx_win_args_valid(enum vas_cop_type cop,
diff --git a/arch/powerpc/platforms/powernv/vas.h b/arch/powerpc/platforms/powernv/vas.h
index 9c8e3f5..88d084d 100644
--- a/arch/powerpc/platforms/powernv/vas.h
+++ b/arch/powerpc/platforms/powernv/vas.h
@@ -467,6 +467,21 @@ static inline u64 read_hvwc_reg(struct vas_window *win,
return in_be64(win->hvwc_map+reg);
}
+/*
+ * Encode/decode the Partition Send Window ID (PSWID) for a window in
+ * a way that we can uniquely identify any window in the system. i.e.
+ * we should be able to locate the 'struct vas_window' given the PSWID.
+ *
+ * Bits Usage
+ * 0:7 VAS id (8 bits)
+ * 8:15 Unused, 0 (3 bits)
+ * 16:31 Window id (16 bits)
+ */
+static inline u32 encode_pswid(int vasid, int winid)
+{
+ return ((u32)winid | (vasid << (31 - 7)));
+}
+
static inline void decode_pswid(u32 pswid, int *vasid, int *winid)
{
if (vasid)
--
1.8.3.1
^ permalink raw reply related
* [PATCH v11 04/14] powerpc/vas: Setup fault window per VAS instance
From: Haren Myneni @ 2020-04-16 6:00 UTC (permalink / raw)
To: mpe
Cc: mikey, srikar, frederic.barrat, ajd, linux-kernel, npiggin, hch,
oohall, clg, sukadev, linuxppc-dev, herbert
In-Reply-To: <1587016214.2275.1036.camel@hbabu-laptop>
Setup fault window for each VAS instance. When NX gets a fault on
request buffer, pastes fault CRB in the corresponding fault FIFO and
then raises an interrupt to the OS. The kernel handles this fault
and process faults CRB from this FIFO.
Signed-off-by: Sukadev Bhattiprolu <sukadev@linux.vnet.ibm.com>
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
---
arch/powerpc/platforms/powernv/Makefile | 2 +-
arch/powerpc/platforms/powernv/vas-fault.c | 77 +++++++++++++++++++++++++++++
arch/powerpc/platforms/powernv/vas-window.c | 4 +-
arch/powerpc/platforms/powernv/vas.c | 20 ++++++++
arch/powerpc/platforms/powernv/vas.h | 21 ++++++++
5 files changed, 121 insertions(+), 3 deletions(-)
create mode 100644 arch/powerpc/platforms/powernv/vas-fault.c
diff --git a/arch/powerpc/platforms/powernv/Makefile b/arch/powerpc/platforms/powernv/Makefile
index c0f8120..395789f 100644
--- a/arch/powerpc/platforms/powernv/Makefile
+++ b/arch/powerpc/platforms/powernv/Makefile
@@ -17,7 +17,7 @@ obj-$(CONFIG_MEMORY_FAILURE) += opal-memory-errors.o
obj-$(CONFIG_OPAL_PRD) += opal-prd.o
obj-$(CONFIG_PERF_EVENTS) += opal-imc.o
obj-$(CONFIG_PPC_MEMTRACE) += memtrace.o
-obj-$(CONFIG_PPC_VAS) += vas.o vas-window.o vas-debug.o
+obj-$(CONFIG_PPC_VAS) += vas.o vas-window.o vas-debug.o vas-fault.o
obj-$(CONFIG_OCXL_BASE) += ocxl.o
obj-$(CONFIG_SCOM_DEBUGFS) += opal-xscom.o
obj-$(CONFIG_PPC_SECURE_BOOT) += opal-secvar.o
diff --git a/arch/powerpc/platforms/powernv/vas-fault.c b/arch/powerpc/platforms/powernv/vas-fault.c
new file mode 100644
index 0000000..4044998
--- /dev/null
+++ b/arch/powerpc/platforms/powernv/vas-fault.c
@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * VAS Fault handling.
+ * Copyright 2019, IBM Corporation
+ */
+
+#define pr_fmt(fmt) "vas: " fmt
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/kthread.h>
+#include <asm/icswx.h>
+
+#include "vas.h"
+
+/*
+ * The maximum FIFO size for fault window can be 8MB
+ * (VAS_RX_FIFO_SIZE_MAX). Using 4MB FIFO since each VAS
+ * instance will be having fault window.
+ * 8MB FIFO can be used if expects more faults for each VAS
+ * instance.
+ */
+#define VAS_FAULT_WIN_FIFO_SIZE (4 << 20)
+
+/*
+ * Fault window is opened per VAS instance. NX pastes fault CRB in fault
+ * FIFO upon page faults.
+ */
+int vas_setup_fault_window(struct vas_instance *vinst)
+{
+ struct vas_rx_win_attr attr;
+
+ vinst->fault_fifo_size = VAS_FAULT_WIN_FIFO_SIZE;
+ vinst->fault_fifo = kzalloc(vinst->fault_fifo_size, GFP_KERNEL);
+ if (!vinst->fault_fifo) {
+ pr_err("Unable to alloc %d bytes for fault_fifo\n",
+ vinst->fault_fifo_size);
+ return -ENOMEM;
+ }
+
+ /*
+ * Invalidate all CRB entries. NX pastes valid entry for each fault.
+ */
+ memset(vinst->fault_fifo, FIFO_INVALID_ENTRY, vinst->fault_fifo_size);
+ vas_init_rx_win_attr(&attr, VAS_COP_TYPE_FAULT);
+
+ attr.rx_fifo_size = vinst->fault_fifo_size;
+ attr.rx_fifo = vinst->fault_fifo;
+
+ /*
+ * Max creds is based on number of CRBs can fit in the FIFO.
+ * (fault_fifo_size/CRB_SIZE). If 8MB FIFO is used, max creds
+ * will be 0xffff since the receive creds field is 16bits wide.
+ */
+ attr.wcreds_max = vinst->fault_fifo_size / CRB_SIZE;
+ attr.lnotify_lpid = 0;
+ attr.lnotify_pid = mfspr(SPRN_PID);
+ attr.lnotify_tid = mfspr(SPRN_PID);
+
+ vinst->fault_win = vas_rx_win_open(vinst->vas_id, VAS_COP_TYPE_FAULT,
+ &attr);
+
+ if (IS_ERR(vinst->fault_win)) {
+ pr_err("VAS: Error %ld opening FaultWin\n",
+ PTR_ERR(vinst->fault_win));
+ kfree(vinst->fault_fifo);
+ return PTR_ERR(vinst->fault_win);
+ }
+
+ pr_devel("VAS: Created FaultWin %d, LPID/PID/TID [%d/%d/%d]\n",
+ vinst->fault_win->winid, attr.lnotify_lpid,
+ attr.lnotify_pid, attr.lnotify_tid);
+
+ return 0;
+}
diff --git a/arch/powerpc/platforms/powernv/vas-window.c b/arch/powerpc/platforms/powernv/vas-window.c
index 0c0d27d..1783fa9 100644
--- a/arch/powerpc/platforms/powernv/vas-window.c
+++ b/arch/powerpc/platforms/powernv/vas-window.c
@@ -827,9 +827,9 @@ void vas_init_rx_win_attr(struct vas_rx_win_attr *rxattr, enum vas_cop_type cop)
rxattr->fault_win = true;
rxattr->notify_disable = true;
rxattr->rx_wcred_mode = true;
- rxattr->tx_wcred_mode = true;
rxattr->rx_win_ord_mode = true;
- rxattr->tx_win_ord_mode = true;
+ rxattr->rej_no_credit = true;
+ rxattr->tc_mode = VAS_THRESH_DISABLED;
} else if (cop == VAS_COP_TYPE_FTW) {
rxattr->user_win = true;
rxattr->intr_disable = true;
diff --git a/arch/powerpc/platforms/powernv/vas.c b/arch/powerpc/platforms/powernv/vas.c
index 3303cfe..9013a63 100644
--- a/arch/powerpc/platforms/powernv/vas.c
+++ b/arch/powerpc/platforms/powernv/vas.c
@@ -24,6 +24,11 @@
static DEFINE_PER_CPU(int, cpu_vas_id);
+static int vas_irq_fault_window_setup(struct vas_instance *vinst)
+{
+ return vas_setup_fault_window(vinst);
+}
+
static int init_vas_instance(struct platform_device *pdev)
{
struct device_node *dn = pdev->dev.of_node;
@@ -114,6 +119,21 @@ static int init_vas_instance(struct platform_device *pdev)
list_add(&vinst->node, &vas_instances);
mutex_unlock(&vas_mutex);
+ /*
+ * IRQ and fault handling setup is needed only for user space
+ * send windows.
+ */
+ if (vinst->virq) {
+ rc = vas_irq_fault_window_setup(vinst);
+ /*
+ * Fault window is used only for user space send windows.
+ * So if vinst->virq is NULL, tx_win_open returns -ENODEV
+ * for user space.
+ */
+ if (rc)
+ vinst->virq = 0;
+ }
+
vas_instance_init_dbgdir(vinst);
dev_set_drvdata(&pdev->dev, vinst);
diff --git a/arch/powerpc/platforms/powernv/vas.h b/arch/powerpc/platforms/powernv/vas.h
index 598608b..9c8e3f5 100644
--- a/arch/powerpc/platforms/powernv/vas.h
+++ b/arch/powerpc/platforms/powernv/vas.h
@@ -296,6 +296,22 @@ enum vas_notify_after_count {
};
/*
+ * NX can generate an interrupt for multiple faults and expects kernel
+ * to process all of them. So read all valid CRB entries until find the
+ * invalid one. So use pswid which is pasted by NX and ccw[0] (reserved
+ * bit in BE) to check valid CRB. CCW[0] will not be touched by user
+ * space. Application gets CRB formt error if it updates this bit.
+ *
+ * Invalidate FIFO during allocation and process all entries from last
+ * successful read until finds invalid pswid and ccw[0] values.
+ * After reading each CRB entry from fault FIFO, the kernel invalidate
+ * it by updating pswid with FIFO_INVALID_ENTRY and CCW[0] with
+ * CCW0_INVALID.
+ */
+#define FIFO_INVALID_ENTRY 0xffffffff
+#define CCW0_INVALID 1
+
+/*
* One per instance of VAS. Each instance will have a separate set of
* receive windows, one per coprocessor type.
*
@@ -315,6 +331,10 @@ struct vas_instance {
u64 irq_port;
int virq;
+ int fault_fifo_size;
+ void *fault_fifo;
+ struct vas_window *fault_win; /* Fault window */
+
struct mutex mutex;
struct vas_window *rxwin[VAS_COP_TYPE_MAX];
struct vas_window *windows[VAS_WINDOWS_PER_CHIP];
@@ -408,6 +428,7 @@ struct vas_winctx {
extern void vas_instance_init_dbgdir(struct vas_instance *vinst);
extern void vas_window_init_dbgdir(struct vas_window *win);
extern void vas_window_free_dbgdir(struct vas_window *win);
+extern int vas_setup_fault_window(struct vas_instance *vinst);
static inline void vas_log_write(struct vas_window *win, char *name,
void *regptr, u64 val)
--
1.8.3.1
^ permalink raw reply related
* [PATCH v11 03/14] powerpc/vas: Alloc and setup IRQ and trigger port address
From: Haren Myneni @ 2020-04-16 6:00 UTC (permalink / raw)
To: mpe
Cc: mikey, srikar, frederic.barrat, ajd, linux-kernel, npiggin, hch,
oohall, clg, sukadev, linuxppc-dev, herbert
In-Reply-To: <1587016214.2275.1036.camel@hbabu-laptop>
Allocate a xive irq on each chip with a vas instance. The NX coprocessor
raises a host CPU interrupt via vas if it encounters page fault on user
space request buffer. Subsequent patches register the trigger port with
the NX coprocessor, and create a vas fault handler for this interrupt
mapping.
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
---
arch/powerpc/platforms/powernv/vas.c | 44 +++++++++++++++++++++++++++++++-----
arch/powerpc/platforms/powernv/vas.h | 2 ++
2 files changed, 40 insertions(+), 6 deletions(-)
diff --git a/arch/powerpc/platforms/powernv/vas.c b/arch/powerpc/platforms/powernv/vas.c
index ed9cc6d..3303cfe 100644
--- a/arch/powerpc/platforms/powernv/vas.c
+++ b/arch/powerpc/platforms/powernv/vas.c
@@ -15,6 +15,7 @@
#include <linux/of_address.h>
#include <linux/of.h>
#include <asm/prom.h>
+#include <asm/xive.h>
#include "vas.h"
@@ -25,10 +26,12 @@
static int init_vas_instance(struct platform_device *pdev)
{
- int rc, cpu, vasid;
- struct resource *res;
- struct vas_instance *vinst;
struct device_node *dn = pdev->dev.of_node;
+ struct vas_instance *vinst;
+ struct xive_irq_data *xd;
+ uint32_t chipid, hwirq;
+ struct resource *res;
+ int rc, cpu, vasid;
rc = of_property_read_u32(dn, "ibm,vas-id", &vasid);
if (rc) {
@@ -36,6 +39,12 @@ static int init_vas_instance(struct platform_device *pdev)
return -ENODEV;
}
+ rc = of_property_read_u32(dn, "ibm,chip-id", &chipid);
+ if (rc) {
+ pr_err("No ibm,chip-id property for %s?\n", pdev->name);
+ return -ENODEV;
+ }
+
if (pdev->num_resources != 4) {
pr_err("Unexpected DT configuration for [%s, %d]\n",
pdev->name, vasid);
@@ -69,9 +78,32 @@ static int init_vas_instance(struct platform_device *pdev)
vinst->paste_win_id_shift = 63 - res->end;
- pr_devel("Initialized instance [%s, %d], paste_base 0x%llx, "
- "paste_win_id_shift 0x%llx\n", pdev->name, vasid,
- vinst->paste_base_addr, vinst->paste_win_id_shift);
+ hwirq = xive_native_alloc_irq_on_chip(chipid);
+ if (!hwirq) {
+ pr_err("Inst%d: Unable to allocate global irq for chip %d\n",
+ vinst->vas_id, chipid);
+ return -ENOENT;
+ }
+
+ vinst->virq = irq_create_mapping(NULL, hwirq);
+ if (!vinst->virq) {
+ pr_err("Inst%d: Unable to map global irq %d\n",
+ vinst->vas_id, hwirq);
+ return -EINVAL;
+ }
+
+ xd = irq_get_handler_data(vinst->virq);
+ if (!xd) {
+ pr_err("Inst%d: Invalid virq %d\n",
+ vinst->vas_id, vinst->virq);
+ return -EINVAL;
+ }
+
+ vinst->irq_port = xd->trig_page;
+ pr_devel("Initialized instance [%s, %d] paste_base 0x%llx paste_win_id_shift 0x%llx IRQ %d Port 0x%llx\n",
+ pdev->name, vasid, vinst->paste_base_addr,
+ vinst->paste_win_id_shift, vinst->virq,
+ vinst->irq_port);
for_each_possible_cpu(cpu) {
if (cpu_to_chip_id(cpu) == of_get_ibm_chip_id(dn))
diff --git a/arch/powerpc/platforms/powernv/vas.h b/arch/powerpc/platforms/powernv/vas.h
index 5574aec..598608b 100644
--- a/arch/powerpc/platforms/powernv/vas.h
+++ b/arch/powerpc/platforms/powernv/vas.h
@@ -313,6 +313,8 @@ struct vas_instance {
u64 paste_base_addr;
u64 paste_win_id_shift;
+ u64 irq_port;
+ int virq;
struct mutex mutex;
struct vas_window *rxwin[VAS_COP_TYPE_MAX];
struct vas_window *windows[VAS_WINDOWS_PER_CHIP];
--
1.8.3.1
^ permalink raw reply related
* [PATCH v11 02/14] powerpc/vas: Define nx_fault_stamp in coprocessor_request_block
From: Haren Myneni @ 2020-04-16 5:59 UTC (permalink / raw)
To: mpe
Cc: mikey, srikar, frederic.barrat, ajd, linux-kernel, npiggin, hch,
oohall, clg, sukadev, linuxppc-dev, herbert
In-Reply-To: <1587016214.2275.1036.camel@hbabu-laptop>
Kernel sets fault address and status in CRB for NX page fault on user
space address after processing page fault. User space gets the signal
and handles the fault mentioned in CRB by bringing the page in to
memory and send NX request again.
Signed-off-by: Sukadev Bhattiprolu <sukadev@linux.vnet.ibm.com>
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
---
arch/powerpc/include/asm/icswx.h | 20 ++++++++++++++++++--
1 file changed, 18 insertions(+), 2 deletions(-)
diff --git a/arch/powerpc/include/asm/icswx.h b/arch/powerpc/include/asm/icswx.h
index 9872f85..965b1f3 100644
--- a/arch/powerpc/include/asm/icswx.h
+++ b/arch/powerpc/include/asm/icswx.h
@@ -108,6 +108,17 @@ struct data_descriptor_entry {
__be64 address;
} __packed __aligned(DDE_ALIGN);
+/* 4.3.2 NX-stamped Fault CRB */
+
+#define NX_STAMP_ALIGN (0x10)
+
+struct nx_fault_stamp {
+ __be64 fault_storage_addr;
+ __be16 reserved;
+ __u8 flags;
+ __u8 fault_status;
+ __be32 pswid;
+} __packed __aligned(NX_STAMP_ALIGN);
/* Chapter 6.5.2 Coprocessor-Request Block (CRB) */
@@ -135,10 +146,15 @@ struct coprocessor_request_block {
struct coprocessor_completion_block ccb;
- u8 reserved[48];
+ union {
+ struct nx_fault_stamp nx;
+ u8 reserved[16];
+ } stamp;
+
+ u8 reserved[32];
struct coprocessor_status_block csb;
-} __packed __aligned(CRB_ALIGN);
+} __packed;
/* RFC02167 Initiate Coprocessor Instructions document
--
1.8.3.1
^ permalink raw reply related
* [PATCH v11 01/14] powerpc/xive: Define xive_native_alloc_irq_on_chip()
From: Haren Myneni @ 2020-04-16 5:58 UTC (permalink / raw)
To: mpe
Cc: mikey, srikar, frederic.barrat, ajd, linux-kernel, npiggin, hch,
oohall, clg, sukadev, linuxppc-dev, herbert
In-Reply-To: <1587016214.2275.1036.camel@hbabu-laptop>
This function allocates IRQ on a specific chip. VAS needs per chip
IRQ allocation and will have IRQ handler per VAS instance.
Signed-off-by: Haren Myneni <haren@linux.ibm.com>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
---
arch/powerpc/include/asm/xive.h | 9 ++++++++-
arch/powerpc/sysdev/xive/native.c | 6 +++---
2 files changed, 11 insertions(+), 4 deletions(-)
diff --git a/arch/powerpc/include/asm/xive.h b/arch/powerpc/include/asm/xive.h
index 93f982db..d08ea11 100644
--- a/arch/powerpc/include/asm/xive.h
+++ b/arch/powerpc/include/asm/xive.h
@@ -5,6 +5,8 @@
#ifndef _ASM_POWERPC_XIVE_H
#define _ASM_POWERPC_XIVE_H
+#include <asm/opal-api.h>
+
#define XIVE_INVALID_VP 0xffffffff
#ifdef CONFIG_PPC_XIVE
@@ -108,7 +110,6 @@ struct xive_q {
int xive_native_populate_irq_data(u32 hw_irq,
struct xive_irq_data *data);
void xive_cleanup_irq_data(struct xive_irq_data *xd);
-u32 xive_native_alloc_irq(void);
void xive_native_free_irq(u32 irq);
int xive_native_configure_irq(u32 hw_irq, u32 target, u8 prio, u32 sw_irq);
@@ -137,6 +138,12 @@ int xive_native_set_queue_state(u32 vp_id, uint32_t prio, u32 qtoggle,
u32 qindex);
int xive_native_get_vp_state(u32 vp_id, u64 *out_state);
bool xive_native_has_queue_state_support(void);
+extern u32 xive_native_alloc_irq_on_chip(u32 chip_id);
+
+static inline u32 xive_native_alloc_irq(void)
+{
+ return xive_native_alloc_irq_on_chip(OPAL_XIVE_ANY_CHIP);
+}
#else
diff --git a/arch/powerpc/sysdev/xive/native.c b/arch/powerpc/sysdev/xive/native.c
index 0ff6b73..14d4406 100644
--- a/arch/powerpc/sysdev/xive/native.c
+++ b/arch/powerpc/sysdev/xive/native.c
@@ -279,12 +279,12 @@ static int xive_native_get_ipi(unsigned int cpu, struct xive_cpu *xc)
}
#endif /* CONFIG_SMP */
-u32 xive_native_alloc_irq(void)
+u32 xive_native_alloc_irq_on_chip(u32 chip_id)
{
s64 rc;
for (;;) {
- rc = opal_xive_allocate_irq(OPAL_XIVE_ANY_CHIP);
+ rc = opal_xive_allocate_irq(chip_id);
if (rc != OPAL_BUSY)
break;
msleep(OPAL_BUSY_DELAY_MS);
@@ -293,7 +293,7 @@ u32 xive_native_alloc_irq(void)
return 0;
return rc;
}
-EXPORT_SYMBOL_GPL(xive_native_alloc_irq);
+EXPORT_SYMBOL_GPL(xive_native_alloc_irq_on_chip);
void xive_native_free_irq(u32 irq)
{
--
1.8.3.1
^ permalink raw reply related
* [PATCH v11 00/14] powerpc/vas: Page fault handling for user space NX requests
From: Haren Myneni @ 2020-04-16 5:50 UTC (permalink / raw)
To: mpe
Cc: mikey, srikar, frederic.barrat, linux-kernel, npiggin, hch,
oohall, clg, herbert, sukadev, linuxppc-dev, ajd
On power9, Virtual Accelerator Switchboard (VAS) allows user space or
kernel to communicate with Nest Accelerator (NX) directly using COPY/PASTE
instructions. NX provides various functionalities such as compression,
encryption and etc. But only compression (842 and GZIP formats) is
supported in Linux kernel on power9.
842 compression driver (drivers/crypto/nx/nx-842-powernv.c)
is already included in Linux. Only GZIP support will be available from
user space.
Applications can issue GZIP compression / decompression requests to NX with
COPY/PASTE instructions. When NX is processing these requests, can hit
fault on the request buffer (not in memory). It issues an interrupt and
pastes fault CRB in fault FIFO. Expects kernel to handle this fault and
return credits for both send and fault windows after processing.
This patch series adds IRQ and fault window setup, and NX fault handling:
- Alloc IRQ and trigger port address, and configure IRQ per VAS instance.
- Set port# for each window to generate an interrupt when noticed fault.
- Set fault window and FIFO on which NX paste fault CRB.
- Setup IRQ thread fault handler per VAS instance.
- When receiving an interrupt, Read CRBs from fault FIFO and update
coprocessor_status_block (CSB) in the corresponding CRB with translation
failure (CSB_CC_TRANSLATION). After issuing NX requests, process polls
on CSB address. When it sees translation error, can touch the request
buffer to bring the page in to memory and reissue NX request.
- If copy_to_user fails on user space CSB address, OS sends SEGV signal.
Tested these patches with NX-GZIP enable patches and posted them as separate
patch series.
Patch 1: Define alloc IRQ per chip which is needed to alloc IRQ per VAS
instance.
Patch 2: Define nx_fault_stamp on which NX writes fault status for the fault
CRB
Patch 3: Alloc and setup IRQ and trigger port address for each VAS instance
Patches 4 & 5: Setup fault window and register NX per each VAS instance. This
window is used for NX to paste fault CRB in FIFO.
Patch 6: Reference to pid and mm so that pid is not used until window closed.
Needed for multi thread application where child can open a window
and can be used by parent it later.
Patch 7: Setup threaded IRQ handler per VAS
Patch 8: Process CRBs from fault FIFO and notify tasks by updating CSB or
through signals.
Patches 9 & 11: Return credits for send and fault windows after handling
faults.
Patches 10 & 12: Dump FIFO / CRB data and messages for error conditions
Patch 13: Fix closing send window after all credits are returned. This issue
happens only for user space requests. No page faults on kernel
request buffer.
Patch 14: For each process / thread, use mm_context->vas_windows counter to
clear foreign address mapping and disable it.
Changelog:
V2:
- Use threaded IRQ instead of own kernel thread handler
- Use pswid instead of user space CSB address to find valid CRB
- Removed unused macros and other changes as suggested by Christoph Hellwig
V3:
- Rebased to 5.5-rc2
- Use struct pid * instead of pid_t for vas_window tgid
- Code cleanup as suggested by Christoph Hellwig
V4:
- Define xive alloc and get IRQ info based on chip ID and use these
functions for IRQ setup per VAS instance. It eliminates skiboot
dependency as suggested by Oliver.
V5:
- Do not update CSB if the process is exiting (patch8)
V6:
- Add interrupt handler instead of default one and return IRQ_HANDLED
if the fault handling thread is already in progress. (Patch7)
- Use platform send window ID and CCW[0] bit to find valid CRB in
fault FIFO (Patch7).
- Return fault address to user space in BE and other changes as
suggested by Michael Neuling. (patch8)
- Rebased to 5.6-rc4
V7:
- Fixed sparse warnings (patches 4, 9 and 10)
V8:
- Moved mm_context_remove_copro() before mmdrop() (patch6)
- Moved barrier before csb.flags store and add WARN_ON_ONCE() checks (patch8)
V9:
- Rebased to 5.6
- Changes based on Cedric's comments
- Removed "Define xive_native_alloc_get_irq_info()" patch and used
irq_get_handler_data() (patch3)
- Changes based on comments from Nicholas Piggin
- Moved "Taking PID reference" patch before setting VAS fault handler
patch
- Removed mutex_lock/unlock (patch7)
- Other cleanup changes
V10:
- Include patch to enable and disable CP_ABORT execution using
mm_context->vas_windows counter.
- Remove 'if (txwin)' line which is covered with 'else' before (patch6)
V11:
- Added comments for fault_lock and fifo_in_progress elements (patch7)
- Use pr_warn_ratelimited instead of pr_debug to display message during
window close (patch12)
- Moved set_thread_uses_vas() to vas_win_open() (patch14)
Haren Myneni (14):
powerpc/xive: Define xive_native_alloc_irq_on_chip()
powerpc/vas: Define nx_fault_stamp in coprocessor_request_block
powerpc/vas: Alloc and setup IRQ and trigger port address
powerpc/vas: Setup fault window per VAS instance
powerpc/vas: Register NX with fault window ID and IRQ port value
powerpc/vas: Take reference to PID and mm for user space windows
powerpc/vas: Setup thread IRQ handler per VAS instance
powerpc/vas: Update CSB and notify process for fault CRBs
powerpc/vas: Return credits after handling fault
powerpc/vas: Print CRB and FIFO values
powerpc/vas: Do not use default credits for receive window
powerpc/vas: Display process stuck message
powerpc/vas: Free send window in VAS instance after credits returned
powerpc: Use mm_context vas_windows counter to issue CP_ABORT
arch/powerpc/include/asm/book3s/64/mmu.h | 3 +
arch/powerpc/include/asm/icswx.h | 20 +-
arch/powerpc/include/asm/mmu_context.h | 30 +++
arch/powerpc/include/asm/processor.h | 1 -
arch/powerpc/include/asm/switch_to.h | 2 -
arch/powerpc/include/asm/xive.h | 9 +-
arch/powerpc/kernel/process.c | 24 +-
arch/powerpc/platforms/powernv/Makefile | 2 +-
arch/powerpc/platforms/powernv/vas-debug.c | 2 +-
arch/powerpc/platforms/powernv/vas-fault.c | 382 ++++++++++++++++++++++++++++
arch/powerpc/platforms/powernv/vas-window.c | 215 ++++++++++++++--
arch/powerpc/platforms/powernv/vas.c | 85 ++++++-
arch/powerpc/platforms/powernv/vas.h | 57 ++++-
arch/powerpc/sysdev/xive/native.c | 6 +-
14 files changed, 779 insertions(+), 59 deletions(-)
create mode 100644 arch/powerpc/platforms/powernv/vas-fault.c
--
1.8.3.1
^ permalink raw reply
* Re: [PATCH] powerpc/uaccess: Use flexible addressing with __put_user()/__get_user()
From: Christophe Leroy @ 2020-04-16 5:50 UTC (permalink / raw)
To: Segher Boessenkool; +Cc: linux-kernel, npiggin, Paul Mackerras, linuxppc-dev
In-Reply-To: <20200415220652.GW26902@gate.crashing.org>
Hi,
Le 16/04/2020 à 00:06, Segher Boessenkool a écrit :
> Hi!
>
> On Wed, Apr 15, 2020 at 09:20:26AM +0000, Christophe Leroy wrote:
>> At the time being, __put_user()/__get_user() and friends only use
>> register indirect with immediate index addressing, with the index
>> set to 0. Ex:
>>
>> lwz reg1, 0(reg2)
>
> This is called a "D-form" instruction, or sometimes "offset addressing".
> Don't talk about an "index", it confuses things, because the *other*
> kind is called "indexed" already, also in the ISA docs! (X-form, aka
> indexed addressing, [reg+reg], where D-form does [reg+imm], and both
> forms can do [reg]).
In the "Programming Environments Manual for 32-Bit Implementations of
the PowerPC™ Architecture", they list the following addressing modes:
Load and store operations have three categories of effective address
generation that depend on the
operands specified:
• Register indirect with immediate index mode
• Register indirect with index mode
• Register indirect mode
>
>> Give the compiler the opportunity to use other adressing modes
>> whenever possible, to get more optimised code.
>
> Great :-)
>
>> --- a/arch/powerpc/include/asm/uaccess.h
>> +++ b/arch/powerpc/include/asm/uaccess.h
>> @@ -114,7 +114,7 @@ extern long __put_user_bad(void);
>> */
>> #define __put_user_asm(x, addr, err, op) \
>> __asm__ __volatile__( \
>> - "1: " op " %1,0(%2) # put_user\n" \
>> + "1: " op "%U2%X2 %1,%2 # put_user\n" \
>> "2:\n" \
>> ".section .fixup,\"ax\"\n" \
>> "3: li %0,%3\n" \
>> @@ -122,7 +122,7 @@ extern long __put_user_bad(void);
>> ".previous\n" \
>> EX_TABLE(1b, 3b) \
>> : "=r" (err) \
>> - : "r" (x), "b" (addr), "i" (-EFAULT), "0" (err))
>> + : "r" (x), "m" (*addr), "i" (-EFAULT), "0" (err))
>
> %Un on an "m" operand doesn't do much: you need to make it "m<>" if you
> want pre-modify ("update") insns to be generated. (You then will want
> to make sure that operand is used in a way GCC can understand; since it
> is used only once here, that works fine).
Ah ? Indeed I got the idea from include/asm/io.h where there is:
#define DEF_MMIO_IN_D(name, size, insn) \
static inline u##size name(const volatile u##size __iomem *addr) \
{ \
u##size ret; \
__asm__ __volatile__("sync;"#insn"%U1%X1 %0,%1;twi 0,%0,0;isync"\
: "=r" (ret) : "m" (*addr) : "memory"); \
return ret; \
}
It should be "m<>" there as well ?
>
>> @@ -130,8 +130,8 @@ extern long __put_user_bad(void);
>> #else /* __powerpc64__ */
>> #define __put_user_asm2(x, addr, err) \
>> __asm__ __volatile__( \
>> - "1: stw %1,0(%2)\n" \
>> - "2: stw %1+1,4(%2)\n" \
>> + "1: stw%U2%X2 %1,%2\n" \
>> + "2: stw%U2%X2 %L1,%L2\n" \
>> "3:\n" \
>> ".section .fixup,\"ax\"\n" \
>> "4: li %0,%3\n" \
>> @@ -140,7 +140,7 @@ extern long __put_user_bad(void);
>> EX_TABLE(1b, 4b) \
>> EX_TABLE(2b, 4b) \
>> : "=r" (err) \
>> - : "r" (x), "b" (addr), "i" (-EFAULT), "0" (err))
>> + : "r" (x), "m" (*addr), "i" (-EFAULT), "0" (err))
>
> Here, it doesn't work. You don't want two consecutive update insns in
> any case. Easiest is to just not use "m<>", and then, don't use %Un
> (which won't do anything, but it is confusing).
Can't we leave the Un on the second stw ?
>
> Same for the reads.
>
> Rest looks fine, and update should be good with that fixed as said.
>
> Reviewed-by: Segher Boessenkool <segher@kernel.crashing.org>
>
>
> Segher
>
Thanks for the review
Christophe
^ permalink raw reply
* Re: [PATCH v2,5/5] drivers: uio: new driver for fsl_85xx_cache_sram
From: Wang Wenhu @ 2020-04-16 5:22 UTC (permalink / raw)
To: christophe.leroy
Cc: linux-kernel, oss, kernel, gregkh, wenhu.wang, linuxppc-dev
In-Reply-To: <37b6b890-e537-7424-6b26-04565681f40a@c-s.fr>
Yes, kzalloc() would clean the allocated areas and the init of remaining array
elements are redundant. I will remove the block in v3.
>> > + dev_err(&pdev->dev, "error no valid uio-map configured\n");
>> > + ret = -EINVAL;
>> > + goto err_info_free_internel;
>> > + }
>> > +
>> > + info->version = "0.1.0";
>>
>> Could you define some DRIVER_VERSION in the top of the file next to
>> DRIVER_NAME instead of hard coding in the middle on a function ?
>
>That's what v1 had, and Greg KH said to remove it. I'm guessing that he
>thought it was the common-but-pointless practice of having the driver print a
>version number that never gets updated, rather than something the UIO API
>(unfortunately, compared to a feature query interface) expects. That said,
>I'm not sure what the value is of making it a macro since it should only be
>used once, that use is self documenting, it isn't tunable, etc. Though if
>this isn't a macro, UIO_NAME also shouldn't be (and if it is made a macro
>again, it should be UIO_VERSION, not DRIVER_VERSION).
>
>Does this really need a three-part version scheme? What's wrong with a
>version of "1", to be changed to "2" in the hopefully-unlikely event that the
>userspace API changes? Assuming UIO is used for this at all, which doesn't
>seem like a great fit to me.
>
>-Scott
>
As Scott mentioned, the version define as necessity by uio core but actually
useless for us here(and for many other type of devices I guess). So maybe the better
way is to set it optionally, but this belong first to uio core.
For the cache-sram uio driver, I will define an UIO_VERSION micro as a compromise
fit all wonders, no confusing as Greg first mentioned.
>> +static const struct of_device_id uio_mpc85xx_l2ctlr_of_match[] = {
>> + { .compatible = "uio,fsl,p2020-l2-cache-controller", },
>> + { .compatible = "uio,fsl,p2010-l2-cache-controller", },
>> + { .compatible = "uio,fsl,p1020-l2-cache-controller", },
>> + { .compatible = "uio,fsl,p1011-l2-cache-controller", },
>> + { .compatible = "uio,fsl,p1013-l2-cache-controller", },
>> + { .compatible = "uio,fsl,p1022-l2-cache-controller", },
>> + { .compatible = "uio,fsl,mpc8548-l2-cache-controller", },
>> + { .compatible = "uio,fsl,mpc8544-l2-cache-controller", },
>> + { .compatible = "uio,fsl,mpc8572-l2-cache-controller", },
>> + { .compatible = "uio,fsl,mpc8536-l2-cache-controller", },
>> + { .compatible = "uio,fsl,p1021-l2-cache-controller", },
>> + { .compatible = "uio,fsl,p1012-l2-cache-controller", },
>> + { .compatible = "uio,fsl,p1025-l2-cache-controller", },
>> + { .compatible = "uio,fsl,p1016-l2-cache-controller", },
>> + { .compatible = "uio,fsl,p1024-l2-cache-controller", },
>> + { .compatible = "uio,fsl,p1015-l2-cache-controller", },
>> + { .compatible = "uio,fsl,p1010-l2-cache-controller", },
>> + { .compatible = "uio,fsl,bsc9131-l2-cache-controller", },
>> + {},
>> +};
>
>NACK
>
>The device tree describes the hardware, not what driver you want to bind the
>hardware to, or how you want to allocate the resources. And even if defining
>nodes for sram allocation were the right way to go, why do you have a separate
>compatible for each chip when you're just describing software configuration?
>
>Instead, have module parameters that take the sizes and alignments you'd like
>to allocate and expose to userspace. Better still would be some sort of
>dynamic allocation (e.g. open a fd, ioctl to set the requested size/alignment,
>if it succeeds you can mmap it, and when the fd is closed the region is
>freed).
>
>-Scott
>
Can not agree more. But what if I want to define more than one cache-sram uio devices?
How about use the device tree for pseudo uio cache-sram driver?
static const struct of_device_id uio_mpc85xx_l2ctlr_of_match[] = {
{ .compatible = "uio,cache-sram", },
{},
};
Thanks,
Wenhu
^ permalink raw reply
* [PATCH v2] KVM: Optimize kvm_arch_vcpu_ioctl_run function
From: Tianjia Zhang @ 2020-04-16 5:10 UTC (permalink / raw)
To: pbonzini, tsbogend, paulus, mpe, benh, borntraeger, frankja,
david, cohuck, heiko.carstens, gor, sean.j.christopherson,
vkuznets, wanpengli, jmattson, joro, tglx, mingo, bp, x86, hpa,
maz, james.morse, julien.thierry.kdev, suzuki.poulose,
christoffer.dall, peterx, thuth
Cc: linux-s390, tianjia.zhang, kvm, linux-mips, kvm-ppc, linux-kernel,
linuxppc-dev, kvmarm, linux-arm-kernel
In earlier versions of kvm, 'kvm_run' is an independent structure
and is not included in the vcpu structure. At present, 'kvm_run'
is already included in the vcpu structure, so the parameter
'kvm_run' is redundant.
This patch simplify the function definition, removes the extra
'kvm_run' parameter, and extract it from the 'kvm_vcpu' structure
if necessary.
Signed-off-by: Tianjia Zhang <tianjia.zhang@linux.alibaba.com>
---
v2 change:
remove 'kvm_run' parameter and extract it from 'kvm_vcpu'
arch/mips/kvm/mips.c | 3 ++-
arch/powerpc/kvm/powerpc.c | 3 ++-
arch/s390/kvm/kvm-s390.c | 3 ++-
arch/x86/kvm/x86.c | 11 ++++++-----
include/linux/kvm_host.h | 2 +-
virt/kvm/arm/arm.c | 6 +++---
virt/kvm/kvm_main.c | 2 +-
7 files changed, 17 insertions(+), 13 deletions(-)
diff --git a/arch/mips/kvm/mips.c b/arch/mips/kvm/mips.c
index 8f05dd0a0f4e..ec24adf4857e 100644
--- a/arch/mips/kvm/mips.c
+++ b/arch/mips/kvm/mips.c
@@ -439,8 +439,9 @@ int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
return -ENOIOCTLCMD;
}
-int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)
+int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu)
{
+ struct kvm_run *run = vcpu->run;
int r = -EINTR;
vcpu_load(vcpu);
diff --git a/arch/powerpc/kvm/powerpc.c b/arch/powerpc/kvm/powerpc.c
index e15166b0a16d..7e24691e138a 100644
--- a/arch/powerpc/kvm/powerpc.c
+++ b/arch/powerpc/kvm/powerpc.c
@@ -1764,8 +1764,9 @@ int kvm_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg)
return r;
}
-int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)
+int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu)
{
+ struct kvm_run *run = vcpu->run;
int r;
vcpu_load(vcpu);
diff --git a/arch/s390/kvm/kvm-s390.c b/arch/s390/kvm/kvm-s390.c
index 19a81024fe16..443af3ead739 100644
--- a/arch/s390/kvm/kvm-s390.c
+++ b/arch/s390/kvm/kvm-s390.c
@@ -4333,8 +4333,9 @@ static void store_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
store_regs_fmt2(vcpu, kvm_run);
}
-int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu)
{
+ struct kvm_run *kvm_run = vcpu->run;
int rc;
if (kvm_run->immediate_exit)
diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
index 3bf2ecafd027..a0338e86c90f 100644
--- a/arch/x86/kvm/x86.c
+++ b/arch/x86/kvm/x86.c
@@ -8707,8 +8707,9 @@ static void kvm_put_guest_fpu(struct kvm_vcpu *vcpu)
trace_kvm_fpu(0);
}
-int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu)
{
+ struct kvm_run *kvm_run = vcpu->run;
int r;
vcpu_load(vcpu);
@@ -8726,18 +8727,18 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
r = -EAGAIN;
if (signal_pending(current)) {
r = -EINTR;
- vcpu->run->exit_reason = KVM_EXIT_INTR;
+ kvm_run->exit_reason = KVM_EXIT_INTR;
++vcpu->stat.signal_exits;
}
goto out;
}
- if (vcpu->run->kvm_valid_regs & ~KVM_SYNC_X86_VALID_FIELDS) {
+ if (kvm_run->kvm_valid_regs & ~KVM_SYNC_X86_VALID_FIELDS) {
r = -EINVAL;
goto out;
}
- if (vcpu->run->kvm_dirty_regs) {
+ if (kvm_run->kvm_dirty_regs) {
r = sync_regs(vcpu);
if (r != 0)
goto out;
@@ -8767,7 +8768,7 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
out:
kvm_put_guest_fpu(vcpu);
- if (vcpu->run->kvm_valid_regs)
+ if (kvm_run->kvm_valid_regs)
store_regs(vcpu);
post_kvm_run_save(vcpu);
kvm_sigset_deactivate(vcpu);
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index 6d58beb65454..1e17ef719595 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -866,7 +866,7 @@ int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
struct kvm_mp_state *mp_state);
int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
struct kvm_guest_debug *dbg);
-int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run);
+int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu);
int kvm_arch_init(void *opaque);
void kvm_arch_exit(void);
diff --git a/virt/kvm/arm/arm.c b/virt/kvm/arm/arm.c
index 48d0ec44ad77..f5390ac2165b 100644
--- a/virt/kvm/arm/arm.c
+++ b/virt/kvm/arm/arm.c
@@ -639,7 +639,6 @@ static void check_vcpu_requests(struct kvm_vcpu *vcpu)
/**
* kvm_arch_vcpu_ioctl_run - the main VCPU run function to execute guest code
* @vcpu: The VCPU pointer
- * @run: The kvm_run structure pointer used for userspace state exchange
*
* This function is called through the VCPU_RUN ioctl called from user space. It
* will execute VM code in a loop until the time slice for the process is used
@@ -647,8 +646,9 @@ static void check_vcpu_requests(struct kvm_vcpu *vcpu)
* return with return value 0 and with the kvm_run structure filled in with the
* required data for the requested emulation.
*/
-int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)
+int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu)
{
+ struct kvm_run *run = vcpu->run;
int ret;
if (unlikely(!kvm_vcpu_initialized(vcpu)))
@@ -659,7 +659,7 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)
return ret;
if (run->exit_reason == KVM_EXIT_MMIO) {
- ret = kvm_handle_mmio_return(vcpu, vcpu->run);
+ ret = kvm_handle_mmio_return(vcpu, run);
if (ret)
return ret;
}
diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c
index 74bdb7bf3295..e18faea89146 100644
--- a/virt/kvm/kvm_main.c
+++ b/virt/kvm/kvm_main.c
@@ -3135,7 +3135,7 @@ static long kvm_vcpu_ioctl(struct file *filp,
synchronize_rcu();
put_pid(oldpid);
}
- r = kvm_arch_vcpu_ioctl_run(vcpu, vcpu->run);
+ r = kvm_arch_vcpu_ioctl_run(vcpu);
trace_kvm_userspace_exit(vcpu->run->exit_reason, r);
break;
}
--
2.17.1
^ permalink raw reply related
* [PATCH] KVM: PPC: Book3S HV: Handle non-present PTEs in page fault functions
From: Paul Mackerras @ 2020-04-16 5:03 UTC (permalink / raw)
To: kvm, kvm-ppc; +Cc: clg, David Gibson, linuxppc-dev, linux-kernel, groug
Since cd758a9b57ee "KVM: PPC: Book3S HV: Use __gfn_to_pfn_memslot in HPT
page fault handler", it's been possible in fairly rare circumstances to
load a non-present PTE in kvmppc_book3s_hv_page_fault() when running a
guest on a POWER8 host.
Because that case wasn't checked for, we could misinterpret the non-present
PTE as being a cache-inhibited PTE. That could mismatch with the
corresponding hash PTE, which would cause the function to fail with -EFAULT
a little further down. That would propagate up to the KVM_RUN ioctl()
generally causing the KVM userspace (usually qemu) to fall over.
This addresses the problem by catching that case and returning to the guest
instead, letting it fault again, and retrying the whole page fault from
the beginning.
For completeness, this fixes the radix page fault handler in the same
way. For radix this didn't cause any obvious misbehaviour, because we
ended up putting the non-present PTE into the guest's partition-scoped
page tables, leading immediately to another hypervisor data/instruction
storage interrupt, which would go through the page fault path again
and fix things up.
Fixes: cd758a9b57ee "KVM: PPC: Book3S HV: Use __gfn_to_pfn_memslot in HPT page fault handler"
Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1820402
Reported-by: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: Paul Mackerras <paulus@ozlabs.org>
---
This is a reworked version of the patch David Gibson sent recently,
with the fix applied to the radix case as well. The commit message
is mostly stolen from David's patch.
arch/powerpc/kvm/book3s_64_mmu_hv.c | 9 +++++----
arch/powerpc/kvm/book3s_64_mmu_radix.c | 9 +++++----
2 files changed, 10 insertions(+), 8 deletions(-)
diff --git a/arch/powerpc/kvm/book3s_64_mmu_hv.c b/arch/powerpc/kvm/book3s_64_mmu_hv.c
index 3aecec8..20b7dce 100644
--- a/arch/powerpc/kvm/book3s_64_mmu_hv.c
+++ b/arch/powerpc/kvm/book3s_64_mmu_hv.c
@@ -604,18 +604,19 @@ int kvmppc_book3s_hv_page_fault(struct kvm_run *run, struct kvm_vcpu *vcpu,
*/
local_irq_disable();
ptep = __find_linux_pte(vcpu->arch.pgdir, hva, NULL, &shift);
+ pte = __pte(0);
+ if (ptep)
+ pte = *ptep;
+ local_irq_enable();
/*
* If the PTE disappeared temporarily due to a THP
* collapse, just return and let the guest try again.
*/
- if (!ptep) {
- local_irq_enable();
+ if (!pte_present(pte)) {
if (page)
put_page(page);
return RESUME_GUEST;
}
- pte = *ptep;
- local_irq_enable();
hpa = pte_pfn(pte) << PAGE_SHIFT;
pte_size = PAGE_SIZE;
if (shift)
diff --git a/arch/powerpc/kvm/book3s_64_mmu_radix.c b/arch/powerpc/kvm/book3s_64_mmu_radix.c
index 134fbc1..7bf94ba 100644
--- a/arch/powerpc/kvm/book3s_64_mmu_radix.c
+++ b/arch/powerpc/kvm/book3s_64_mmu_radix.c
@@ -815,18 +815,19 @@ int kvmppc_book3s_instantiate_page(struct kvm_vcpu *vcpu,
*/
local_irq_disable();
ptep = __find_linux_pte(vcpu->arch.pgdir, hva, NULL, &shift);
+ pte = __pte(0);
+ if (ptep)
+ pte = *ptep;
+ local_irq_enable();
/*
* If the PTE disappeared temporarily due to a THP
* collapse, just return and let the guest try again.
*/
- if (!ptep) {
- local_irq_enable();
+ if (!pte_present(pte)) {
if (page)
put_page(page);
return RESUME_GUEST;
}
- pte = *ptep;
- local_irq_enable();
/* If we're logging dirty pages, always map single pages */
large_enable = !(memslot->flags & KVM_MEM_LOG_DIRTY_PAGES);
--
2.7.4
^ permalink raw reply related
* Re: [musl] Powerpc Linux 'scv' system call ABI proposal take 2
From: Florian Weimer @ 2020-04-16 4:48 UTC (permalink / raw)
To: Rich Felker; +Cc: musl, libc-alpha, linuxppc-dev, Nicholas Piggin, libc-dev
In-Reply-To: <20200415225539.GL11469@brightrain.aerifal.cx>
* Rich Felker:
> My preference would be that it work just like the i386 AT_SYSINFO
> where you just replace "int $128" with "call *%%gs:16" and the kernel
> provides a stub in the vdso that performs either scv or the old
> mechanism with the same calling convention.
The i386 mechanism has received some criticism because it provides an
effective means to redirect execution flow to anyone who can write to
the TCB. I am not sure if it makes sense to copy it.
^ permalink raw reply
* Re: [PATCH v2] powerpc/setup_64: Set cache-line-size based on cache-block-size
From: Chris Packham @ 2020-04-16 4:36 UTC (permalink / raw)
To: christophe.leroy@c-s.fr, paulus@samba.org, mpe@ellerman.id.au,
benh@kernel.crashing.org, oss@buserror.net, tglx@linutronix.de
Cc: Hamish Martin, linuxppc-dev@lists.ozlabs.org,
linux-kernel@vger.kernel.org
In-Reply-To: <20200325031854.7625-1-chris.packham@alliedtelesis.co.nz>
Hi All,
On Wed, 2020-03-25 at 16:18 +1300, Chris Packham wrote:
> If {i,d}-cache-block-size is set and {i,d}-cache-line-size is not,
> use
> the block-size value for both. Per the devicetree spec cache-line-
> size
> is only needed if it differs from the block size.
>
> Signed-off-by: Chris Packham <chris.packham@alliedtelesis.co.nz>
> ---
> It looks as though the bsizep = lsizep is not required per the spec
> but it's
> probably safer to retain it.
>
> Changes in v2:
> - Scott pointed out that u-boot should be filling in the cache
> properties
> (which it does). But it does not specify a cache-line-size because
> it
> provides a cache-block-size and the spec says you don't have to if
> they are
> the same. So the error is in the parsing not in the devicetree
> itself.
>
Ping? This thread went kind of quiet.
> arch/powerpc/kernel/setup_64.c | 2 ++
> 1 file changed, 2 insertions(+)
>
> diff --git a/arch/powerpc/kernel/setup_64.c
> b/arch/powerpc/kernel/setup_64.c
> index e05e6dd67ae6..dd8a238b54b8 100644
> --- a/arch/powerpc/kernel/setup_64.c
> +++ b/arch/powerpc/kernel/setup_64.c
> @@ -516,6 +516,8 @@ static bool __init parse_cache_info(struct
> device_node *np,
> lsizep = of_get_property(np, propnames[3], NULL);
> if (bsizep == NULL)
> bsizep = lsizep;
> + if (lsizep == NULL)
> + lsizep = bsizep;
> if (lsizep != NULL)
> lsize = be32_to_cpu(*lsizep);
> if (bsizep != NULL)
^ permalink raw reply
* Re: [PATCH v2, 1/5] powerpc: 85xx: make FSL_85XX_CACHE_SRAM configurable
From: Wang Wenhu @ 2020-04-16 4:11 UTC (permalink / raw)
To: oss, Wang Wenhu, gregkh; +Cc: kernel, linuxppc-dev, linux-kernel
In-Reply-To: <36961f9d8c533d8b576043a2c6fc4859accfd9f1.camel@buserror.net>
From: Scott Wood <oss@buserror.net>
>> + bool "32-bit kernel"
>
>Why make that user selectable ?
>
>Either a kernel is 64-bit or it is 32-bit. So having PPC64 user
>selectable is all we need.
>
>And what is the link between this change and the description in the log ?
>
>> default y if !PPC64
>> select KASAN_VMALLOC if KASAN && MODULES
>>
>> @@ -15,6 +15,7 @@ config PPC_BOOK3S_32
>> bool
>>
>> menu "Processor support"
>> +
>
>Why adding this space ?
>
>> choice
>> prompt "Processor Type"
>> depends on PPC32
>> @@ -211,9 +212,9 @@ config PPC_BOOK3E
>> depends on PPC_BOOK3E_64
>>
>> config E500
>> + bool "e500 Support"
>> select FSL_EMB_PERFMON
>> select PPC_FSL_BOOK3E
>> - bool
>
>Why make this user-selectable ? This is already selected by the
>processors requiring it, ie 8500, e5500 and e6500.
>
>Is there any other case where we need E500 ?
>
>And again, what's the link between this change and the description in
>the log ?
>
>
>>
>> config PPC_E500MC
>> bool "e500mc Support"
>>
>
>Christophe
Hi, Scott, Christophe!
I find that I did not get the point well of the defferences between
configurability and selectability(maybe words I created) of Kconfig items.
You are right that FSL_85XX_CACHE_SRAM should only be selected by a caller
but never enable it seperately.
Same answer for the comments from Christophe. I will drop this patch in v3.
Thanks,
Wenhu
^ permalink raw reply
* Re: CVE-2020-11669: Linux kernel 4.10 to 5.1: powerpc: guest can cause DoS on POWER9 KVM hosts
From: Paul Mackerras @ 2020-04-16 4:02 UTC (permalink / raw)
To: Michal Suchánek; +Cc: oss-security, linuxppc-dev, Andrew Donnellan
In-Reply-To: <20200415140329.GC25468@kitsune.suse.cz>
On Wed, Apr 15, 2020 at 04:03:29PM +0200, Michal Suchánek wrote:
> On Wed, Apr 15, 2020 at 10:52:53PM +1000, Andrew Donnellan wrote:
> > The Linux kernel for powerpc from v4.10 to v5.1 has a bug where the
> > Authority Mask Register (AMR), Authority Mask Override Register (AMOR) and
> > User Authority Mask Override Register (UAMOR) are not correctly saved and
> > restored when the CPU is going into/coming out of idle state.
> >
> > On POWER9 CPUs, this means that a CPU may return from idle with the AMR
> > value of another thread on the same core.
> >
> > This allows a trivial Denial of Service attack against KVM hosts, by booting
> > a guest kernel which makes use of the AMR, such as a v5.2 or later kernel
> > with Kernel Userspace Access Prevention (KUAP) enabled.
> >
> > The guest kernel will set the AMR to prevent userspace access, then the
> > thread will go idle. At a later point, the hardware thread that the guest
> > was using may come out of idle and start executing in the host, without
> > restoring the host AMR value. The host kernel can get caught in a page fault
> > loop, as the AMR is unexpectedly causing memory accesses to fail in the
> > host, and the host is eventually rendered unusable.
>
> Hello,
>
> shouldn't the kernel restore the host registers when leaving the guest?
It does. That's not the bug.
> I recall some code exists for handling the *AM*R when leaving guest. Can
> the KVM guest enter idle without exiting to host?
No, we currently never execute the "stop" instruction in guest context.
The bug occurs when a thread that is in the host goes idle and
executes the stop instruction to go to a power-saving state, while
another thread is executing inside a guest. Hardware loses the first
thread's AMR while it is stopped, and as it happens, it is possible
for the first thread to wake up with the contents of its AMR equal to
the other thread's AMR. This can happen even if the first thread has
never executed in the guest.
The kernel needs to save and restore AMR (among other registers)
across the stop instruction because of this hardware behaviour.
We missed the AMR initially, which is what led to this vulnerability.
Paul.
^ permalink raw reply
* [PATCH] KVM: PPC: Handle non-present PTEs in kvmppc_book3s_hv_page_fault()
From: David Gibson @ 2020-04-16 3:53 UTC (permalink / raw)
To: paulus, mpe; +Cc: groug, kvm-ppc, linux-kernel, clg, linuxppc-dev, David Gibson
Since cd758a9b57ee "KVM: PPC: Book3S HV: Use __gfn_to_pfn_memslot in HPT
page fault handler", it's been possible in fairly rare circumstances to
load a non-present PTE in kvmppc_book3s_hv_page_fault() when running a
guest on a POWER8 host.
Because that case wasn't checked for, we could misinterpret the non-present
PTE as being a cache-inhibited PTE. That could mismatch with the
corresponding hash PTE, which would cause the function to fail with -EFAULT
a little further down. That would propagate up to the KVM_RUN ioctl()
generally causing the KVM userspace (usually qemu) to fall over.
This addresses the problem by catching that case and returning to the guest
instead.
Fixes: cd758a9b57ee "KVM: PPC: Book3S HV: Use __gfn_to_pfn_memslot in HPT page fault handler"
Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1820402
Suggested-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
---
arch/powerpc/kvm/book3s_64_mmu_hv.c | 5 +++++
1 file changed, 5 insertions(+)
diff --git a/arch/powerpc/kvm/book3s_64_mmu_hv.c b/arch/powerpc/kvm/book3s_64_mmu_hv.c
index 6404df613ea3..394fca8e630a 100644
--- a/arch/powerpc/kvm/book3s_64_mmu_hv.c
+++ b/arch/powerpc/kvm/book3s_64_mmu_hv.c
@@ -616,6 +616,11 @@ int kvmppc_book3s_hv_page_fault(struct kvm_run *run, struct kvm_vcpu *vcpu,
}
pte = *ptep;
local_irq_enable();
+ if (!pte_present(pte)) {
+ if (page)
+ put_page(page);
+ return RESUME_GUEST;
+ }
hpa = pte_pfn(pte) << PAGE_SHIFT;
pte_size = PAGE_SIZE;
if (shift)
--
2.25.2
^ permalink raw reply related
* Re: [musl] Powerpc Linux 'scv' system call ABI proposal take 2
From: Nicholas Piggin @ 2020-04-16 3:41 UTC (permalink / raw)
To: Rich Felker; +Cc: libc-dev, libc-alpha, linuxppc-dev, musl
In-Reply-To: <20200416030304.GQ11469@brightrain.aerifal.cx>
Excerpts from Rich Felker's message of April 16, 2020 1:03 pm:
> On Thu, Apr 16, 2020 at 12:53:31PM +1000, Nicholas Piggin wrote:
>> > Not to mention the dcache line to access
>> > __hwcap or whatever, and the icache lines to setup access TOC-relative
>> > access to it. (Of course you could put a copy of its value in TLS at a
>> > fixed offset, which would somewhat mitigate both.)
>> >
>> >> And finally, the HWCAP test can eventually go away in future. A vdso
>> >> call can not.
>> >
>> > We support nearly arbitrarily old kernels (with limited functionality)
>> > and hardware (with full functionality) and don't intend for that to
>> > change, ever. But indeed glibc might want too eventually drop the
>> > check.
>>
>> Ah, cool. Any build-time flexibility there?
>>
>> We may or may not be getting a new ABI that will use instructions not
>> supported by old processors.
>>
>> https://sourceware.org/legacy-ml/binutils/2019-05/msg00331.html
>>
>> Current ABI continues to work of course and be the default for some
>> time, but building for new one would give some opportunity to drop
>> such support for old procs, at least for glibc.
>
> What does "new ABI" entail to you? In the terminology I use with musl,
> "new ABI" and "new ISA level" are different things. You can compile
> (explicit -march or compiler default) binaries that won't run on older
> cpus due to use of new insns etc., but we consider it the same ABI if
> you can link code for an older/baseline ISA level with the
> newer-ISA-level object files, i.e. if the interface surface for
> linkage remains compatible. We also try to avoid gratuitous
> proliferation of different ABIs unless there's a strong underlying
> need (like addition of softfloat ABIs for archs that usually have FPU,
> or vice versa).
Yeah it will be a new ABI type that also requires a new ISA level.
As far as I know (and I'm not on the toolchain side) there will be
some call compatibility between the two, so it may be fine to
continue with existing ABI for libc. But it just something that
comes to mind as a build-time cutover where we might be able to
assume particular features.
> In principle the same could be done for kernels except it's a bigger
> silent gotcha (possible ENOSYS in places where it shouldn't be able to
> happen rather than a trapping SIGILL or similar) and there's rarely
> any serious performance or size benefit to dropping support for older
> kernels.
Right, I don't think it'd be a huge problem whatever way we go,
compared with the cost of the system call.
Thanks,
Nick
^ permalink raw reply
* Re: [PATCH] papr/scm: Add bad memory ranges to nvdimm bad ranges
From: Vaibhav Jain @ 2020-04-16 3:41 UTC (permalink / raw)
To: Santosh Sivaraj, linuxppc-dev
Cc: Oliver, Ganesh Goudar, Mahesh Salgaonkar, Aneesh Kumar K.V
In-Reply-To: <20200401074741.1562361-1-santosh@fossix.org>
Hi Santosh,
Some review comments below.
Santosh Sivaraj <santosh@fossix.org> writes:
> Subscribe to the MCE notification and add the physical address which
> generated a memory error to nvdimm bad range.
>
> Signed-off-by: Santosh Sivaraj <santosh@fossix.org>
> ---
>
> This patch depends on "powerpc/mce: Add MCE notification chain" [1].
>
> Unlike the previous series[2], the patch adds badblock registration only for
> pseries scm driver. Handling badblocks for baremetal (powernv) PMEM will be done
> later and if possible get the badblock handling as a common code.
>
> [1] https://lore.kernel.org/linuxppc-dev/20200330071219.12284-1-ganeshgr@linux.ibm.com/
> [2] https://lore.kernel.org/linuxppc-dev/20190820023030.18232-1-santosh@fossix.org/
>
> arch/powerpc/platforms/pseries/papr_scm.c | 96 ++++++++++++++++++++++-
> 1 file changed, 95 insertions(+), 1 deletion(-)
>
> diff --git a/arch/powerpc/platforms/pseries/papr_scm.c b/arch/powerpc/platforms/pseries/papr_scm.c
> index 0b4467e378e5..5012cbf4606e 100644
> --- a/arch/powerpc/platforms/pseries/papr_scm.c
> +++ b/arch/powerpc/platforms/pseries/papr_scm.c
> @@ -12,6 +12,8 @@
> #include <linux/libnvdimm.h>
> #include <linux/platform_device.h>
> #include <linux/delay.h>
> +#include <linux/nd.h>
> +#include <asm/mce.h>
>
> #include <asm/plpar_wrappers.h>
>
> @@ -39,8 +41,12 @@ struct papr_scm_priv {
> struct resource res;
> struct nd_region *region;
> struct nd_interleave_set nd_set;
> + struct list_head region_list;
> };
>
> +LIST_HEAD(papr_nd_regions);
> +DEFINE_MUTEX(papr_ndr_lock);
> +
> static int drc_pmem_bind(struct papr_scm_priv *p)
> {
> unsigned long ret[PLPAR_HCALL_BUFSIZE];
> @@ -372,6 +378,10 @@ static int papr_scm_nvdimm_init(struct papr_scm_priv *p)
> dev_info(dev, "Region registered with target node %d and online node %d",
> target_nid, online_nid);
>
> + mutex_lock(&papr_ndr_lock);
> + list_add_tail(&p->region_list, &papr_nd_regions);
> + mutex_unlock(&papr_ndr_lock);
> +
> return 0;
>
> err: nvdimm_bus_unregister(p->bus);
> @@ -379,6 +389,68 @@ err: nvdimm_bus_unregister(p->bus);
> return -ENXIO;
> }
>
> +void papr_scm_add_badblock(struct nd_region *region, struct nvdimm_bus *bus,
> + u64 phys_addr)
> +{
> + u64 aligned_addr = ALIGN_DOWN(phys_addr, L1_CACHE_BYTES);
> +
> + if (nvdimm_bus_add_badrange(bus, aligned_addr, L1_CACHE_BYTES)) {
> + pr_err("Bad block registration for 0x%llx failed\n", phys_addr);
> + return;
> + }
> +
> + pr_debug("Add memory range (0x%llx - 0x%llx) as bad range\n",
> + aligned_addr, aligned_addr + L1_CACHE_BYTES);
> +
> + nvdimm_region_notify(region, NVDIMM_REVALIDATE_POISON);
> +}
> +
> +static int handle_mce_ue(struct notifier_block *nb, unsigned long val,
> + void *data)
> +{
> + struct machine_check_event *evt = data;
> + struct papr_scm_priv *p;
> + u64 phys_addr;
> + bool found = false;
> +
> + if (evt->error_type != MCE_ERROR_TYPE_UE)
> + return NOTIFY_DONE;
> +
> + if (list_empty(&papr_nd_regions))
> + return NOTIFY_DONE;
> +
> + phys_addr = evt->u.ue_error.physical_address +
> + (evt->u.ue_error.effective_address & ~PAGE_MASK);
Though it seems that you are trying to get the actual physical address
from the page aligned evt->u.ue_error.physical_address, it would be nice
if you could put a comment as to why you are doing this seemingly wierd
math with real and effective addresses here.
> +
> + if (!evt->u.ue_error.physical_address_provided ||
> + !is_zone_device_page(pfn_to_page(phys_addr >> PAGE_SHIFT)))
> + return NOTIFY_DONE;
> +
> + /* mce notifier is called from a process context, so mutex is safe */
> + mutex_lock(&papr_ndr_lock);
> + list_for_each_entry(p, &papr_nd_regions, region_list) {
> + struct resource res = p->res;
> +
> + if (phys_addr >= res.start && phys_addr <= res.end) {
> + found = true;
> + break;
> + }
> + }
> +
> + mutex_unlock(&papr_ndr_lock);
> +
> + if (!found)
> + return NOTIFY_DONE;
> +
> + papr_scm_add_badblock(p->region, p->bus, phys_addr);
I see a possible race between papr_scm_add_badblock() and
papr_scm_remove() as a bad block may be reported just remove a region is
disabled. Would recomment calling papr_scm_bad_block() in context of
papr_ndr_lock.
> +
> + return NOTIFY_OK;
> +}
> +
> +static struct notifier_block mce_ue_nb = {
> + .notifier_call = handle_mce_ue
> +};
> +
> static int papr_scm_probe(struct platform_device *pdev)
> {
> struct device_node *dn = pdev->dev.of_node;
> @@ -476,6 +548,10 @@ static int papr_scm_remove(struct platform_device *pdev)
> {
> struct papr_scm_priv *p = platform_get_drvdata(pdev);
>
> + mutex_lock(&papr_ndr_lock);
> + list_del(&(p->region_list));
> + mutex_unlock(&papr_ndr_lock);
> +
> nvdimm_bus_unregister(p->bus);
> drc_pmem_unbind(p);
> kfree(p->bus_desc.provider_name);
> @@ -498,7 +574,25 @@ static struct platform_driver papr_scm_driver = {
> },
> };
>
> -module_platform_driver(papr_scm_driver);
> +static int __init papr_scm_init(void)
> +{
> + int ret;
> +
> + ret = platform_driver_register(&papr_scm_driver);
> + if (!ret)
> + mce_register_notifier(&mce_ue_nb);
> +
> + return ret;
> +}
> +module_init(papr_scm_init);
> +
> +static void __exit papr_scm_exit(void)
> +{
> + mce_unregister_notifier(&mce_ue_nb);
> + platform_driver_unregister(&papr_scm_driver);
> +}
> +module_exit(papr_scm_exit);
> +
> MODULE_DEVICE_TABLE(of, papr_scm_match);
> MODULE_LICENSE("GPL");
> MODULE_AUTHOR("IBM Corporation");
> --
> 2.25.1
>
--
Vaibhav Jain <vaibhav@linux.ibm.com>
Linux Technology Center, IBM India Pvt. Ltd.
^ permalink raw reply
* Re: [Bug 206203] kmemleak reports various leaks in drivers/of/unittest.c
From: Frank Rowand @ 2020-04-16 3:27 UTC (permalink / raw)
To: Michael Ellerman, Rob Herring; +Cc: devicetree, linuxppc-dev
In-Reply-To: <8383090b-f8d1-f346-5ff3-7234a9d44092@gmail.com>
On 4/8/20 10:22 AM, Frank Rowand wrote:
> Hi Michael,
>
> On 4/7/20 10:13 PM, Michael Ellerman wrote:
>> bugzilla-daemon@bugzilla.kernel.org writes:
>>> https://bugzilla.kernel.org/show_bug.cgi?id=206203
>>>
>>> Erhard F. (erhard_f@mailbox.org) changed:
>>>
>>> What |Removed |Added
>>> ----------------------------------------------------------------------------
>>> Attachment #286801|0 |1
>>> is obsolete| |
>>>
>>> --- Comment #10 from Erhard F. (erhard_f@mailbox.org) ---
>>> Created attachment 288189
>>> --> https://bugzilla.kernel.org/attachment.cgi?id=288189&action=edit
>>> kmemleak output (kernel 5.6.2, Talos II)
>>
>> These are all in or triggered by the of unittest code AFAICS.
>> Content of the log reproduced below.
>>
>> Frank/Rob, are these memory leaks expected?
>
> Thanks for the report. I'll look at each one.
Only one of the leaks was expected. I have patches to fix the
unexpected leaks and to remove the expected leak so that the
kmemleak report of it will not have to be checked again.
I expect to send the patch series tomorrow (Thursday).
-Frank
>
> -Frank
>
>
>>
>> cheers
>>
>>
>> unreferenced object 0xc0000007eb89ca58 (size 192):
>> comm "swapper/0", pid 1, jiffies 4294878935 (age 824.747s)
>> hex dump (first 32 bytes):
>> c0 00 00 00 00 d9 21 38 00 00 00 00 00 00 00 00 ......!8........
>> c0 00 00 07 ec 97 80 08 00 00 00 00 00 00 00 00 ................
>> backtrace:
>> [<0000000007b50c76>] .__of_node_dup+0x38/0x1c0
>> [<00000000e2115f4f>] .of_unittest_changeset+0x13c/0xa20
>> [<00000000925a8013>] .of_unittest+0x1ba0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec978008 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878935 (age 824.747s)
>> hex dump (first 8 bytes):
>> 6e 31 00 6b 6b 6b 6b a5 n1.kkkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000a074532f>] .__of_node_dup+0x50/0x1c0
>> [<00000000e2115f4f>] .of_unittest_changeset+0x13c/0xa20
>> [<00000000925a8013>] .of_unittest+0x1ba0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eb89e318 (size 192):
>> comm "swapper/0", pid 1, jiffies 4294878935 (age 824.747s)
>> hex dump (first 32 bytes):
>> c0 00 00 00 00 d9 21 38 00 00 00 00 00 00 00 00 ......!8........
>> c0 00 00 07 ec 97 ab 08 00 00 00 00 00 00 00 00 ................
>> backtrace:
>> [<0000000007b50c76>] .__of_node_dup+0x38/0x1c0
>> [<00000000881dc9c4>] .of_unittest_changeset+0x194/0xa20
>> [<00000000925a8013>] .of_unittest+0x1ba0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec97ab08 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878935 (age 824.747s)
>> hex dump (first 8 bytes):
>> 6e 32 00 6b 6b 6b 6b a5 n2.kkkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000a074532f>] .__of_node_dup+0x50/0x1c0
>> [<00000000881dc9c4>] .of_unittest_changeset+0x194/0xa20
>> [<00000000925a8013>] .of_unittest+0x1ba0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eb89e528 (size 192):
>> comm "swapper/0", pid 1, jiffies 4294878935 (age 824.747s)
>> hex dump (first 32 bytes):
>> c0 00 00 07 ec 97 bd d8 00 00 00 00 00 00 00 00 ................
>> c0 00 00 07 ec 97 b3 18 00 00 00 00 00 00 00 00 ................
>> backtrace:
>> [<0000000007b50c76>] .__of_node_dup+0x38/0x1c0
>> [<00000000af6923cb>] .of_unittest_changeset+0x1ec/0xa20
>> [<00000000925a8013>] .of_unittest+0x1ba0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec97b318 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878935 (age 824.747s)
>> hex dump (first 8 bytes):
>> 6e 32 31 00 6b 6b 6b a5 n21.kkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000a074532f>] .__of_node_dup+0x50/0x1c0
>> [<00000000af6923cb>] .of_unittest_changeset+0x1ec/0xa20
>> [<00000000925a8013>] .of_unittest+0x1ba0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007f1c1fb00 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878935 (age 824.757s)
>> hex dump (first 32 bytes):
>> c0 00 00 07 ec 97 90 28 00 00 00 03 00 00 00 00 .......(........
>> c0 00 00 07 ec 97 8e d0 00 00 00 00 00 00 00 00 ................
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<000000003079b8f2>] .of_unittest_changeset+0x310/0xa20
>> [<00000000925a8013>] .of_unittest+0x1ba0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec979028 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878935 (age 824.757s)
>> hex dump (first 8 bytes):
>> 6e 61 6d 65 00 6b 6b a5 name.kk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<000000003079b8f2>] .of_unittest_changeset+0x310/0xa20
>> [<00000000925a8013>] .of_unittest+0x1ba0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec978ed0 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878935 (age 824.757s)
>> hex dump (first 8 bytes):
>> 6e 31 00 6b 6b 6b 6b a5 n1.kkkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<000000003079b8f2>] .of_unittest_changeset+0x310/0xa20
>> [<00000000925a8013>] .of_unittest+0x1ba0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007f1c1bc80 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878935 (age 824.757s)
>> hex dump (first 32 bytes):
>> c0 00 00 07 ec 97 b4 70 00 00 00 03 00 00 00 00 .......p........
>> c0 00 00 07 ec 97 b1 c0 00 00 00 00 00 00 00 00 ................
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<000000000f97f174>] .of_unittest_changeset+0x368/0xa20
>> [<00000000925a8013>] .of_unittest+0x1ba0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec97b470 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878935 (age 824.757s)
>> hex dump (first 8 bytes):
>> 6e 61 6d 65 00 6b 6b a5 name.kk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<000000000f97f174>] .of_unittest_changeset+0x368/0xa20
>> [<00000000925a8013>] .of_unittest+0x1ba0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec97b1c0 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878935 (age 824.757s)
>> hex dump (first 8 bytes):
>> 6e 32 00 6b 6b 6b 6b a5 n2.kkkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<000000000f97f174>] .of_unittest_changeset+0x368/0xa20
>> [<00000000925a8013>] .of_unittest+0x1ba0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007f1c1d800 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878935 (age 824.764s)
>> hex dump (first 32 bytes):
>> c0 00 00 07 ec 97 88 18 00 00 00 03 00 00 00 00 ................
>> c0 00 00 07 ec 97 bd d8 00 00 00 00 00 00 00 00 ................
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<00000000c71a088a>] .of_unittest_changeset+0x3c0/0xa20
>> [<00000000925a8013>] .of_unittest+0x1ba0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec978818 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878935 (age 824.764s)
>> hex dump (first 8 bytes):
>> 6e 61 6d 65 00 6b 6b a5 name.kk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<00000000c71a088a>] .of_unittest_changeset+0x3c0/0xa20
>> [<00000000925a8013>] .of_unittest+0x1ba0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec97bdd8 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878935 (age 824.764s)
>> hex dump (first 8 bytes):
>> 6e 32 31 6b 6b 6b 6b a5 n21kkkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<00000000c71a088a>] .of_unittest_changeset+0x3c0/0xa20
>> [<00000000925a8013>] .of_unittest+0x1ba0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec979d98 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878935 (age 824.764s)
>> hex dump (first 8 bytes):
>> 6e 31 00 6b 6b 6b 6b a5 n1.kkkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<0000000001df4c62>] .kvasprintf_const+0xa8/0xf0
>> [<00000000b7ba15a5>] .kobject_set_name_vargs+0x34/0xf0
>> [<0000000076cbbcf2>] .kobject_add+0x50/0xe0
>> [<000000002d7a6157>] .__of_attach_node_sysfs+0xa8/0x160
>> [<000000004ed552f3>] .__of_changeset_entry_apply+0x32c/0x390
>> [<0000000062a8a683>] .__of_changeset_apply_entries+0x48/0x110
>> [<00000000530ec4ee>] .of_changeset_apply+0x54/0xc0
>> [<0000000039fa95c3>] .of_unittest_changeset+0x8a4/0xa20
>> [<00000000925a8013>] .of_unittest+0x1ba0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec9796e0 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878935 (age 824.764s)
>> hex dump (first 8 bytes):
>> 6e 32 00 6b 6b 6b 6b a5 n2.kkkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<0000000001df4c62>] .kvasprintf_const+0xa8/0xf0
>> [<00000000b7ba15a5>] .kobject_set_name_vargs+0x34/0xf0
>> [<0000000076cbbcf2>] .kobject_add+0x50/0xe0
>> [<000000002d7a6157>] .__of_attach_node_sysfs+0xa8/0x160
>> [<000000004ed552f3>] .__of_changeset_entry_apply+0x32c/0x390
>> [<0000000062a8a683>] .__of_changeset_apply_entries+0x48/0x110
>> [<00000000530ec4ee>] .of_changeset_apply+0x54/0xc0
>> [<0000000039fa95c3>] .of_unittest_changeset+0x8a4/0xa20
>> [<00000000925a8013>] .of_unittest+0x1ba0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec979ef0 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878935 (age 824.764s)
>> hex dump (first 8 bytes):
>> 6e 32 31 00 6b 6b 6b a5 n21.kkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<0000000001df4c62>] .kvasprintf_const+0xa8/0xf0
>> [<00000000b7ba15a5>] .kobject_set_name_vargs+0x34/0xf0
>> [<0000000076cbbcf2>] .kobject_add+0x50/0xe0
>> [<000000002d7a6157>] .__of_attach_node_sysfs+0xa8/0x160
>> [<000000004ed552f3>] .__of_changeset_entry_apply+0x32c/0x390
>> [<0000000062a8a683>] .__of_changeset_apply_entries+0x48/0x110
>> [<00000000530ec4ee>] .of_changeset_apply+0x54/0xc0
>> [<0000000039fa95c3>] .of_unittest_changeset+0x8a4/0xa20
>> [<00000000925a8013>] .of_unittest+0x1ba0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f2e98800 (size 2048):
>> comm "swapper/0", pid 1, jiffies 4294878936 (age 824.760s)
>> hex dump (first 32 bytes):
>> c0 00 00 07 ec 92 dc 40 ff ff ff ff 00 00 00 00 .......@........
>> c0 00 00 07 ec 92 dc 40 c0 00 20 07 f2 e9 88 18 .......@.. .....
>> backtrace:
>> [<00000000d07b7b2c>] .platform_device_alloc+0x34/0x100
>> [<00000000d9abb21d>] .of_device_alloc+0x44/0x390
>> [<0000000002d381f5>] .of_platform_device_create_pdata+0x78/0x1a0
>> [<00000000c7a45eba>] .of_platform_bus_create+0x214/0x2f0
>> [<00000000c6ba35e7>] .of_platform_bus_create+0x268/0x2f0
>> [<0000000076525030>] .of_platform_populate+0x78/0x140
>> [<00000000d3aeed04>] .of_unittest_platform_populate+0x328/0x50c
>> [<000000003978eb44>] .of_unittest+0x24a8/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec92dc40 (size 64):
>> comm "swapper/0", pid 1, jiffies 4294878936 (age 824.760s)
>> hex dump (first 32 bytes):
>> 74 65 73 74 63 61 73 65 2d 64 61 74 61 3a 70 6c testcase-data:pl
>> 61 74 66 6f 72 6d 2d 74 65 73 74 73 3a 74 65 73 atform-tests:tes
>> backtrace:
>> [<00000000154ad5cf>] .kvasprintf+0x60/0xd0
>> [<00000000b7ba15a5>] .kobject_set_name_vargs+0x34/0xf0
>> [<00000000cce6fd03>] .dev_set_name+0x2c/0x40
>> [<000000007d4be46f>] .of_device_alloc+0x2b0/0x390
>> [<0000000002d381f5>] .of_platform_device_create_pdata+0x78/0x1a0
>> [<00000000c7a45eba>] .of_platform_bus_create+0x214/0x2f0
>> [<00000000c6ba35e7>] .of_platform_bus_create+0x268/0x2f0
>> [<0000000076525030>] .of_platform_populate+0x78/0x140
>> [<00000000d3aeed04>] .of_unittest_platform_populate+0x328/0x50c
>> [<000000003978eb44>] .of_unittest+0x24a8/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eb8aa100 (size 256):
>> comm "swapper/0", pid 1, jiffies 4294878936 (age 824.760s)
>> hex dump (first 32 bytes):
>> 00 00 00 00 de ad 4e ad ff ff ff ff 00 00 00 00 ......N.........
>> ff ff ff ff ff ff ff ff c0 00 00 00 02 30 31 a8 .............01.
>> backtrace:
>> [<000000008039b6cb>] .device_add+0x578/0x980
>> [<0000000012aa326f>] .of_device_add+0x58/0x70
>> [<00000000d6a8e21f>] .of_platform_device_create_pdata+0xc4/0x1a0
>> [<00000000c7a45eba>] .of_platform_bus_create+0x214/0x2f0
>> [<00000000c6ba35e7>] .of_platform_bus_create+0x268/0x2f0
>> [<0000000076525030>] .of_platform_populate+0x78/0x140
>> [<00000000d3aeed04>] .of_unittest_platform_populate+0x328/0x50c
>> [<000000003978eb44>] .of_unittest+0x24a8/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f2e9a000 (size 2048):
>> comm "swapper/0", pid 1, jiffies 4294878936 (age 824.764s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 f2 e7 a2 40 ff ff ff ff 00 00 00 00 .. ....@........
>> c0 00 20 07 f2 e7 a2 40 c0 00 20 07 f2 e9 a0 18 .. ....@.. .....
>> backtrace:
>> [<00000000d07b7b2c>] .platform_device_alloc+0x34/0x100
>> [<00000000d9abb21d>] .of_device_alloc+0x44/0x390
>> [<0000000002d381f5>] .of_platform_device_create_pdata+0x78/0x1a0
>> [<00000000c7a45eba>] .of_platform_bus_create+0x214/0x2f0
>> [<00000000c6ba35e7>] .of_platform_bus_create+0x268/0x2f0
>> [<0000000076525030>] .of_platform_populate+0x78/0x140
>> [<00000000d3aeed04>] .of_unittest_platform_populate+0x328/0x50c
>> [<000000003978eb44>] .of_unittest+0x24a8/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f2e7a240 (size 64):
>> comm "swapper/0", pid 1, jiffies 4294878936 (age 824.764s)
>> hex dump (first 32 bytes):
>> 74 65 73 74 63 61 73 65 2d 64 61 74 61 3a 70 6c testcase-data:pl
>> 61 74 66 6f 72 6d 2d 74 65 73 74 73 3a 74 65 73 atform-tests:tes
>> backtrace:
>> [<00000000154ad5cf>] .kvasprintf+0x60/0xd0
>> [<00000000b7ba15a5>] .kobject_set_name_vargs+0x34/0xf0
>> [<00000000cce6fd03>] .dev_set_name+0x2c/0x40
>> [<000000007d4be46f>] .of_device_alloc+0x2b0/0x390
>> [<0000000002d381f5>] .of_platform_device_create_pdata+0x78/0x1a0
>> [<00000000c7a45eba>] .of_platform_bus_create+0x214/0x2f0
>> [<00000000c6ba35e7>] .of_platform_bus_create+0x268/0x2f0
>> [<0000000076525030>] .of_platform_populate+0x78/0x140
>> [<00000000d3aeed04>] .of_unittest_platform_populate+0x328/0x50c
>> [<000000003978eb44>] .of_unittest+0x24a8/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eb8ac100 (size 256):
>> comm "swapper/0", pid 1, jiffies 4294878936 (age 824.764s)
>> hex dump (first 32 bytes):
>> 00 00 00 00 de ad 4e ad ff ff ff ff 00 00 00 00 ......N.........
>> ff ff ff ff ff ff ff ff c0 00 00 00 02 30 31 a8 .............01.
>> backtrace:
>> [<000000008039b6cb>] .device_add+0x578/0x980
>> [<0000000012aa326f>] .of_device_add+0x58/0x70
>> [<00000000d6a8e21f>] .of_platform_device_create_pdata+0xc4/0x1a0
>> [<00000000c7a45eba>] .of_platform_bus_create+0x214/0x2f0
>> [<00000000c6ba35e7>] .of_platform_bus_create+0x268/0x2f0
>> [<0000000076525030>] .of_platform_populate+0x78/0x140
>> [<00000000d3aeed04>] .of_unittest_platform_populate+0x328/0x50c
>> [<000000003978eb44>] .of_unittest+0x24a8/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eb89f7b8 (size 192):
>> comm "swapper/0", pid 1, jiffies 4294878937 (age 824.760s)
>> hex dump (first 32 bytes):
>> c0 00 00 07 f1 ea 17 b0 00 00 00 00 00 00 00 00 ................
>> c0 00 20 07 f2 e8 47 40 00 00 00 00 00 00 00 00 .. ...G@........
>> backtrace:
>> [<0000000007b50c76>] .__of_node_dup+0x38/0x1c0
>> [<000000006f73e286>] .build_changeset_next_level+0x280/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<00000000d856304a>] .of_unittest+0x2758/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f2e84740 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878937 (age 824.764s)
>> hex dump (first 16 bytes):
>> 74 65 73 74 2d 75 6e 69 74 74 65 73 74 34 00 a5 test-unittest4..
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000a074532f>] .__of_node_dup+0x50/0x1c0
>> [<000000006f73e286>] .build_changeset_next_level+0x280/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<00000000d856304a>] .of_unittest+0x2758/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007f1c1c680 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878937 (age 824.764s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 f2 e8 70 f0 00 00 00 09 00 00 00 00 .. ...p.........
>> c0 00 20 07 f4 2e b6 b0 c0 00 00 07 f1 c1 df 80 .. .............
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<00000000d856304a>] .of_unittest+0x2758/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f2e870f0 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878937 (age 824.764s)
>> hex dump (first 16 bytes):
>> 63 6f 6d 70 61 74 69 62 6c 65 00 6b 6b 6b 6b a5 compatible.kkkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<00000000d856304a>] .of_unittest+0x2758/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f42eb6b0 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878937 (age 824.764s)
>> hex dump (first 16 bytes):
>> 75 6e 69 74 74 65 73 74 00 6b 6b 6b 6b 6b 6b a5 unittest.kkkkkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<00000000d856304a>] .of_unittest+0x2758/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007f1c1df80 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878937 (age 824.767s)
>> hex dump (first 32 bytes):
>> c0 00 00 07 ec 7f ec 60 00 00 00 05 00 00 00 00 .......`........
>> c0 00 00 07 ec 7f f4 70 c0 00 00 07 f1 c1 e2 00 .......p........
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<00000000d856304a>] .of_unittest+0x2758/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec7fec60 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878937 (age 824.767s)
>> hex dump (first 8 bytes):
>> 73 74 61 74 75 73 00 a5 status..
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<00000000d856304a>] .of_unittest+0x2758/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec7ff470 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878937 (age 824.767s)
>> hex dump (first 8 bytes):
>> 6f 6b 61 79 00 6b 6b a5 okay.kk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<00000000d856304a>] .of_unittest+0x2758/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007f1c1e200 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878937 (age 824.767s)
>> hex dump (first 32 bytes):
>> c0 00 00 07 ec 7f dc 40 00 00 00 04 00 00 00 00 .......@........
>> c0 00 00 07 ec 7f cc 20 c0 00 00 07 f1 c1 97 00 ....... ........
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<00000000d856304a>] .of_unittest+0x2758/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec7fdc40 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878937 (age 824.767s)
>> hex dump (first 8 bytes):
>> 72 65 67 00 6b 6b 6b a5 reg.kkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<00000000d856304a>] .of_unittest+0x2758/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec7fcc20 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878937 (age 824.767s)
>> hex dump (first 8 bytes):
>> 00 00 00 04 6b 6b 6b a5 ....kkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<00000000d856304a>] .of_unittest+0x2758/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007f1c19700 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878937 (age 824.770s)
>> hex dump (first 32 bytes):
>> c0 00 00 07 ec 7f c5 68 00 00 00 0f 00 00 00 00 .......h........
>> c0 00 20 07 f4 2e bb 00 00 00 00 00 00 00 00 00 .. .............
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<00000000d856304a>] .of_unittest+0x2758/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec7fc568 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878937 (age 824.770s)
>> hex dump (first 8 bytes):
>> 6e 61 6d 65 00 6b 6b a5 name.kk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<00000000d856304a>] .of_unittest+0x2758/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f42ebb00 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878937 (age 824.770s)
>> hex dump (first 16 bytes):
>> 74 65 73 74 2d 75 6e 69 74 74 65 73 74 34 00 a5 test-unittest4..
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<00000000d856304a>] .of_unittest+0x2758/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f42e8fe0 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878937 (age 824.770s)
>> hex dump (first 16 bytes):
>> 74 65 73 74 2d 75 6e 69 74 74 65 73 74 34 00 a5 test-unittest4..
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<0000000001df4c62>] .kvasprintf_const+0xa8/0xf0
>> [<00000000b7ba15a5>] .kobject_set_name_vargs+0x34/0xf0
>> [<0000000076cbbcf2>] .kobject_add+0x50/0xe0
>> [<000000002d7a6157>] .__of_attach_node_sysfs+0xa8/0x160
>> [<000000004ed552f3>] .__of_changeset_entry_apply+0x32c/0x390
>> [<0000000062a8a683>] .__of_changeset_apply_entries+0x48/0x110
>> [<0000000067290146>] .of_overlay_fdt_apply+0xb00/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<00000000d856304a>] .of_unittest+0x2758/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eb89e108 (size 192):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.767s)
>> hex dump (first 32 bytes):
>> c0 00 00 07 eb a1 c8 a0 00 00 00 00 00 00 00 00 ................
>> c0 00 20 07 f4 2e 8b 90 00 00 00 00 00 00 00 00 .. .............
>> backtrace:
>> [<0000000007b50c76>] .__of_node_dup+0x38/0x1c0
>> [<000000006f73e286>] .build_changeset_next_level+0x280/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f42e8b90 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.767s)
>> hex dump (first 16 bytes):
>> 74 65 73 74 2d 75 6e 69 74 74 65 73 74 31 30 00 test-unittest10.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000a074532f>] .__of_node_dup+0x50/0x1c0
>> [<000000006f73e286>] .build_changeset_next_level+0x280/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007f1c18f80 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.767s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 f4 2e 8a 20 00 00 00 09 00 00 00 00 .. .... ........
>> c0 00 20 07 f4 2e a5 70 c0 00 00 07 f1 c1 8a 80 .. ....p........
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f42e8a20 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.770s)
>> hex dump (first 16 bytes):
>> 63 6f 6d 70 61 74 69 62 6c 65 00 6b 6b 6b 6b a5 compatible.kkkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f42ea570 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.770s)
>> hex dump (first 16 bytes):
>> 75 6e 69 74 74 65 73 74 00 6b 6b 6b 6b 6b 6b a5 unittest.kkkkkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007f1c18a80 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.770s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 f5 57 61 a0 00 00 00 05 00 00 00 00 .. ..Wa.........
>> c0 00 20 07 f5 57 4e d0 c0 00 00 07 f1 c1 94 80 .. ..WN.........
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f55761a0 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.774s)
>> hex dump (first 8 bytes):
>> 73 74 61 74 75 73 00 a5 status..
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f5574ed0 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.774s)
>> hex dump (first 8 bytes):
>> 6f 6b 61 79 00 6b 6b a5 okay.kk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007f1c19480 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.774s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 f5 57 50 28 00 00 00 04 00 00 00 00 .. ..WP(........
>> c0 00 20 07 f5 57 71 c0 c0 00 00 07 f1 c1 c1 80 .. ..Wq.........
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f5575028 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.774s)
>> hex dump (first 8 bytes):
>> 72 65 67 00 6b 6b 6b a5 reg.kkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f55771c0 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.774s)
>> hex dump (first 8 bytes):
>> 00 00 00 0a 6b 6b 6b a5 ....kkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007f1c1c180 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.774s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 f4 2e 99 f0 00 00 00 04 00 00 00 00 .. .............
>> c0 00 20 07 f5 57 74 70 c0 00 00 07 f1 c1 ab 00 .. ..Wtp........
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f5577470 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.777s)
>> hex dump (first 8 bytes):
>> 00 00 00 01 6b 6b 6b a5 ....kkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007f1c1ab00 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.777s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 f4 2e 88 b0 00 00 00 04 00 00 00 00 .. .............
>> c0 00 20 07 f5 57 7d d8 c0 00 00 07 f1 c1 8d 00 .. ..W}.........
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f42e88b0 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.777s)
>> hex dump (first 16 bytes):
>> 23 73 69 7a 65 2d 63 65 6c 6c 73 00 6b 6b 6b a5 #size-cells.kkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f5577dd8 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.780s)
>> hex dump (first 8 bytes):
>> 00 00 00 00 6b 6b 6b a5 ....kkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007f1c18d00 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.780s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 f5 57 48 18 00 00 00 10 00 00 00 00 .. ..WH.........
>> c0 00 20 07 f4 2e ac a0 00 00 00 00 00 00 00 00 .. .............
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f5574818 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.780s)
>> hex dump (first 8 bytes):
>> 6e 61 6d 65 00 6b 6b a5 name.kk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f42eaca0 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.780s)
>> hex dump (first 16 bytes):
>> 74 65 73 74 2d 75 6e 69 74 74 65 73 74 31 30 00 test-unittest10.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eb89d8c8 (size 192):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.780s)
>> hex dump (first 32 bytes):
>> c0 00 00 07 eb a1 cb 50 00 00 00 00 00 00 00 00 .......P........
>> c0 00 00 07 ea dd 8d 20 00 00 00 00 00 00 00 00 ....... ........
>> backtrace:
>> [<0000000007b50c76>] .__of_node_dup+0x38/0x1c0
>> [<000000006f73e286>] .build_changeset_next_level+0x280/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eadd8d20 (size 32):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.780s)
>> hex dump (first 32 bytes):
>> 74 65 73 74 2d 75 6e 69 74 74 65 73 74 31 30 31 test-unittest101
>> 00 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b a5 .kkkkkkkkkkkkkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000a074532f>] .__of_node_dup+0x50/0x1c0
>> [<000000006f73e286>] .build_changeset_next_level+0x280/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007f1c1a880 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.784s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 f4 2e af 80 00 00 00 09 00 00 00 00 .. .............
>> c0 00 20 07 f4 2e 81 80 c0 00 00 07 f1 c1 92 00 .. .............
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f42eaf80 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.784s)
>> hex dump (first 16 bytes):
>> 63 6f 6d 70 61 74 69 62 6c 65 00 6b 6b 6b 6b a5 compatible.kkkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f42e8180 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.784s)
>> hex dump (first 16 bytes):
>> 75 6e 69 74 74 65 73 74 00 6b 6b 6b 6b 6b 6b a5 unittest.kkkkkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007f1c19200 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.784s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 f5 57 75 c8 00 00 00 05 00 00 00 00 .. ..Wu.........
>> c0 00 20 07 f5 57 7c 80 c0 00 00 07 f1 c1 d3 00 .. ..W|.........
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f55775c8 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.784s)
>> hex dump (first 8 bytes):
>> 73 74 61 74 75 73 00 a5 status..
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f5577c80 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.784s)
>> hex dump (first 8 bytes):
>> 6f 6b 61 79 00 6b 6b a5 okay.kk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007f1c1d300 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.787s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 f5 57 77 20 00 00 00 04 00 00 00 00 .. ..Ww ........
>> c0 00 20 07 f5 57 5d 98 c0 00 00 07 f2 25 0f 80 .. ..W]......%..
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f5577720 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.787s)
>> hex dump (first 8 bytes):
>> 72 65 67 00 6b 6b 6b a5 reg.kkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f5575d98 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.787s)
>> hex dump (first 8 bytes):
>> 00 00 00 01 6b 6b 6b a5 ....kkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007f2250f80 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.790s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 f5 57 68 58 00 00 00 11 00 00 00 00 .. ..WhX........
>> c0 00 00 07 ea dd a2 40 00 00 00 00 00 00 00 00 .......@........
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f5576858 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.790s)
>> hex dump (first 8 bytes):
>> 6e 61 6d 65 00 6b 6b a5 name.kk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eadda240 (size 32):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.790s)
>> hex dump (first 32 bytes):
>> 74 65 73 74 2d 75 6e 69 74 74 65 73 74 31 30 31 test-unittest101
>> 00 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b a5 .kkkkkkkkkkkkkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007ece6bc70 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.790s)
>> hex dump (first 16 bytes):
>> 74 65 73 74 2d 75 6e 69 74 74 65 73 74 31 30 00 test-unittest10.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<0000000001df4c62>] .kvasprintf_const+0xa8/0xf0
>> [<00000000b7ba15a5>] .kobject_set_name_vargs+0x34/0xf0
>> [<0000000076cbbcf2>] .kobject_add+0x50/0xe0
>> [<000000002d7a6157>] .__of_attach_node_sysfs+0xa8/0x160
>> [<000000004ed552f3>] .__of_changeset_entry_apply+0x32c/0x390
>> [<0000000062a8a683>] .__of_changeset_apply_entries+0x48/0x110
>> [<0000000067290146>] .of_overlay_fdt_apply+0xb00/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eadd9540 (size 32):
>> comm "swapper/0", pid 1, jiffies 4294878938 (age 824.790s)
>> hex dump (first 32 bytes):
>> 74 65 73 74 2d 75 6e 69 74 74 65 73 74 31 30 31 test-unittest101
>> 00 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b a5 .kkkkkkkkkkkkkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<0000000001df4c62>] .kvasprintf_const+0xa8/0xf0
>> [<00000000b7ba15a5>] .kobject_set_name_vargs+0x34/0xf0
>> [<0000000076cbbcf2>] .kobject_add+0x50/0xe0
>> [<000000002d7a6157>] .__of_attach_node_sysfs+0xa8/0x160
>> [<000000004ed552f3>] .__of_changeset_entry_apply+0x32c/0x390
>> [<0000000062a8a683>] .__of_changeset_apply_entries+0x48/0x110
>> [<0000000067290146>] .of_overlay_fdt_apply+0xb00/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<00000000e3d25537>] .of_unittest_apply_overlay_check+0xfc/0x1e4
>> [<000000009b1b95aa>] .of_unittest+0x2da4/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eb89e738 (size 192):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.787s)
>> hex dump (first 32 bytes):
>> c0 00 00 07 eb a1 98 a0 00 00 00 00 00 00 00 00 ................
>> c0 00 20 07 ec e6 8e 70 00 00 00 00 00 00 00 00 .. ....p........
>> backtrace:
>> [<0000000007b50c76>] .__of_node_dup+0x38/0x1c0
>> [<000000006f73e286>] .build_changeset_next_level+0x280/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007ece68e70 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.790s)
>> hex dump (first 16 bytes):
>> 74 65 73 74 2d 75 6e 69 74 74 65 73 74 31 31 00 test-unittest11.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000a074532f>] .__of_node_dup+0x50/0x1c0
>> [<000000006f73e286>] .build_changeset_next_level+0x280/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec886200 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.790s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 ec e6 a4 00 00 00 00 09 00 00 00 00 .. .............
>> c0 00 20 07 ec e6 99 f0 c0 00 00 07 ec 88 55 80 .. ...........U.
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007ece6a400 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.790s)
>> hex dump (first 16 bytes):
>> 63 6f 6d 70 61 74 69 62 6c 65 00 6b 6b 6b 6b a5 compatible.kkkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007ece699f0 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.794s)
>> hex dump (first 16 bytes):
>> 75 6e 69 74 74 65 73 74 00 6b 6b 6b 6b 6b 6b a5 unittest.kkkkkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec885580 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.794s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 f8 5d a0 48 00 00 00 05 00 00 00 00 .. ..].H........
>> c0 00 20 07 f8 5d ac 60 c0 00 00 07 ec 88 46 80 .. ..].`......F.
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f85da048 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.794s)
>> hex dump (first 8 bytes):
>> 73 74 61 74 75 73 00 a5 status..
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f85dac60 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.794s)
>> hex dump (first 8 bytes):
>> 6f 6b 61 79 00 6b 6b a5 okay.kk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec884680 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.794s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 f8 5d ab 08 00 00 00 04 00 00 00 00 .. ..]..........
>> c0 00 20 07 f8 5d 9a e8 c0 00 00 07 ec 88 6e 80 .. ..]........n.
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f85dab08 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.794s)
>> hex dump (first 8 bytes):
>> 72 65 67 00 6b 6b 6b a5 reg.kkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f85d9ae8 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.797s)
>> hex dump (first 8 bytes):
>> 00 00 00 0b 6b 6b 6b a5 ....kkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec886e80 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.797s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 ec e6 a6 e0 00 00 00 04 00 00 00 00 .. .............
>> c0 00 20 07 f8 5d b3 18 c0 00 00 07 ec 88 44 00 .. ..]........D.
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007ece6a6e0 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.797s)
>> hex dump (first 16 bytes):
>> 23 61 64 64 72 65 73 73 2d 63 65 6c 6c 73 00 a5 #address-cells..
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f85db318 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.797s)
>> hex dump (first 8 bytes):
>> 00 00 00 01 6b 6b 6b a5 ....kkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec884400 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.797s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 ec e6 81 80 00 00 00 04 00 00 00 00 .. .............
>> c0 00 20 07 f8 5d 92 d8 c0 00 00 07 ec 88 3a 00 .. ..]........:.
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007ece68180 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.797s)
>> hex dump (first 16 bytes):
>> 23 73 69 7a 65 2d 63 65 6c 6c 73 00 6b 6b 6b a5 #size-cells.kkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f85d92d8 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.800s)
>> hex dump (first 8 bytes):
>> 00 00 00 00 6b 6b 6b a5 ....kkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec883a00 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.800s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 f8 5d 80 08 00 00 00 10 00 00 00 00 .. ..]..........
>> c0 00 20 07 ec e6 b3 d0 00 00 00 00 00 00 00 00 .. .............
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f85d8008 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.800s)
>> hex dump (first 8 bytes):
>> 6e 61 6d 65 00 6b 6b a5 name.kk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007ece6b3d0 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.804s)
>> hex dump (first 16 bytes):
>> 74 65 73 74 2d 75 6e 69 74 74 65 73 74 31 31 00 test-unittest11.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eb89fde8 (size 192):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.804s)
>> hex dump (first 32 bytes):
>> c0 00 00 07 eb a1 9b 50 00 00 00 00 00 00 00 00 .......P........
>> c0 00 00 07 ea dd 85 00 00 00 00 00 00 00 00 00 ................
>> backtrace:
>> [<0000000007b50c76>] .__of_node_dup+0x38/0x1c0
>> [<000000006f73e286>] .build_changeset_next_level+0x280/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eadd8500 (size 32):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.804s)
>> hex dump (first 32 bytes):
>> 74 65 73 74 2d 75 6e 69 74 74 65 73 74 31 31 31 test-unittest111
>> 00 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b a5 .kkkkkkkkkkkkkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000a074532f>] .__of_node_dup+0x50/0x1c0
>> [<000000006f73e286>] .build_changeset_next_level+0x280/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec886c00 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.804s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 ec e6 8a 20 00 00 00 09 00 00 00 00 .. .... ........
>> c0 00 20 07 ec e6 ab 30 c0 00 00 07 ec 88 0a 80 .. ....0........
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007ece68a20 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.804s)
>> hex dump (first 16 bytes):
>> 63 6f 6d 70 61 74 69 62 6c 65 00 6b 6b 6b 6b a5 compatible.kkkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007ece6ab30 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.804s)
>> hex dump (first 16 bytes):
>> 75 6e 69 74 74 65 73 74 00 6b 6b 6b 6b 6b 6b a5 unittest.kkkkkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec880a80 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.807s)
>> hex dump (first 32 bytes):
>> c0 00 20 07 f8 5d a5 a8 00 00 00 05 00 00 00 00 .. ..]..........
>> c0 00 00 07 eb 18 c8 18 c0 00 00 07 ec 88 58 00 ..............X.
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f85da5a8 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.807s)
>> hex dump (first 8 bytes):
>> 73 74 61 74 75 73 00 a5 status..
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eb18c818 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.807s)
>> hex dump (first 8 bytes):
>> 6f 6b 61 79 00 6b 6b a5 okay.kk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec885800 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.810s)
>> hex dump (first 32 bytes):
>> c0 00 00 07 eb 18 fc 80 00 00 00 04 00 00 00 00 ................
>> c0 00 00 07 eb 18 f4 70 c0 00 00 07 ec 88 41 80 .......p......A.
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eb18fc80 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.810s)
>> hex dump (first 8 bytes):
>> 72 65 67 00 6b 6b 6b a5 reg.kkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eb18f470 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.810s)
>> hex dump (first 8 bytes):
>> 00 00 00 01 6b 6b 6b a5 ....kkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec884180 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.810s)
>> hex dump (first 32 bytes):
>> c0 00 00 07 eb 18 dd 98 00 00 00 11 00 00 00 00 ................
>> c0 00 00 07 ea dd b4 20 00 00 00 00 00 00 00 00 ....... ........
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eb18dd98 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.810s)
>> hex dump (first 8 bytes):
>> 6e 61 6d 65 00 6b 6b a5 name.kk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eaddb420 (size 32):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.810s)
>> hex dump (first 32 bytes):
>> 74 65 73 74 2d 75 6e 69 74 74 65 73 74 31 31 31 test-unittest111
>> 00 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b a5 .kkkkkkkkkkkkkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<0000000038c6aced>] .add_changeset_property.isra.0+0x61c/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<0000000034ba1197>] .build_changeset_next_level+0x334/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007ece6a850 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.814s)
>> hex dump (first 16 bytes):
>> 74 65 73 74 2d 75 6e 69 74 74 65 73 74 31 31 00 test-unittest11.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<0000000001df4c62>] .kvasprintf_const+0xa8/0xf0
>> [<00000000b7ba15a5>] .kobject_set_name_vargs+0x34/0xf0
>> [<0000000076cbbcf2>] .kobject_add+0x50/0xe0
>> [<000000002d7a6157>] .__of_attach_node_sysfs+0xa8/0x160
>> [<000000004ed552f3>] .__of_changeset_entry_apply+0x32c/0x390
>> [<0000000062a8a683>] .__of_changeset_apply_entries+0x48/0x110
>> [<0000000067290146>] .of_overlay_fdt_apply+0xb00/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eadda580 (size 32):
>> comm "swapper/0", pid 1, jiffies 4294878939 (age 824.814s)
>> hex dump (first 32 bytes):
>> 74 65 73 74 2d 75 6e 69 74 74 65 73 74 31 31 31 test-unittest111
>> 00 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b a5 .kkkkkkkkkkkkkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<0000000001df4c62>] .kvasprintf_const+0xa8/0xf0
>> [<00000000b7ba15a5>] .kobject_set_name_vargs+0x34/0xf0
>> [<0000000076cbbcf2>] .kobject_add+0x50/0xe0
>> [<000000002d7a6157>] .__of_attach_node_sysfs+0xa8/0x160
>> [<000000004ed552f3>] .__of_changeset_entry_apply+0x32c/0x390
>> [<0000000062a8a683>] .__of_changeset_apply_entries+0x48/0x110
>> [<0000000067290146>] .of_overlay_fdt_apply+0xb00/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<000000003ad7372f>] .of_unittest_apply_overlay.constprop.0+0x54/0xb8
>> [<000000008fda7969>] .of_unittest_apply_revert_overlay_check.constprop.0+0xc4/0x2b4
>> [<00000000ea132166>] .of_unittest+0x2ee0/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec881200 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878943 (age 824.800s)
>> hex dump (first 32 bytes):
>> c0 00 00 07 ec 71 d0 28 00 00 00 0c 00 00 00 00 .....q.(........
>> c0 00 20 07 f2 e8 c5 d0 00 00 00 00 00 00 00 00 .. .............
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<000000004e6be113>] .of_unittest+0x3458/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec71d028 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878943 (age 824.800s)
>> hex dump (first 8 bytes):
>> 6e 61 6d 65 00 6b 6b a5 name.kk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<000000004e6be113>] .of_unittest+0x3458/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007f2e8c5d0 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878943 (age 824.804s)
>> hex dump (first 16 bytes):
>> 5f 5f 73 79 6d 62 6f 6c 73 5f 5f 00 6b 6b 6b a5 __symbols__.kkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<000000004e6be113>] .of_unittest+0x3458/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eaddb280 (size 32):
>> comm "swapper/0", pid 1, jiffies 4294878943 (age 824.804s)
>> hex dump (first 32 bytes):
>> 2f 74 65 73 74 63 61 73 65 2d 64 61 74 61 2d 32 /testcase-data-2
>> 2f 73 75 62 73 74 61 74 69 6f 6e 40 31 30 30 00 /substation@100.
>> backtrace:
>> [<00000000154ad5cf>] .kvasprintf+0x60/0xd0
>> [<00000000c2320ab8>] .kasprintf+0x2c/0x40
>> [<000000005511b2ac>] .add_changeset_property.isra.0+0x170/0xaf0
>> [<0000000060888297>] .of_overlay_fdt_apply+0x5e4/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<00000000daa7ed62>] .of_unittest+0x3404/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eadd9880 (size 32):
>> comm "swapper/0", pid 1, jiffies 4294878943 (age 824.804s)
>> hex dump (first 32 bytes):
>> 2f 74 65 73 74 63 61 73 65 2d 64 61 74 61 2d 32 /testcase-data-2
>> 2f 66 61 69 72 77 61 79 2d 31 00 6b 6b 6b 6b a5 /fairway-1.kkkk.
>> backtrace:
>> [<00000000154ad5cf>] .kvasprintf+0x60/0xd0
>> [<00000000c2320ab8>] .kasprintf+0x2c/0x40
>> [<000000005511b2ac>] .add_changeset_property.isra.0+0x170/0xaf0
>> [<0000000060888297>] .of_overlay_fdt_apply+0x5e4/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<00000000daa7ed62>] .of_unittest+0x3404/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eaddbc40 (size 32):
>> comm "swapper/0", pid 1, jiffies 4294878943 (age 824.804s)
>> hex dump (first 32 bytes):
>> 2f 74 65 73 74 63 61 73 65 2d 64 61 74 61 2d 32 /testcase-data-2
>> 2f 66 61 69 72 77 61 79 2d 31 00 6b 6b 6b 6b a5 /fairway-1.kkkk.
>> backtrace:
>> [<00000000154ad5cf>] .kvasprintf+0x60/0xd0
>> [<00000000c2320ab8>] .kasprintf+0x2c/0x40
>> [<000000005511b2ac>] .add_changeset_property.isra.0+0x170/0xaf0
>> [<0000000060888297>] .of_overlay_fdt_apply+0x5e4/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<00000000daa7ed62>] .of_unittest+0x3404/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eaddbaa0 (size 32):
>> comm "swapper/0", pid 1, jiffies 4294878943 (age 824.804s)
>> hex dump (first 32 bytes):
>> 2f 74 65 73 74 63 61 73 65 2d 64 61 74 61 2d 32 /testcase-data-2
>> 2f 66 61 69 72 77 61 79 2d 31 00 6b 6b 6b 6b a5 /fairway-1.kkkk.
>> backtrace:
>> [<00000000154ad5cf>] .kvasprintf+0x60/0xd0
>> [<00000000c2320ab8>] .kasprintf+0x2c/0x40
>> [<000000005511b2ac>] .add_changeset_property.isra.0+0x170/0xaf0
>> [<0000000060888297>] .of_overlay_fdt_apply+0x5e4/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<00000000daa7ed62>] .of_unittest+0x3404/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec37b000 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878945 (age 824.797s)
>> hex dump (first 32 bytes):
>> c0 00 00 07 eb 7a 42 f0 00 00 00 04 00 00 00 00 .....zB.........
>> c0 00 20 07 ef af e1 a0 00 00 00 00 00 00 00 00 .. .............
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<00000000e6e185ca>] .add_changeset_property.isra.0+0x960/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000043c13a57>] .build_changeset_next_level+0x21c/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<00000000eaf6e6ea>] .of_unittest+0x35b8/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eb7a42f0 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878945 (age 824.797s)
>> hex dump (first 16 bytes):
>> 72 70 6d 5f 61 76 61 69 6c 00 6b 6b 6b 6b 6b a5 rpm_avail.kkkkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<00000000e6e185ca>] .add_changeset_property.isra.0+0x960/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000043c13a57>] .build_changeset_next_level+0x21c/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<00000000eaf6e6ea>] .of_unittest+0x35b8/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007efafe1a0 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878945 (age 824.797s)
>> hex dump (first 8 bytes):
>> 00 00 00 64 6b 6b 6b a5 ...dkkk.
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<00000000e6e185ca>] .add_changeset_property.isra.0+0x960/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<0000000043c13a57>] .build_changeset_next_level+0x21c/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<00000000eaf6e6ea>] .of_unittest+0x35b8/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007ec37bf00 (size 128):
>> comm "swapper/0", pid 1, jiffies 4294878945 (age 824.797s)
>> hex dump (first 32 bytes):
>> c0 00 00 07 eb 7a 5b 60 00 00 00 08 00 00 00 00 .....z[`........
>> c0 00 20 07 ef af f7 20 00 00 00 00 00 00 00 00 .. .... ........
>> backtrace:
>> [<00000000fd6c039b>] .__of_prop_dup+0x48/0x130
>> [<00000000e6e185ca>] .add_changeset_property.isra.0+0x960/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<00000000eaf6e6ea>] .of_unittest+0x35b8/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0000007eb7a5b60 (size 16):
>> comm "swapper/0", pid 1, jiffies 4294878945 (age 824.800s)
>> hex dump (first 16 bytes):
>> 72 70 6d 5f 61 76 61 69 6c 00 6b 6b 6b 6b 6b a5 rpm_avail.kkkkk.
>> backtrace:
>> [<00000000c939be68>] .kstrdup+0x44/0xb0
>> [<00000000f0610228>] .__of_prop_dup+0x60/0x130
>> [<00000000e6e185ca>] .add_changeset_property.isra.0+0x960/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<00000000eaf6e6ea>] .of_unittest+0x35b8/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>> unreferenced object 0xc0002007efaff720 (size 8):
>> comm "swapper/0", pid 1, jiffies 4294878945 (age 824.800s)
>> hex dump (first 8 bytes):
>> 00 00 00 64 00 00 00 c8 ...d....
>> backtrace:
>> [<00000000a2a61f11>] .kmemdup+0x30/0x70
>> [<00000000fcebe2cd>] .__of_prop_dup+0x7c/0x130
>> [<00000000e6e185ca>] .add_changeset_property.isra.0+0x960/0xaf0
>> [<000000008b0977be>] .build_changeset_next_level+0x74/0x370
>> [<000000009598e32c>] .of_overlay_fdt_apply+0x504/0xf90
>> [<00000000a7d4460c>] .overlay_data_apply+0xa8/0x118
>> [<00000000eaf6e6ea>] .of_unittest+0x35b8/0x3778
>> [<00000000af117d89>] .do_one_initcall+0x7c/0x420
>> [<00000000c99776b4>] .kernel_init_freeable+0x318/0x3d8
>> [<0000000001b957ee>] .kernel_init+0x14/0x168
>> [<000000001fe347b5>] .ret_from_kernel_thread+0x58/0x68
>>
>
>
^ permalink raw reply
* Re: [musl] Powerpc Linux 'scv' system call ABI proposal take 2
From: Rich Felker @ 2020-04-16 3:03 UTC (permalink / raw)
To: Nicholas Piggin; +Cc: libc-dev, libc-alpha, linuxppc-dev, musl
In-Reply-To: <1587004907.ioxh0bxsln.astroid@bobo.none>
On Thu, Apr 16, 2020 at 12:53:31PM +1000, Nicholas Piggin wrote:
> > Not to mention the dcache line to access
> > __hwcap or whatever, and the icache lines to setup access TOC-relative
> > access to it. (Of course you could put a copy of its value in TLS at a
> > fixed offset, which would somewhat mitigate both.)
> >
> >> And finally, the HWCAP test can eventually go away in future. A vdso
> >> call can not.
> >
> > We support nearly arbitrarily old kernels (with limited functionality)
> > and hardware (with full functionality) and don't intend for that to
> > change, ever. But indeed glibc might want too eventually drop the
> > check.
>
> Ah, cool. Any build-time flexibility there?
>
> We may or may not be getting a new ABI that will use instructions not
> supported by old processors.
>
> https://sourceware.org/legacy-ml/binutils/2019-05/msg00331.html
>
> Current ABI continues to work of course and be the default for some
> time, but building for new one would give some opportunity to drop
> such support for old procs, at least for glibc.
What does "new ABI" entail to you? In the terminology I use with musl,
"new ABI" and "new ISA level" are different things. You can compile
(explicit -march or compiler default) binaries that won't run on older
cpus due to use of new insns etc., but we consider it the same ABI if
you can link code for an older/baseline ISA level with the
newer-ISA-level object files, i.e. if the interface surface for
linkage remains compatible. We also try to avoid gratuitous
proliferation of different ABIs unless there's a strong underlying
need (like addition of softfloat ABIs for archs that usually have FPU,
or vice versa).
In principle the same could be done for kernels except it's a bigger
silent gotcha (possible ENOSYS in places where it shouldn't be able to
happen rather than a trapping SIGILL or similar) and there's rarely
any serious performance or size benefit to dropping support for older
kernels.
Rich
^ permalink raw reply
* Re: [musl] Powerpc Linux 'scv' system call ABI proposal take 2
From: Nicholas Piggin @ 2020-04-16 2:53 UTC (permalink / raw)
To: Rich Felker; +Cc: libc-dev, libc-alpha, linuxppc-dev, musl
In-Reply-To: <20200416023542.GP11469@brightrain.aerifal.cx>
Excerpts from Rich Felker's message of April 16, 2020 12:35 pm:
> On Thu, Apr 16, 2020 at 12:24:16PM +1000, Nicholas Piggin wrote:
>> >> > Likewise, it's not useful to have different error return mechanisms
>> >> > because the caller just has to branch to support both (or the
>> >> > kernel-provided stub just has to emulate one for it; that could work
>> >> > if you really want to change the bad existing convention).
>> >> >
>> >> > Thoughts?
>> >>
>> >> The existing convention has to change somewhat because of the clobbers,
>> >> so I thought we could change the error return at the same time. I'm
>> >> open to not changing it and using CR0[SO], but others liked the idea.
>> >> Pro: it matches sc and vsyscall. Con: it's different from other common
>> >> archs. Performnce-wise it would really be a wash -- cost of conditional
>> >> branch is not the cmp but the mispredict.
>> >
>> > If you do the branch on hwcap at each syscall, then you significantly
>> > increase code size of every syscall point, likely turning a bunch of
>> > trivial functions that didn't need stack frames into ones that do. You
>> > also potentially make them need a TOC pointer. Making them all just do
>> > an indirect call unconditionally (with pointer in TLS like i386?) is a
>> > lot more efficient in code size and at least as good for performance.
>>
>> I disagree. Doing the long vdso indirect call *necessarily* requires
>> touching a new icache line, and even a new TLB entry. Indirect branches
>
> The increase in number of icache lines from the branch at every
> syscall point is far greater than the use of a single extra icache
> line shared by all syscalls.
That's true, I was thinking of a single function that does the test and
calls syscalls, which might be the fair comparison.
> Not to mention the dcache line to access
> __hwcap or whatever, and the icache lines to setup access TOC-relative
> access to it. (Of course you could put a copy of its value in TLS at a
> fixed offset, which would somewhat mitigate both.)
>
>> And finally, the HWCAP test can eventually go away in future. A vdso
>> call can not.
>
> We support nearly arbitrarily old kernels (with limited functionality)
> and hardware (with full functionality) and don't intend for that to
> change, ever. But indeed glibc might want too eventually drop the
> check.
Ah, cool. Any build-time flexibility there?
We may or may not be getting a new ABI that will use instructions not
supported by old processors.
https://sourceware.org/legacy-ml/binutils/2019-05/msg00331.html
Current ABI continues to work of course and be the default for some
time, but building for new one would give some opportunity to drop
such support for old procs, at least for glibc.
>
>> If you really want to select with an indirect branch rather than
>> direct conditional, you can do that all within the library.
>
> OK. It's a little bit more work if that's not the interface the kernel
> will give us, but it's no big deal.
Okay.
Thanks,
Nick
^ permalink raw reply
* Re: [PATCH kernel v2 0/7] powerpc/powenv/ioda: Allow huge DMA window at 4GB
From: Oliver O'Halloran @ 2020-04-16 2:53 UTC (permalink / raw)
To: Alexey Kardashevskiy
Cc: KVM list, Fabiano Rosas, Alistair Popple, kvm-ppc, linuxppc-dev,
David Gibson
In-Reply-To: <CAOSf1CGfjX9LGQ1GDSmxrzjnaWOM3mUvBu9_xe-L2umin9n66w@mail.gmail.com>
On Thu, Apr 16, 2020 at 12:34 PM Oliver O'Halloran <oohall@gmail.com> wrote:
>
> On Thu, Apr 16, 2020 at 11:27 AM Alexey Kardashevskiy <aik@ozlabs.ru> wrote:
> >
> > Anyone? Is it totally useless or wrong approach? Thanks,
>
> I wouldn't say it's either, but I still hate it.
>
> The 4GB mode being per-PHB makes it difficult to use unless we force
> that mode on 100% of the time which I'd prefer not to do. Ideally
> devices that actually support 64bit addressing (which is most of them)
> should be able to use no-translate mode when possible since a) It's
> faster, and b) It frees up room in the TCE cache devices that actually
> need them. I know you've done some testing with 100G NICs and found
> the overhead was fine, but IMO that's a bad test since it's pretty
> much the best-case scenario since all the devices on the PHB are in
> the same PE. The PHB's TCE cache only hits when the TCE matches the
> DMA bus address and the PE number for the device so in a multi-PE
> environment there's a lot of potential for TCE cache trashing. If
> there was one or two PEs under that PHB it's probably not going to
> matter, but if you have an NVMe rack with 20 drives it starts to look
> a bit ugly.
>
> That all said, it might be worth doing this anyway since we probably
> want the software infrastructure in place to take advantage of it.
> Maybe expand the command line parameters to allow it to be enabled on
> a per-PHB basis rather than globally.
Since we're on the topic
I've been thinking the real issue we have is that we're trying to pick
an "optimal" IOMMU config at a point where we don't have enough
information to work out what's actually optimal. The IOMMU config is
done on a per-PE basis, but since PEs may contain devices with
different DMA masks (looking at you wierd AMD audio function) we're
always going to have to pick something conservative as the default
config for TVE#0 (64k, no bypass mapping) since the driver will tell
us what the device actually supports long after the IOMMU configuation
is done. What we really want is to be able to have separate IOMMU
contexts for each device, or at the very least a separate context for
the crippled devices.
We could allow a per-device IOMMU context by extending the Master /
Slave PE thing to cover DMA in addition to MMIO. Right now we only use
slave PEs when a device's MMIO BARs extend over multiple m64 segments.
When that happens an MMIO error causes the PHB to freezes the PE
corresponding to one of those segments, but not any of the others. To
present a single "PE" to the EEH core we check the freeze status of
each of the slave PEs when the EEH core does a PE status check and if
any of them are frozen, we freeze the rest of them too. When a driver
sets a limited DMA mask we could move that device to a seperate slave
PE so that it has it's own IOMMU context taylored to its DMA
addressing limits.
Thoughts?
Oliver
^ permalink raw reply
* Re: [PATCH v2 4/4] mm/vmalloc: Hugepage vmalloc mappings
From: Nicholas Piggin @ 2020-04-16 2:38 UTC (permalink / raw)
To: Will Deacon
Cc: linux-arch, Catalin Marinas, x86, linux-kernel, linux-mm,
Ingo Molnar, Borislav Petkov, H. Peter Anvin, Thomas Gleixner,
linuxppc-dev, linux-arm-kernel
In-Reply-To: <20200415104755.GD12621@willie-the-truck>
Excerpts from Will Deacon's message of April 15, 2020 8:47 pm:
> Hi Nick,
>
> On Mon, Apr 13, 2020 at 10:53:03PM +1000, Nicholas Piggin wrote:
>> For platforms that define HAVE_ARCH_HUGE_VMAP and support PMD vmap mappings,
>> have vmalloc attempt to allocate PMD-sized pages first, before falling back
>> to small pages. Allocations which use something other than PAGE_KERNEL
>> protections are not permitted to use huge pages yet, not all callers expect
>> this (e.g., module allocations vs strict module rwx).
>>
>> This gives a 6x reduction in dTLB misses for a `git diff` (of linux), from
>> 45600 to 6500 and a 2.2% reduction in cycles on a 2-node POWER9.
>
> I wonder if it's worth extending vmap() to handle higher order pages in
> a similar way? That might be helpful for tracing PMUs such as Arm SPE,
> where the CPU streams tracing data out to a virtually addressed buffer
> (see rb_alloc_aux_page()).
Yeah it becomes pretty trivial to do that with VM_HUGE_PAGES after
this patch, I have something to do it but no callers ready yet, if
you have an easy one we can add it.
>> This can result in more internal fragmentation and memory overhead for a
>> given allocation. It can also cause greater NUMA unbalance on hashdist
>> allocations.
>>
>> There may be other callers that expect small pages under vmalloc but use
>> PAGE_KERNEL, I'm not sure if it's feasible to catch them all. An
>> alternative would be a new function or flag which enables large mappings,
>> and use that in callers.
>>
>> Signed-off-by: Nicholas Piggin <npiggin@gmail.com>
>> ---
>> include/linux/vmalloc.h | 2 +
>> mm/vmalloc.c | 135 +++++++++++++++++++++++++++++-----------
>> 2 files changed, 102 insertions(+), 35 deletions(-)
>>
>> diff --git a/include/linux/vmalloc.h b/include/linux/vmalloc.h
>> index 291313a7e663..853b82eac192 100644
>> --- a/include/linux/vmalloc.h
>> +++ b/include/linux/vmalloc.h
>> @@ -24,6 +24,7 @@ struct notifier_block; /* in notifier.h */
>> #define VM_UNINITIALIZED 0x00000020 /* vm_struct is not fully initialized */
>> #define VM_NO_GUARD 0x00000040 /* don't add guard page */
>> #define VM_KASAN 0x00000080 /* has allocated kasan shadow memory */
>> +#define VM_HUGE_PAGES 0x00000100 /* may use huge pages */
>
> Please can you add a check for this in the arm64 change_memory_common()
> code? Other architectures might need something similar, but we need to
> forbid changing memory attributes for portions of the huge page.
Yeah good idea, I can look about adding some more checks.
>
> In general, I'm a bit wary of software table walkers tripping over this.
> For example, I don't think apply_to_existing_page_range() can handle
> huge mappings at all, but the one user (KASAN) only ever uses page mappings
> so it's ok there.
Right, I have something to warn for apply to page range (and looking
at adding support for bigger pages). It doesn't even have a test and
warn at the moment which isn't good practice IMO so we should add one
even without huge vmap.
>
>> @@ -2325,9 +2356,11 @@ static struct vm_struct *__get_vm_area_node(unsigned long size,
>> if (unlikely(!size))
>> return NULL;
>>
>> - if (flags & VM_IOREMAP)
>> - align = 1ul << clamp_t(int, get_count_order_long(size),
>> - PAGE_SHIFT, IOREMAP_MAX_ORDER);
>> + if (flags & VM_IOREMAP) {
>> + align = max(align,
>> + 1ul << clamp_t(int, get_count_order_long(size),
>> + PAGE_SHIFT, IOREMAP_MAX_ORDER));
>> + }
>
>
> I don't follow this part. Please could you explain why you're potentially
> aligning above IOREMAP_MAX_ORDER? It doesn't seem to follow from the rest
> of the patch.
Trying to remember. If the caller asks for a particular alignment we
shouldn't reduce it. Should put it in another patch.
Thanks,
Nick
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox