Support packets in flight
[samplevnf.git] / VNFs / DPPD-PROX / cqm.c
1 /*
2 // Copyright (c) 2010-2017 Intel Corporation
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //     http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 */
16
17 #include <unistd.h>
18 #include <stdio.h>
19 #include <fcntl.h>
20
21 #include "msr.h"
22 #include "cqm.h"
23 #include "log.h"
24 #include "prox_cfg.h"
25
26 #define IA32_QM_EVTSEL          0xC8D
27 #define IA32_QM_CTR             0xC8E
28 #define IA32_QM_ASSOC           0xC8F
29 #define IA32_QM_L3CA_START      0xC90
30 #define IA32_QM_L3CA_END        0xD0F
31
32 #define L3_CACHE_OCCUPANCY              1
33 #define L3_TOTAL_EXTERNAL_BANDWIDTH     2
34 #define L3_LOCAL_EXTERNAL_BANDWIDTH     3
35
36 static struct rdt_features rdt_features;
37 static int cat_features = 0;
38
39 static int stat_core;
40
41 struct reg {
42         uint32_t eax;
43         uint32_t ebx;
44         uint32_t ecx;
45         uint32_t edx;
46 };
47
48 static void cpuid(struct reg* r, uint32_t a, uint32_t b, uint32_t c, uint32_t d)
49 {
50         asm volatile("cpuid"
51                      : "=a" (r->eax), "=b" (r->ebx), "=c" (r->ecx), "=d" (r->edx)
52                      : "a" (a), "b" (b), "c" (c), "d" (d));
53 }
54
55 void read_rdt_info(void)
56 {
57         struct reg r;
58         int i;
59         uint64_t tmp_rmid;
60         int rc;
61
62         cpuid(&r, 0x7, 0x0, 0x0, 0x0);
63         if ((r.ebx >> 12) & 1) {
64                 plog_info("\tRDT-M. Supports Intel RDT Monitoring capability\n");
65                 rdt_features.rdtm_supported = 1;
66         } else {
67                 plog_info("\tDoes not support Intel RDT Monitoring capability\n");
68                 return;
69         }
70         if ((r.ebx >> 15) & 1) {
71                 plog_info("\tRDT-A. Supports Intel RDT Allocation capability\n");
72                 rdt_features.rdta_supported = 1;
73         } else {
74                 plog_info("\tDoes not support Intel RDT Allocation capability\n");
75         }
76
77         cpuid(&r, 0xf, 0x0, 0x0, 0x0);
78         if ((r.edx >> 1) & 1) {
79                 plog_info("\tSupports L3 Cache Intel RDT Monitoring\n");
80                 rdt_features.cmt_supported = 1;
81         }
82         plog_info("\tIntel RDT Monitoring has %d maximum RMID\n", r.ebx);
83         rdt_features.rdtm_max_rmid = r.ebx;
84
85         cpuid(&r, 0xf, 0x0, 0x1, 0x0);
86         if ((r.edx >> 0) & 1) {
87                 plog_info("\tSupports L3 occupancy monitoring\n");
88                 rdt_features.cmt_supported = 1;
89         }
90         if ((r.edx >> 1) & 1) {
91                 plog_info("\tSupports L3 Total bandwidth monitoring\n");
92                 rdt_features.mbm_tot_supported = 1;
93         }
94         if ((r.edx >> 2) & 1) {
95                 plog_info("\tSupports L3 Local bandwidth monitoring\n");
96                 rdt_features.mbm_loc_supported = 1;
97         }
98         rdt_features.cmt_max_rmid = r.ecx;
99         rdt_features.upscaling_factor = r.ebx;
100         rdt_features.event_types = r.edx;
101
102         plog_info("\tL3 Cache Intel RDT Monitoring Capability has %d maximum RMID\n", r.ecx);
103         plog_info("\tUpscaling_factor = %d\n", rdt_features.upscaling_factor);
104
105         cpuid(&r, 0x10, 0x0, 0x0, 0x0);
106         if ((r.ebx >> 1) & 1) {
107                 plog_info("\tSupports L3 Cache Allocation Technology\n");
108                 rdt_features.l3_cat_supported = 1;
109         }
110         if ((r.ebx >> 2) & 1) {
111                 plog_info("\tSupports L2 Cache Allocation Technology\n");
112                 rdt_features.l2_cat_supported = 1;
113         }
114         if ((r.ebx >> 3) & 1) {
115                 plog_info("\tSupports MBA Allocation Technology\n");
116                 rdt_features.mba_supported = 1;
117         }
118
119         cpuid(&r, 0x10, 0x0, 0x1, 0x0);
120         if ((r.ecx >> 2) & 1)
121                 plog_info("\tCode and Data Prioritization Technology supported\n");
122         plog_info("\tL3 Cache Allocation Technology Enumeration Highest COS number = %d\n", r.edx & 0xffff);
123         rdt_features.cat_max_rmid = r.edx & 0xffff;
124         rdt_features.cat_num_ways = r.eax + 1;
125
126         cpuid(&r, 0x10, 0x0, 0x2, 0x0);
127         plog_info("\tL2 Cache Allocation Technology Enumeration COS number = %d\n", r.edx & 0xffff);
128
129         cpuid(&r, 0x10, 0x0, 0x3, 0x0);
130         plog_info("\tMemory Bandwidth Allocation Enumeration COS number = %d\n", r.edx & 0xffff);
131         rdt_features.mba_max_rmid = r.ecx;
132 }
133 int mbm_is_supported(void)
134 {
135         return (rdt_features.rdtm_supported && rdt_features.mbm_tot_supported && rdt_features.mbm_loc_supported);
136 }
137
138 int mba_is_supported(void)
139 {
140         return (rdt_features.rdta_supported && rdt_features.mba_supported);
141 }
142
143 int cmt_is_supported(void)
144 {
145         if ((rdt_features.rdtm_supported || rdt_features.rdta_supported) && (prox_cfg.flags & DSF_DISABLE_CMT)) {
146                 rdt_features.rdtm_supported = rdt_features.rdta_supported  = 0;
147                 plog_info("cqm and cat features disabled by config file\n");
148         }
149         return (rdt_features.rdtm_supported && rdt_features.cmt_supported);
150 }
151
152 int cat_is_supported(void)
153 {
154         if ((rdt_features.rdtm_supported || rdt_features.rdta_supported) && (prox_cfg.flags & DSF_DISABLE_CMT)) {
155                 rdt_features.rdtm_supported = rdt_features.rdta_supported  = 0;
156                 plog_info("cqm and cat features disabled by config file\n");
157         }
158         return (rdt_features.rdta_supported && rdt_features.l3_cat_supported);
159 }
160
161 int rdt_is_supported(void)
162 {
163         return (cmt_is_supported() || cat_is_supported());
164 }
165
166 int rdt_get_features(struct rdt_features* feat)
167 {
168         if (!cmt_is_supported() && !cat_is_supported())
169                 return 1;
170
171         *feat = rdt_features;
172         return 0;
173 }
174
175 int cqm_assoc(uint8_t lcore_id, uint64_t rmid)
176 {
177         uint64_t val = 0;
178         int ret = 0;
179         ret = msr_read(&val, lcore_id, IA32_QM_ASSOC);
180         if (ret != 0) {
181                 plog_err("Unable to read msr %x on core %u\n", IA32_QM_ASSOC, lcore_id);
182         }
183         val &= 0x3FFULL;
184         plog_dbg("core %u, rmid was %lu, now setting to %lu\n", lcore_id, val, rmid);
185         val |= (uint64_t)(rmid & 0x3FFULL);
186         ret = msr_write(lcore_id, rmid, IA32_QM_ASSOC);
187         if (ret != 0) {
188                 plog_err("Unable to set msr %x on core %u to value %lx\n", IA32_QM_ASSOC, lcore_id, val);
189         }
190         return ret;
191 }
192
193 int cqm_assoc_read(uint8_t lcore_id, uint64_t *rmid)
194 {
195         return msr_read(rmid, lcore_id, IA32_QM_ASSOC);
196 }
197
198 void rdt_init_stat_core(uint8_t lcore_id)
199 {
200         stat_core = lcore_id;
201 }
202
203 /* read a specific rmid value using core 0 */
204 int cmt_read_ctr(uint64_t* ret, uint64_t rmid, uint8_t lcore_id)
205 {
206         uint64_t event_id = L3_CACHE_OCCUPANCY;
207
208         uint64_t es = rmid;
209         es = (es << 32) | event_id;
210
211         if (msr_write(lcore_id, es, IA32_QM_EVTSEL) < 0) {
212                 return 1;
213         }
214
215         if (msr_read(ret, lcore_id, IA32_QM_CTR) < 0) {
216                 return 2;
217         }
218
219         return 0;
220 }
221
222 int mbm_read_tot_bdw(uint64_t* ret, uint64_t rmid, uint8_t lcore_id)
223 {
224         uint64_t event_id = L3_TOTAL_EXTERNAL_BANDWIDTH;
225
226         uint64_t es = rmid;
227         es = (es << 32) | event_id;
228
229         if (msr_write(lcore_id, es, IA32_QM_EVTSEL) < 0) {
230                 return 1;
231         }
232
233         if (msr_read(ret, lcore_id, IA32_QM_CTR) < 0) {
234                 return 2;
235         }
236         return 0;
237 }
238
239 int mbm_read_loc_bdw(uint64_t* ret, uint64_t rmid, uint8_t lcore_id)
240 {
241         uint64_t event_id = L3_LOCAL_EXTERNAL_BANDWIDTH;
242
243         uint64_t es = rmid;
244         es = (es << 32) | event_id;
245
246         if (msr_write(lcore_id, es, IA32_QM_EVTSEL) < 0) {
247                 return 1;
248         }
249
250         if (msr_read(ret, lcore_id, IA32_QM_CTR) < 0) {
251                 return 2;
252         }
253         return 0;
254 }
255
256 int cat_log_init(uint8_t lcore_id)
257 {
258         uint64_t tmp_rmid;
259         int rc, i = 0;
260         for (i = 0; i < IA32_QM_L3CA_END - IA32_QM_L3CA_START; i++) {
261                 rc = msr_read(&tmp_rmid,lcore_id,IA32_QM_L3CA_START + i);
262                 if (rc < 0) {
263                         break;
264                 }
265                 plog_info("\tAt initialization: Cache allocation set %d (msr %x): mask %lx\n", i, IA32_QM_L3CA_START + i, tmp_rmid);
266         }
267         return i;
268 }
269
270 int cat_set_class_mask(uint8_t lcore_id, uint32_t set, uint32_t mask)
271 {
272         uint64_t tmp_rmid;
273         int rc;
274         rc = msr_write(lcore_id, mask, IA32_QM_L3CA_START + set);
275         if (rc < 0) {
276                 plog_err("Failed to write Cache allocation\n");
277                 return -1;
278         }
279         return 0;
280 }
281
282 int cat_get_class_mask(uint8_t lcore_id, uint32_t set, uint32_t *mask)
283 {
284         uint64_t tmp_rmid;
285         int rc;
286         rc = msr_read(&tmp_rmid,lcore_id,IA32_QM_L3CA_START + set);
287         if (rc < 0) {
288                 plog_err("Failed to read Cache allocation\n");
289                 return -1;
290         }
291         *mask = tmp_rmid & 0xffffffff;
292         return 0;
293 }
294
295 void cat_reset_cache(uint32_t lcore_id)
296 {
297         int rc;
298         uint32_t mask = (1 << rdt_features.cat_num_ways) -1;
299         for (uint32_t set = 0; set <= rdt_features.cat_max_rmid; set++) {
300                 rc = msr_write(lcore_id, mask, IA32_QM_L3CA_START + set);
301                 if (rc < 0) {
302                         plog_err("Failed to reset Cache allocation\n");
303                 }
304         }
305 }
306
307 int cat_get_num_ways(void)
308 {
309         return rdt_features.cat_num_ways;
310 }