arch/x86/xen/multicalls.c

   1 /*
   2  * Xen hypercall batching.
   3  *
   4  * Xen allows multiple hypercalls to be issued at once, using the
   5  * multicall interface.  This allows the cost of trapping into the
   6  * hypervisor to be amortized over several calls.
   7  *
   8  * This file implements a simple interface for multicalls.  There's a
   9  * per-cpu buffer of outstanding multicalls.  When you want to queue a
  10  * multicall for issuing, you can allocate a multicall slot for the
  11  * call and its arguments, along with storage for space which is
  12  * pointed to by the arguments (for passing pointers to structures,
  13  * etc).  When the multicall is actually issued, all the space for the
  14  * commands and allocated memory is freed for reuse.
  15  *
  16  * Multicalls are flushed whenever any of the buffers get full, or
  17  * when explicitly requested.  There's no way to get per-multicall
  18  * return results back.  It will BUG if any of the multicalls fail.
  19  *
  20  * Jeremy Fitzhardinge <jeremy@xensource.com>, XenSource Inc, 2007
  21  */
  22 #include <linux/percpu.h>
  23 #include <linux/hardirq.h>
  24 #include <linux/debugfs.h>
  25
  26 #include <asm/xen/hypercall.h>
  27
  28 #include "multicalls.h"
  29 #include "debugfs.h"
  30
  31 #define MC_BATCH        32
  32
  33 #define MC_DEBUG        1
  34
  35 #define MC_ARGS         (MC_BATCH * 16)
  36
  37
  38 struct mc_buffer {
  39         struct multicall_entry entries[MC_BATCH];
  40 #if MC_DEBUG
  41         struct multicall_entry debug[MC_BATCH];
  42         void *caller[MC_BATCH];
  43 #endif
  44         unsigned char args[MC_ARGS];
  45         struct callback {
  46                 void (*fn)(void *);
  47                 void *data;
  48         } callbacks[MC_BATCH];
  49         unsigned mcidx, argidx, cbidx;
  50 };
  51
  52 static DEFINE_PER_CPU(struct mc_buffer, mc_buffer);
  53 DEFINE_PER_CPU(unsigned long, xen_mc_irq_flags);
  54
  55 /* flush reasons 0- slots, 1- args, 2- callbacks */
  56 enum flush_reasons
  57 {
  58         FL_SLOTS,
  59         FL_ARGS,
  60         FL_CALLBACKS,
  61
  62         FL_N_REASONS
  63 };
  64
  65 #ifdef CONFIG_XEN_DEBUG_FS
  66 #define NHYPERCALLS     40              /* not really */
  67
  68 static struct {
  69         unsigned histo[MC_BATCH+1];
  70
  71         unsigned issued;
  72         unsigned arg_total;
  73         unsigned hypercalls;
  74         unsigned histo_hypercalls[NHYPERCALLS];
  75
  76         unsigned flush[FL_N_REASONS];
  77 } mc_stats;
  78
  79 static u8 zero_stats;
  80
  81 static inline void check_zero(void)
  82 {
  83         if (unlikely(zero_stats)) {
  84                 memset(&mc_stats, 0, sizeof(mc_stats));
  85                 zero_stats = 0;
  86         }
  87 }
  88
  89 static void mc_add_stats(const struct mc_buffer *mc)
  90 {
  91         int i;
  92
  93         check_zero();
  94
  95         mc_stats.issued++;
  96         mc_stats.hypercalls += mc->mcidx;
  97         mc_stats.arg_total += mc->argidx;
  98
  99         mc_stats.histo[mc->mcidx]++;
 100         for(i = 0; i < mc->mcidx; i++) {
 101                 unsigned op = mc->entries[i].op;
 102                 if (op < NHYPERCALLS)
 103                         mc_stats.histo_hypercalls[op]++;
 104         }
 105 }
 106
 107 static void mc_stats_flush(enum flush_reasons idx)
 108 {
 109         check_zero();
 110
 111         mc_stats.flush[idx]++;
 112 }
 113
 114 #else  /* !CONFIG_XEN_DEBUG_FS */
 115
 116 static inline void mc_add_stats(const struct mc_buffer *mc)
 117 {
 118 }
 119
 120 static inline void mc_stats_flush(enum flush_reasons idx)
 121 {
 122 }
 123 #endif  /* CONFIG_XEN_DEBUG_FS */
 124
 125 void xen_mc_flush(void)
 126 {
 127         struct mc_buffer *b = &__get_cpu_var(mc_buffer);
 128         int ret = 0;
 129         unsigned long flags;
 130         int i;
 131
 132         BUG_ON(preemptible());
 133
 134         /* Disable interrupts in case someone comes in and queues
 135            something in the middle */
 136         local_irq_save(flags);
 137
 138         mc_add_stats(b);
 139
 140         if (b->mcidx) {
 141 #if MC_DEBUG
 142                 memcpy(b->debug, b->entries,
 143                        b->mcidx * sizeof(struct multicall_entry));
 144 #endif
 145
 146                 if (HYPERVISOR_multicall(b->entries, b->mcidx) != 0)
 147                         BUG();
 148                 for (i = 0; i < b->mcidx; i++)
 149                         if (b->entries[i].result < 0)
 150                                 ret++;
 151
 152 #if MC_DEBUG
 153                 if (ret) {
 154                         printk(KERN_ERR "%d multicall(s) failed: cpu %d\n",
 155                                ret, smp_processor_id());
 156                         dump_stack();
 157                         for (i = 0; i < b->mcidx; i++) {
 158                                 printk(KERN_DEBUG "  call %2d/%d: op=%lu arg=[%lx] result=%ld\t%pF\n",
 159                                        i+1, b->mcidx,
 160                                        b->debug[i].op,
 161                                        b->debug[i].args[0],
 162                                        b->entries[i].result,
 163                                        b->caller[i]);
 164                         }
 165                 }
 166 #endif
 167
 168                 b->mcidx = 0;
 169                 b->argidx = 0;
 170         } else
 171                 BUG_ON(b->argidx != 0);
 172
 173         for (i = 0; i < b->cbidx; i++) {
 174                 struct callback *cb = &b->callbacks[i];
 175
 176                 (*cb->fn)(cb->data);
 177         }
 178         b->cbidx = 0;
 179
 180         local_irq_restore(flags);
 181
 182         WARN_ON(ret);
 183 }
 184
 185 struct multicall_space __xen_mc_entry(size_t args)
 186 {
 187         struct mc_buffer *b = &__get_cpu_var(mc_buffer);
 188         struct multicall_space ret;
 189         unsigned argidx = roundup(b->argidx, sizeof(u64));
 190
 191         BUG_ON(preemptible());
 192         BUG_ON(b->argidx > MC_ARGS);
 193
 194         if (b->mcidx == MC_BATCH ||
 195             (argidx + args) > MC_ARGS) {
 196                 mc_stats_flush(b->mcidx == MC_BATCH ? FL_SLOTS : FL_ARGS);
 197                 xen_mc_flush();
 198                 argidx = roundup(b->argidx, sizeof(u64));
 199         }
 200
 201         ret.mc = &b->entries[b->mcidx];
 202 #ifdef MC_DEBUG
 203         b->caller[b->mcidx] = __builtin_return_address(0);
 204 #endif
 205         b->mcidx++;
 206         ret.args = &b->args[argidx];
 207         b->argidx = argidx + args;
 208
 209         BUG_ON(b->argidx > MC_ARGS);
 210         return ret;
 211 }
 212
 213 struct multicall_space xen_mc_extend_args(unsigned long op, size_t size)
 214 {
 215         struct mc_buffer *b = &__get_cpu_var(mc_buffer);
 216         struct multicall_space ret = { NULL, NULL };
 217
 218         BUG_ON(preemptible());
 219         BUG_ON(b->argidx > MC_ARGS);
 220
 221         if (b->mcidx == 0)
 222                 return ret;
 223
 224         if (b->entries[b->mcidx - 1].op != op)
 225                 return ret;
 226
 227         if ((b->argidx + size) > MC_ARGS)
 228                 return ret;
 229
 230         ret.mc = &b->entries[b->mcidx - 1];
 231         ret.args = &b->args[b->argidx];
 232         b->argidx += size;
 233
 234         BUG_ON(b->argidx > MC_ARGS);
 235         return ret;
 236 }
 237
 238 void xen_mc_callback(void (*fn)(void *), void *data)
 239 {
 240         struct mc_buffer *b = &__get_cpu_var(mc_buffer);
 241         struct callback *cb;
 242
 243         if (b->cbidx == MC_BATCH) {
 244                 mc_stats_flush(FL_CALLBACKS);
 245                 xen_mc_flush();
 246         }
 247
 248         cb = &b->callbacks[b->cbidx++];
 249         cb->fn = fn;
 250         cb->data = data;
 251 }
 252
 253 #ifdef CONFIG_XEN_DEBUG_FS
 254
 255 static struct dentry *d_mc_debug;
 256
 257 static int __init xen_mc_debugfs(void)
 258 {
 259         struct dentry *d_xen = xen_init_debugfs();
 260
 261         if (d_xen == NULL)
 262                 return -ENOMEM;
 263
 264         d_mc_debug = debugfs_create_dir("multicalls", d_xen);
 265
 266         debugfs_create_u8("zero_stats", 0644, d_mc_debug, &zero_stats);
 267
 268         debugfs_create_u32("batches", 0444, d_mc_debug, &mc_stats.issued);
 269         debugfs_create_u32("hypercalls", 0444, d_mc_debug, &mc_stats.hypercalls);
 270         debugfs_create_u32("arg_total", 0444, d_mc_debug, &mc_stats.arg_total);
 271
 272         xen_debugfs_create_u32_array("batch_histo", 0444, d_mc_debug,
 273                                      mc_stats.histo, MC_BATCH);
 274         xen_debugfs_create_u32_array("hypercall_histo", 0444, d_mc_debug,
 275                                      mc_stats.histo_hypercalls, NHYPERCALLS);
 276         xen_debugfs_create_u32_array("flush_reasons", 0444, d_mc_debug,
 277                                      mc_stats.flush, FL_N_REASONS);
 278
 279         return 0;
 280 }
 281 fs_initcall(xen_mc_debugfs);
 282
 283 #endif  /* CONFIG_XEN_DEBUG_FS */