src/plugins/perfmon/arm/dispatch_wrapper.c

   1 /*
   2  * Copyright (c) 2022 Arm and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vnet/vnet.h>
  17
  18 #include <vlibapi/api.h>
  19 #include <vlibmemory/api.h>
  20 #include <vnet/plugin/plugin.h>
  21 #include <vpp/app/version.h>
  22 #include <linux/limits.h>
  23 #include <sys/ioctl.h>
  24
  25 #include <perfmon/perfmon.h>
  26
  27 #define barrier() asm volatile("dmb ish" : : : "memory");
  28
  29 typedef int64_t s64;
  30
  31 static_always_inline u64
  32 get_pmc_register (u32 pmc_idx)
  33 {
  34   u64 value = 0;
  35   if (pmc_idx == 31)
  36     /* i.e. CPU Cycle event code 0x11 - need to read via pmccntr_el0 */
  37     asm volatile("mrs %x0, pmccntr_el0" : "=r"(value));
  38   else
  39     {
  40       /* set event register 0x0-0x1F */
  41       asm volatile("msr pmselr_el0, %x0" : : "r"((pmc_idx)));
  42       /* get register value */
  43       asm volatile("mrs %x0, pmxevcntr_el0" : "=r"(value));
  44     }
  45   asm volatile("isb" : : : "memory");
  46   return value;
  47 }
  48
  49 static_always_inline u64
  50 read_pmc_from_mmap (struct perf_event_mmap_page *pc)
  51 {
  52   u32 seq, idx, width;
  53   u64 offset = 0;
  54   s64 pmc = 0;
  55
  56   do
  57     {
  58       seq = pc->lock;
  59       barrier ();
  60       idx = pc->index;
  61       offset = pc->offset;
  62       if (pc->cap_user_rdpmc && idx)
  63         {
  64           width = pc->pmc_width;
  65           pmc = get_pmc_register (idx - 1);
  66           /* for 32 bit regs, left shift 32b to zero/discard the top bits */
  67           pmc <<= 64 - width;
  68           pmc >>= 64 - width;
  69         }
  70       barrier ();
  71     }
  72   while (pc->lock != seq);
  73
  74   return pmc + offset;
  75 }
  76
  77 static_always_inline void
  78 perfmon_read_pmcs (u64 *counters, perfmon_thread_runtime_t *rt, u8 n_counters)
  79 {
  80   switch (n_counters)
  81     {
  82     default:
  83     case 7:
  84       counters[6] = read_pmc_from_mmap (rt->mmap_pages[6]);
  85     case 6:
  86       counters[5] = read_pmc_from_mmap (rt->mmap_pages[5]);
  87     case 5:
  88       counters[4] = read_pmc_from_mmap (rt->mmap_pages[4]);
  89     case 4:
  90       counters[3] = read_pmc_from_mmap (rt->mmap_pages[3]);
  91     case 3:
  92       counters[2] = read_pmc_from_mmap (rt->mmap_pages[2]);
  93     case 2:
  94       counters[1] = read_pmc_from_mmap (rt->mmap_pages[1]);
  95     case 1:
  96       counters[0] = read_pmc_from_mmap (rt->mmap_pages[0]);
  97       break;
  98     }
  99 }
 100
 101 uword
 102 perfmon_dispatch_wrapper (vlib_main_t *vm, vlib_node_runtime_t *node,
 103                           vlib_frame_t *frame)
 104 {
 105   perfmon_main_t *pm = &perfmon_main;
 106   perfmon_thread_runtime_t *rt =
 107     vec_elt_at_index (pm->thread_runtimes, vm->thread_index);
 108   perfmon_node_stats_t *s =
 109     vec_elt_at_index (rt->node_stats, node->node_index);
 110   u8 n_events = rt->n_events;
 111   u64 before[n_events];
 112   u64 after[n_events];
 113
 114   uword rv;
 115
 116   clib_prefetch_load (s);
 117
 118   perfmon_read_pmcs (before, rt, n_events);
 119   rv = node->function (vm, node, frame);
 120   perfmon_read_pmcs (after, rt, n_events);
 121
 122   if (rv == 0)
 123     return rv;
 124
 125   s->n_calls += 1;
 126   s->n_packets += rv;
 127
 128   for (int i = 0; i < n_events; i++)
 129     {
 130       s->value[i] += after[i] - before[i];
 131     }
 132
 133   return rv;
 134 }
 135
 136 clib_error_t *
 137 arm_config_dispatch_wrapper (perfmon_bundle_t *b,
 138                              vlib_node_function_t **dispatch_wrapper)
 139 {
 140   (*dispatch_wrapper) = perfmon_dispatch_wrapper;
 141   return 0;
 142 }