arch/arm64/kvm/ptdump.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Debug helper used to dump the stage-2 pagetables of the system and their
   4  * associated permissions.
   5  *
   6  * Copyright (C) Google, 2024
   7  * Author: Sebastian Ene <sebastianene@google.com>
   8  */
   9 #include <linux/debugfs.h>
  10 #include <linux/kvm_host.h>
  11 #include <linux/seq_file.h>
  12
  13 #include <asm/kvm_mmu.h>
  14 #include <asm/kvm_pgtable.h>
  15 #include <asm/ptdump.h>
  16
  17 #define MARKERS_LEN             2
  18 #define KVM_PGTABLE_MAX_LEVELS  (KVM_PGTABLE_LAST_LEVEL + 1)
  19
  20 struct kvm_ptdump_guest_state {
  21         struct kvm              *kvm;
  22         struct ptdump_pg_state  parser_state;
  23         struct addr_marker      ipa_marker[MARKERS_LEN];
  24         struct ptdump_pg_level  level[KVM_PGTABLE_MAX_LEVELS];
  25         struct ptdump_range     range[MARKERS_LEN];
  26 };
  27
  28 static const struct ptdump_prot_bits stage2_pte_bits[] = {
  29         {
  30                 .mask   = PTE_VALID,
  31                 .val    = PTE_VALID,
  32                 .set    = " ",
  33                 .clear  = "F",
  34         }, {
  35                 .mask   = KVM_PTE_LEAF_ATTR_LO_S2_S2AP_R | PTE_VALID,
  36                 .val    = KVM_PTE_LEAF_ATTR_LO_S2_S2AP_R | PTE_VALID,
  37                 .set    = "R",
  38                 .clear  = " ",
  39         }, {
  40                 .mask   = KVM_PTE_LEAF_ATTR_LO_S2_S2AP_W | PTE_VALID,
  41                 .val    = KVM_PTE_LEAF_ATTR_LO_S2_S2AP_W | PTE_VALID,
  42                 .set    = "W",
  43                 .clear  = " ",
  44         }, {
  45                 .mask   = KVM_PTE_LEAF_ATTR_HI_S2_XN | PTE_VALID,
  46                 .val    = PTE_VALID,
  47                 .set    = " ",
  48                 .clear  = "X",
  49         }, {
  50                 .mask   = KVM_PTE_LEAF_ATTR_LO_S2_AF | PTE_VALID,
  51                 .val    = KVM_PTE_LEAF_ATTR_LO_S2_AF | PTE_VALID,
  52                 .set    = "AF",
  53                 .clear  = "  ",
  54         }, {
  55                 .mask   = PTE_TABLE_BIT | PTE_VALID,
  56                 .val    = PTE_VALID,
  57                 .set    = "BLK",
  58                 .clear  = "   ",
  59         },
  60 };
  61
  62 static int kvm_ptdump_visitor(const struct kvm_pgtable_visit_ctx *ctx,
  63                               enum kvm_pgtable_walk_flags visit)
  64 {
  65         struct ptdump_pg_state *st = ctx->arg;
  66         struct ptdump_state *pt_st = &st->ptdump;
  67
  68         note_page(pt_st, ctx->addr, ctx->level, ctx->old);
  69
  70         return 0;
  71 }
  72
  73 static int kvm_ptdump_build_levels(struct ptdump_pg_level *level, u32 start_lvl)
  74 {
  75         u32 i;
  76         u64 mask;
  77
  78         if (WARN_ON_ONCE(start_lvl >= KVM_PGTABLE_LAST_LEVEL))
  79                 return -EINVAL;
  80
  81         mask = 0;
  82         for (i = 0; i < ARRAY_SIZE(stage2_pte_bits); i++)
  83                 mask |= stage2_pte_bits[i].mask;
  84
  85         for (i = start_lvl; i < KVM_PGTABLE_MAX_LEVELS; i++) {
  86                 snprintf(level[i].name, sizeof(level[i].name), "%u", i);
  87
  88                 level[i].num    = ARRAY_SIZE(stage2_pte_bits);
  89                 level[i].bits   = stage2_pte_bits;
  90                 level[i].mask   = mask;
  91         }
  92
  93         return 0;
  94 }
  95
  96 static struct kvm_ptdump_guest_state *kvm_ptdump_parser_create(struct kvm *kvm)
  97 {
  98         struct kvm_ptdump_guest_state *st;
  99         struct kvm_s2_mmu *mmu = &kvm->arch.mmu;
 100         struct kvm_pgtable *pgtable = mmu->pgt;
 101         int ret;
 102
 103         st = kzalloc(sizeof(struct kvm_ptdump_guest_state), GFP_KERNEL_ACCOUNT);
 104         if (!st)
 105                 return ERR_PTR(-ENOMEM);
 106
 107         ret = kvm_ptdump_build_levels(&st->level[0], pgtable->start_level);
 108         if (ret) {
 109                 kfree(st);
 110                 return ERR_PTR(ret);
 111         }
 112
 113         st->ipa_marker[0].name          = "Guest IPA";
 114         st->ipa_marker[1].start_address = BIT(pgtable->ia_bits);
 115         st->range[0].end                = BIT(pgtable->ia_bits);
 116
 117         st->kvm                         = kvm;
 118         st->parser_state = (struct ptdump_pg_state) {
 119                 .marker         = &st->ipa_marker[0],
 120                 .level          = -1,
 121                 .pg_level       = &st->level[0],
 122                 .ptdump.range   = &st->range[0],
 123                 .start_address  = 0,
 124         };
 125
 126         return st;
 127 }
 128
 129 static int kvm_ptdump_guest_show(struct seq_file *m, void *unused)
 130 {
 131         int ret;
 132         struct kvm_ptdump_guest_state *st = m->private;
 133         struct kvm *kvm = st->kvm;
 134         struct kvm_s2_mmu *mmu = &kvm->arch.mmu;
 135         struct ptdump_pg_state *parser_state = &st->parser_state;
 136         struct kvm_pgtable_walker walker = (struct kvm_pgtable_walker) {
 137                 .cb     = kvm_ptdump_visitor,
 138                 .arg    = parser_state,
 139                 .flags  = KVM_PGTABLE_WALK_LEAF,
 140         };
 141
 142         parser_state->seq = m;
 143
 144         write_lock(&kvm->mmu_lock);
 145         ret = kvm_pgtable_walk(mmu->pgt, 0, BIT(mmu->pgt->ia_bits), &walker);
 146         write_unlock(&kvm->mmu_lock);
 147
 148         return ret;
 149 }
 150
 151 static int kvm_ptdump_guest_open(struct inode *m, struct file *file)
 152 {
 153         struct kvm *kvm = m->i_private;
 154         struct kvm_ptdump_guest_state *st;
 155         int ret;
 156
 157         if (!kvm_get_kvm_safe(kvm))
 158                 return -ENOENT;
 159
 160         st = kvm_ptdump_parser_create(kvm);
 161         if (IS_ERR(st)) {
 162                 ret = PTR_ERR(st);
 163                 goto err_with_kvm_ref;
 164         }
 165
 166         ret = single_open(file, kvm_ptdump_guest_show, st);
 167         if (!ret)
 168                 return 0;
 169
 170         kfree(st);
 171 err_with_kvm_ref:
 172         kvm_put_kvm(kvm);
 173         return ret;
 174 }
 175
 176 static int kvm_ptdump_guest_close(struct inode *m, struct file *file)
 177 {
 178         struct kvm *kvm = m->i_private;
 179         void *st = ((struct seq_file *)file->private_data)->private;
 180
 181         kfree(st);
 182         kvm_put_kvm(kvm);
 183
 184         return single_release(m, file);
 185 }
 186
 187 static const struct file_operations kvm_ptdump_guest_fops = {
 188         .open           = kvm_ptdump_guest_open,
 189         .read           = seq_read,
 190         .llseek         = seq_lseek,
 191         .release        = kvm_ptdump_guest_close,
 192 };
 193
 194 static int kvm_pgtable_range_show(struct seq_file *m, void *unused)
 195 {
 196         struct kvm_pgtable *pgtable = m->private;
 197
 198         seq_printf(m, "%2u\n", pgtable->ia_bits);
 199         return 0;
 200 }
 201
 202 static int kvm_pgtable_levels_show(struct seq_file *m, void *unused)
 203 {
 204         struct kvm_pgtable *pgtable = m->private;
 205
 206         seq_printf(m, "%1d\n", KVM_PGTABLE_MAX_LEVELS - pgtable->start_level);
 207         return 0;
 208 }
 209
 210 static int kvm_pgtable_debugfs_open(struct inode *m, struct file *file,
 211                                     int (*show)(struct seq_file *, void *))
 212 {
 213         struct kvm *kvm = m->i_private;
 214         struct kvm_pgtable *pgtable;
 215         int ret;
 216
 217         if (!kvm_get_kvm_safe(kvm))
 218                 return -ENOENT;
 219
 220         pgtable = kvm->arch.mmu.pgt;
 221
 222         ret = single_open(file, show, pgtable);
 223         if (ret < 0)
 224                 kvm_put_kvm(kvm);
 225         return ret;
 226 }
 227
 228 static int kvm_pgtable_range_open(struct inode *m, struct file *file)
 229 {
 230         return kvm_pgtable_debugfs_open(m, file, kvm_pgtable_range_show);
 231 }
 232
 233 static int kvm_pgtable_levels_open(struct inode *m, struct file *file)
 234 {
 235         return kvm_pgtable_debugfs_open(m, file, kvm_pgtable_levels_show);
 236 }
 237
 238 static int kvm_pgtable_debugfs_close(struct inode *m, struct file *file)
 239 {
 240         struct kvm *kvm = m->i_private;
 241
 242         kvm_put_kvm(kvm);
 243         return single_release(m, file);
 244 }
 245
 246 static const struct file_operations kvm_pgtable_range_fops = {
 247         .open           = kvm_pgtable_range_open,
 248         .read           = seq_read,
 249         .llseek         = seq_lseek,
 250         .release        = kvm_pgtable_debugfs_close,
 251 };
 252
 253 static const struct file_operations kvm_pgtable_levels_fops = {
 254         .open           = kvm_pgtable_levels_open,
 255         .read           = seq_read,
 256         .llseek         = seq_lseek,
 257         .release        = kvm_pgtable_debugfs_close,
 258 };
 259
 260 void kvm_s2_ptdump_create_debugfs(struct kvm *kvm)
 261 {
 262         debugfs_create_file("stage2_page_tables", 0400, kvm->debugfs_dentry,
 263                             kvm, &kvm_ptdump_guest_fops);
 264         debugfs_create_file("ipa_range", 0400, kvm->debugfs_dentry, kvm,
 265                             &kvm_pgtable_range_fops);
 266         debugfs_create_file("stage2_levels", 0400, kvm->debugfs_dentry,
 267                             kvm, &kvm_pgtable_levels_fops);
 268 }