NULL))
                        pr_err("Failed to register fpu interrupt\n");
                desc_fpu = irq_to_desc(irq_fpu);
-               fpu_kstat_irq = this_cpu_ptr(desc_fpu->kstat_irqs);
+               fpu_kstat_irq = this_cpu_ptr(&desc_fpu->kstat_irqs->cnt);
        }
        if (dec_interrupt[DEC_IRQ_CASCADE] >= 0) {
                if (request_irq(dec_interrupt[DEC_IRQ_CASCADE], no_action,
 
                struct irq_desc *desc = irq_to_desc(i);
 
                if (desc && desc->kstat_irqs)
-                       *per_cpu_ptr(desc->kstat_irqs, cpuid) = 0;
+                       *per_cpu_ptr(desc->kstat_irqs, cpuid) = (struct irqstat) { };
        }
 #endif
 
 
  */
 static void kvmppc_rm_handle_irq_desc(struct irq_desc *desc)
 {
-       this_cpu_inc_rm(desc->kstat_irqs);
+       this_cpu_inc_rm(&desc->kstat_irqs->cnt);
        __this_cpu_inc(kstat.irqs_sum);
 }
 
 
 struct irq_domain;
 struct pt_regs;
 
+/**
+ * struct irqstat - interrupt statistics
+ * @cnt:       real-time interrupt count
+ */
+struct irqstat {
+       unsigned int    cnt;
+};
+
 /**
  * struct irq_desc - interrupt descriptor
  * @irq_common_data:   per irq and chip data passed down to chip functions
 struct irq_desc {
        struct irq_common_data  irq_common_data;
        struct irq_data         irq_data;
-       unsigned int __percpu   *kstat_irqs;
+       struct irqstat __percpu *kstat_irqs;
        irq_flow_handler_t      handle_irq;
        struct irqaction        *action;        /* IRQ action list */
        unsigned int            status_use_accessors;
 static inline unsigned int irq_desc_kstat_cpu(struct irq_desc *desc,
                                              unsigned int cpu)
 {
-       return desc->kstat_irqs ? *per_cpu_ptr(desc->kstat_irqs, cpu) : 0;
+       return desc->kstat_irqs ? per_cpu(desc->kstat_irqs->cnt, cpu) : 0;
 }
 
 static inline struct irq_desc *irq_data_to_desc(struct irq_data *data)
 
 
 static inline void __kstat_incr_irqs_this_cpu(struct irq_desc *desc)
 {
-       __this_cpu_inc(*desc->kstat_irqs);
+       __this_cpu_inc(desc->kstat_irqs->cnt);
        __this_cpu_inc(kstat.irqs_sum);
 }
 
 
        desc->name = NULL;
        desc->owner = owner;
        for_each_possible_cpu(cpu)
-               *per_cpu_ptr(desc->kstat_irqs, cpu) = 0;
+               *per_cpu_ptr(desc->kstat_irqs, cpu) = (struct irqstat) { };
        desc_smp_init(desc, node, affinity);
 }
 
                     const struct cpumask *affinity,
                     struct module *owner)
 {
-       desc->kstat_irqs = alloc_percpu(unsigned int);
+       desc->kstat_irqs = alloc_percpu(struct irqstat);
        if (!desc->kstat_irqs)
                return -ENOMEM;
 
 {
        struct irq_desc *desc = irq_to_desc(irq);
 
-       return desc && desc->kstat_irqs ?
-                       *per_cpu_ptr(desc->kstat_irqs, cpu) : 0;
+       return desc && desc->kstat_irqs ? per_cpu(desc->kstat_irqs->cnt, cpu) : 0;
 }
 
 static bool irq_is_nmi(struct irq_desc *desc)
                return data_race(desc->tot_count);
 
        for_each_possible_cpu(cpu)
-               sum += data_race(*per_cpu_ptr(desc->kstat_irqs, cpu));
+               sum += data_race(per_cpu(desc->kstat_irqs->cnt, cpu));
        return sum;
 }
 
 
 
        if (desc->kstat_irqs) {
                for_each_online_cpu(j)
-                       any_count |= data_race(*per_cpu_ptr(desc->kstat_irqs, j));
+                       any_count |= data_race(per_cpu(desc->kstat_irqs->cnt, j));
        }
 
        if ((!desc->action || irq_desc_is_chained(desc)) && !any_count)
 
        seq_printf(p, "%*d: ", prec, i);
        for_each_online_cpu(j)
-               seq_printf(p, "%10u ", desc->kstat_irqs ?
-                                       *per_cpu_ptr(desc->kstat_irqs, j) : 0);
+               seq_printf(p, "%10u ", desc->kstat_irqs ? per_cpu(desc->kstat_irqs->cnt, j) : 0);
 
        raw_spin_lock_irqsave(&desc->lock, flags);
        if (desc->irq_data.chip) {
 
     any_count = 0
     if desc['kstat_irqs']:
         for cpu in cpus.each_online_cpu():
-            any_count += cpus.per_cpu(desc['kstat_irqs'], cpu)
+            any_count += cpus.per_cpu(desc['kstat_irqs'], cpu)['cnt']
 
     if (desc['action'] == 0 or irq_desc_is_chained(desc)) and any_count == 0:
         return text;
     text += "%*d: " % (prec, irq)
     for cpu in cpus.each_online_cpu():
         if desc['kstat_irqs']:
-            count = cpus.per_cpu(desc['kstat_irqs'], cpu)
+            count = cpus.per_cpu(desc['kstat_irqs'], cpu)['cnt']
         else:
             count = 0
         text += "%10u" % (count)
         if desc == 0:
             continue
         for cpu in cpus.each_online_cpu():
-            text += "%10u" % (cpus.per_cpu(desc['kstat_irqs'], cpu))
+            text += "%10u" % (cpus.per_cpu(desc['kstat_irqs'], cpu)['cnt'])
         text += "      %s" % (ipi_types[ipi].string())
         text += "\n"
     return text