KVM: Clean up and extend rate-limited output

The use of printk_ratelimit is discouraged, replace it with
pr*_ratelimited or __ratelimit. While at it, convert remaining
guest-triggerable printks to rate-limited variants.

Signed-off-by: Jan Kiszka <jan.kiszka@siemens.com>
Signed-off-by: Marcelo Tosatti <mtosatti@redhat.com>

3 files changed, 17 insertions, 17 deletions

diff --git a/arch/x86/kvm/i8259.c b/arch/x86/kvm/i8259.c
index 6b869ce0cc19..cac4746d7ffb 100644
--- a/arch/x86/kvm/i8259.c
+++ b/arch/x86/kvm/i8259.c
@@ -34,6 +34,9 @@
 #include <linux/kvm_host.h>
 #include "trace.h"
 
+#define pr_pic_unimpl(fmt, ...) \
+        pr_err_ratelimited("kvm: pic: " fmt, ## __VA_ARGS__)
+
 static void pic_irq_request(struct kvm *kvm, int level);
 
 static void pic_lock(struct kvm_pic *s)
@@ -306,10 +309,10 @@ static void pic_ioport_write(void *opaque, u32 addr, u32 val)
                         }
                         s->init_state = 1;
                         if (val & 0x02)
-                                printk(KERN_ERR "single mode not supported");
+                                pr_pic_unimpl("single mode not supported");
                         if (val & 0x08)
-                                printk(KERN_ERR
-                                       "level sensitive irq not supported");
+                                pr_pic_unimpl(
+                                        "level sensitive irq not supported");
                 } else if (val & 0x08) {
                         if (val & 0x04)
                                 s->poll = 1;
@@ -467,8 +470,7 @@ static int picdev_write(struct kvm_pic *s,
                 return -EOPNOTSUPP;
 
         if (len != 1) {
-                if (printk_ratelimit())
-                        printk(KERN_ERR "PIC: non byte write\n");
+                pr_pic_unimpl("non byte write\n");
                 return 0;
         }
         pic_lock(s);
@@ -496,8 +498,7 @@ static int picdev_read(struct kvm_pic *s,
                 return -EOPNOTSUPP;
 
         if (len != 1) {
-                if (printk_ratelimit())
-                        printk(KERN_ERR "PIC: non byte read\n");
+                pr_pic_unimpl("non byte read\n");
                 return 0;
         }
         pic_lock(s);
diff --git a/arch/x86/kvm/mmu_audit.c b/arch/x86/kvm/mmu_audit.c
index 2460a265be23..746ec259d024 100644
--- a/arch/x86/kvm/mmu_audit.c
+++ b/arch/x86/kvm/mmu_audit.c
@@ -121,16 +121,16 @@ static void audit_mappings(struct kvm_vcpu *vcpu, u64 *sptep, int level)
 
 static void inspect_spte_has_rmap(struct kvm *kvm, u64 *sptep)
 {
+        static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);
         unsigned long *rmapp;
         struct kvm_mmu_page *rev_sp;
         gfn_t gfn;
 
-
         rev_sp = page_header(__pa(sptep));
         gfn = kvm_mmu_page_get_gfn(rev_sp, sptep - rev_sp->spt);
 
         if (!gfn_to_memslot(kvm, gfn)) {
-                if (!printk_ratelimit())
+                if (!__ratelimit(&ratelimit_state))
                         return;
                 audit_printk(kvm, "no memslot for gfn %llx\n", gfn);
                 audit_printk(kvm, "index %ld of sp (gfn=%llx)\n",
@@ -141,7 +141,7 @@ static void inspect_spte_has_rmap(struct kvm *kvm, u64 *sptep)
 
         rmapp = gfn_to_rmap(kvm, gfn, rev_sp->role.level);
         if (!*rmapp) {
-                if (!printk_ratelimit())
+                if (!__ratelimit(&ratelimit_state))
                         return;
                 audit_printk(kvm, "no rmap for writable spte %llx\n",
                              *sptep);
diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c
index 21217b65b129..a0d6bd9ad442 100644
--- a/arch/x86/kvm/vmx.c
+++ b/arch/x86/kvm/vmx.c
@@ -2762,8 +2762,8 @@ static void enter_lmode(struct kvm_vcpu *vcpu)
 
         guest_tr_ar = vmcs_read32(GUEST_TR_AR_BYTES);
         if ((guest_tr_ar & AR_TYPE_MASK) != AR_TYPE_BUSY_64_TSS) {
-                printk(KERN_DEBUG "%s: tss fixup for long mode. \n",
-                       __func__);
+                pr_debug_ratelimited("%s: tss fixup for long mode. \n",
+                                     __func__);
                 vmcs_write32(GUEST_TR_AR_BYTES,
                              (guest_tr_ar & ~AR_TYPE_MASK)
                              | AR_TYPE_BUSY_64_TSS);
@@ -5634,8 +5634,8 @@ static bool nested_vmx_exit_handled(struct kvm_vcpu *vcpu)
                 return 0;
 
         if (unlikely(vmx->fail)) {
-                printk(KERN_INFO "%s failed vm entry %x\n",
-                       __func__, vmcs_read32(VM_INSTRUCTION_ERROR));
+                pr_info_ratelimited("%s failed vm entry %x\n", __func__,
+                                    vmcs_read32(VM_INSTRUCTION_ERROR));
                 return 1;
         }
 
@@ -6612,9 +6612,8 @@ static int nested_vmx_run(struct kvm_vcpu *vcpu, bool launch)
         if (vmcs12->vm_entry_msr_load_count > 0 ||
             vmcs12->vm_exit_msr_load_count > 0 ||
             vmcs12->vm_exit_msr_store_count > 0) {
-                if (printk_ratelimit())
-                        printk(KERN_WARNING
-                          "%s: VMCS MSR_{LOAD,STORE} unsupported\n", __func__);
+                pr_warn_ratelimited("%s: VMCS MSR_{LOAD,STORE} unsupported\n",
+                                    __func__);
                 nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_CONTROL_FIELD);
                 return 1;
         }