[DEB] userspace: Print component memory domain

Author: softwarecki

zephyr/include/rtos/userspace_helper.h

@@ -137,4 +137,14 @@ static inline int user_access_to_mailbox(struct k_mem_domain *domain, k_tid_t th
 
 #endif /* CONFIG_USERSPACE */
 
+void dump_memory_domain(struct k_mem_domain *domain);
+void dump_page_tables(uint32_t *ptables, void *test, bool kernel);
+void dump_page_table(uint32_t *ptables, void *test);
+void dump_domain_page_tables(struct k_mem_domain *domain, void *test, bool kernel);
+
+static inline void dump_domain_entry(struct k_mem_domain *domain, void *test)
+{
+	dump_page_tables(domain->arch.ptables, test, false);
+}
+
 #endif /* __ZEPHYR_LIB_USERSPACE_HELPER_H__ */

zephyr/lib/userspace_helper.c

@@ -27,13 +27,17 @@
 #include <zephyr/kernel.h>
 #include <zephyr/app_memory/app_memdomain.h>
 #include <zephyr/logging/log.h>
+#include <../../../../../zephyr/zephyr/arch/xtensa/include/xtensa_mmu_priv.h>
+#include <zephyr/arch/xtensa/xtensa_mmu.h>
 
 LOG_MODULE_REGISTER(userspace_helper, CONFIG_SOF_LOG_LEVEL);
 
 #if CONFIG_USERSPACE
 
 K_APPMEM_PARTITION_DEFINE(common_partition);
 
+extern struct tr_ctx userspace_proxy_tr;
+
 struct k_heap *module_driver_heap_init(void)
 {
 	struct k_heap *mod_drv_heap = rballoc(SOF_MEM_FLAG_USER, sizeof(*mod_drv_heap));
@@ -149,6 +153,171 @@ void user_grant_dma_access_all(struct k_thread *thread)
 
 #endif /* CONFIG_SOF_USERSPACE_LL */
 
+/** Mask for attributes in PTE */
+#define PTE_ATTR_MASK 0x0000000FU
+
+/** Number of bits to shift for attributes in PTE */
+#define PTE_ATTR_SHIFT 0U
+
+/** Mask for cache mode in PTE */
+#define PTE_ATTR_CACHED_MASK 0x0000000CU
+
+/** Mask for ring in PTE */
+#define PTE_RING_MASK 0x00000030U
+
+/** Number of bits to shift for ring in PTE */
+#define PTE_RING_SHIFT 4U
+
+/** Number of bits to shift for backup attributes in PTE SW field. */
+#define PTE_BCKUP_ATTR_SHIFT (PTE_ATTR_SHIFT + 6U)
+
+/** Mask for backup attributes in PTE SW field. */
+#define PTE_BCKUP_ATTR_MASK (PTE_ATTR_MASK << 6U)
+
+/** Number of bits to shift for backup ring value in PTE SW field. */
+#define PTE_BCKUP_RING_SHIFT (PTE_RING_SHIFT + 6U)
+
+/** Mask for backup ring value in PTE SW field. */
+#define PTE_BCKUP_RING_MASK (PTE_RING_MASK << 6U)
+
+/** Combined attributes and ring mask in PTE. */
+#define PTE_PERM_MASK (PTE_ATTR_MASK | PTE_RING_MASK)
+
+/** Number of bits to shift for combined attributes and ring in PTE. */
+#define PTE_PERM_SHIFT 0U
+
+/** Combined backup attributes and backup ring mask in PTE. */
+#define PTE_BCKUP_PERM_MASK (PTE_BCKUP_ATTR_MASK | PTE_BCKUP_RING_MASK)
+
+/** Number of bits to shift for combined backup attributes and backup ring mask in PTE. */
+#define PTE_BCKUP_PERM_SHIFT 6U
+
+#define PTE_ATTR_ILLEGAL (BIT(3) | BIT(2))
+
+/** Get the ring from a PTE */
+#define PTE_RING_GET(pte) (((pte) & PTE_RING_MASK) >> PTE_RING_SHIFT)
+
+/** Get the permissions from a PTE */
+#define PTE_PERM_GET(pte) (((pte) & PTE_PERM_MASK) >> PTE_PERM_SHIFT)
+
+/** Get the backup permissions from a PTE */
+#define PTE_BCKUP_PERM_GET(pte) (((pte) & PTE_BCKUP_PERM_MASK) >> PTE_BCKUP_PERM_SHIFT)
+
+/** Get the backed up attributes from the PTE SW field. */
+#define PTE_BCKUP_ATTR_GET(pte) (((pte) & PTE_BCKUP_ATTR_MASK) >> PTE_BCKUP_ATTR_SHIFT)
+
+/** Get the backed up ring value from the PTE SW field. */
+#define PTE_BCKUP_RING_GET(pte) (((pte) & PTE_BCKUP_RING_MASK) >> PTE_BCKUP_RING_SHIFT)
+
+static void dump_pte_attr(char *attr_s, uint32_t attr)
+{
+	attr_s[0] = attr & XTENSA_MMU_CACHED_WT ? 'T' : '-';
+	attr_s[1] = attr & XTENSA_MMU_CACHED_WB ? 'B' : '-';
+	attr_s[2] = attr & XTENSA_MMU_PERM_W ? 'W' : '-';
+	attr_s[3] = attr & XTENSA_MMU_PERM_X ? 'X' : '-';
+	attr_s[4] = '\0';
+}
+
+static uint32_t *dump_pte(uint32_t pte)
+{
+	uint32_t ppn = pte & XTENSA_MMU_PTE_PPN_MASK;
+	uint32_t ring = PTE_RING_GET(pte);
+	uint32_t sw = PTE_BCKUP_PERM_GET(pte);
+	uint32_t sw_ring = PTE_BCKUP_RING_GET(pte);
+	uint32_t sw_attr = PTE_BCKUP_ATTR_GET(pte);
+	uint32_t attr = PTE_PERM_GET(pte);
+
+	char attr_s[5];
+	dump_pte_attr(attr_s, attr);
+
+	char sw_attr_s[5];
+	dump_pte_attr(sw_attr_s, sw_attr);
+
+	tr_err(&userspace_proxy_tr, "PPN %#x, sw %#x (ring: %u, %s), ring %u %s",
+	       ppn, sw, sw_ring, sw_attr_s, ring, attr_s);
+
+	if ((attr & PTE_ATTR_ILLEGAL) == PTE_ATTR_ILLEGAL) {
+		//tr_err(&userspace_proxy_tr, "ILLEGAL PTE");
+		return NULL;
+	}
+
+	return (uint32_t *)ppn;
+}
+
+void dump_page_table(uint32_t *ptables, void *test)
+{
+	const uint32_t l1_index = XTENSA_MMU_L1_POS(POINTER_TO_UINT(test));
+	const uint32_t l2_index = XTENSA_MMU_L2_POS(POINTER_TO_UINT(test));
+	const uint32_t test_aligned = POINTER_TO_UINT(test) & ~(CONFIG_MMU_PAGE_SIZE - 1);
+
+	tr_err(&userspace_proxy_tr, "test %p, ptables = %p, L1 = %#x, L2 = %#x", test,
+	       (void *)ptables, l1_index, l2_index);
+
+	uint32_t *const l1_entry = ptables + l1_index;
+	//tr_err(&userspace_proxy_tr, "l1 @ %p = %p", (void *)l1_entry, *l1_entry);
+
+	uint32_t* l1_ppn = dump_pte(*l1_entry);
+	if (!l1_ppn) {
+		tr_err(&userspace_proxy_tr, "INVALID L1 PTE!");
+		return;
+	}
+
+	uint32_t *const l2_entry = l1_ppn + l2_index;
+	//tr_err(&userspace_proxy_tr, "l2 @ %p = %p", (void *)l2_entry, *l2_entry);
+	uint32_t *l2_ppn = dump_pte(*l2_entry);
+
+	if (test_aligned != POINTER_TO_UINT(l2_ppn)) {
+		tr_err(&userspace_proxy_tr, "INVALID L2 PTE!");
+		return;
+	}
+}
+
+extern uint32_t *xtensa_kernel_ptables;
+
+void dump_page_tables(uint32_t *ptables, void *test, bool kernel)
+{
+	if (ptables) {
+		tr_err(&userspace_proxy_tr, "Dump for %p in user table", test);
+		dump_page_table(ptables, sys_cache_cached_ptr_get(test));
+		dump_page_table(ptables, sys_cache_uncached_ptr_get(test));
+	}
+
+	if (kernel) {
+		tr_err(&userspace_proxy_tr, "Kernel table", test);
+		dump_page_table(xtensa_kernel_ptables, sys_cache_cached_ptr_get(test));
+		dump_page_table(xtensa_kernel_ptables, sys_cache_uncached_ptr_get(test));
+	}
+}
+
+void dump_domain_page_tables(struct k_mem_domain *domain, void *test, bool kernel)
+{
+	dump_page_tables(domain->arch.ptables, test, kernel);
+}
+
+static void dump_domain_attr(char *attr_s, uint32_t attr)
+{
+	attr_s[0] = attr & XTENSA_MMU_MAP_SHARED ? 'S' : '-';
+	attr_s[1] = K_MEM_PARTITION_IS_USER(attr) ? 'U' : '-';
+	dump_pte_attr(attr_s + 2, attr);
+}
+
+void dump_memory_domain(struct k_mem_domain *domain)
+{
+	int i;
+	char attrs[7];
+
+	for (i = 0; i < domain->num_partitions; i++) {
+		dump_domain_attr(attrs, domain->partitions[i].attr);
+
+		tr_err(&userspace_proxy_tr, "partitions[%d]: %p + %#zx %s", i,
+		       UINT_TO_POINTER(domain->partitions[i].start),
+		       domain->partitions[i].size, attrs);
+	}
+
+	tr_err(&userspace_proxy_tr, "ptables = %p, asid = %u, dirty = %u",
+	       (void *)domain->arch.ptables, domain->arch.asid, domain->arch.dirty);
+}
+
 #else /* CONFIG_USERSPACE */
 
 void *user_stack_allocate(size_t stack_size, uint32_t options)