blob: df0b7a1ef147e22ab875e35abd3a66b12a1109ed [file] [log] [blame]
Girish Gowdraddf9a162020-01-27 12:56:27 +05301/*
2 * Copyright 2018-present Open Networking Foundation
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
Orhan Kupusoglu1fd77072021-03-23 08:13:25 -070017#include <fstream>
18#include <sstream>
Girish Gowdraddf9a162020-01-27 12:56:27 +053019#include "core_utils.h"
20
Orhan Kupusoglu1fd77072021-03-23 08:13:25 -070021// save the TLS option
22static std::string tls_option_arg{};
23
Girish Gowdraddf9a162020-01-27 12:56:27 +053024std::string serial_number_to_str(bcmolt_serial_number* serial_number) {
25#define SERIAL_NUMBER_SIZE 12
26 char buff[SERIAL_NUMBER_SIZE+1];
27
28 sprintf(buff, "%c%c%c%c%1X%1X%1X%1X%1X%1X%1X%1X",
29 serial_number->vendor_id.arr[0],
30 serial_number->vendor_id.arr[1],
31 serial_number->vendor_id.arr[2],
32 serial_number->vendor_id.arr[3],
33 serial_number->vendor_specific.arr[0]>>4 & 0x0f,
34 serial_number->vendor_specific.arr[0] & 0x0f,
35 serial_number->vendor_specific.arr[1]>>4 & 0x0f,
36 serial_number->vendor_specific.arr[1] & 0x0f,
37 serial_number->vendor_specific.arr[2]>>4 & 0x0f,
38 serial_number->vendor_specific.arr[2] & 0x0f,
39 serial_number->vendor_specific.arr[3]>>4 & 0x0f,
40 serial_number->vendor_specific.arr[3] & 0x0f);
41
42 return buff;
43}
44
45std::string vendor_specific_to_str(char const * const vendor_specific) {
46 char buff[SERIAL_NUMBER_SIZE+1];
47
48 sprintf(buff, "%1X%1X%1X%1X%1X%1X%1X%1X",
49 vendor_specific[0]>>4 & 0x0f,
50 vendor_specific[0] & 0x0f,
51 vendor_specific[1]>>4 & 0x0f,
52 vendor_specific[1] & 0x0f,
53 vendor_specific[2]>>4 & 0x0f,
54 vendor_specific[2] & 0x0f,
55 vendor_specific[3]>>4 & 0x0f,
56 vendor_specific[3] & 0x0f);
57
58 return buff;
59}
60/**
61* Returns the default NNI (Upstream direction) or PON (Downstream direction) scheduler
62* Every NNI port and PON port have default scheduler.
63* The NNI0 default scheduler ID is 18432, and NNI1 is 18433 and so on.
64* Similarly, PON0 default scheduler ID is 16384. PON1 is 16385 and so on.
65*
66* @param intf_id NNI or PON interface ID
67* @param direction "upstream" or "downstream"
68*
69* @return default scheduler ID for the given interface.
70*/
71
72uint16_t get_dev_id(void) {
73 return dev_id;
74}
75
76int get_default_tm_sched_id(int intf_id, std::string direction) {
Girish Gowdrafc6c0bf2022-01-28 18:31:30 -080077 if (direction == upstream) {
Girish Gowdraddf9a162020-01-27 12:56:27 +053078 return tm_upstream_sched_id_start + intf_id;
Girish Gowdrafc6c0bf2022-01-28 18:31:30 -080079 } else if (direction == downstream) {
Girish Gowdraddf9a162020-01-27 12:56:27 +053080 return tm_downstream_sched_id_start + intf_id;
81 }
82 else {
83 OPENOLT_LOG(ERROR, openolt_log_id, "invalid direction - %s\n", direction.c_str());
84 return 0;
85 }
86}
87
88/**
89* Gets a unique tm_sched_id for a given intf_id, onu_id, uni_id, gemport_id, direction
90* The tm_sched_id is locally cached in a map, so that it can rendered when necessary.
Burak Gurdag2f2618c2020-04-23 13:20:30 +000091* VOLTHA replays whole configuration on OLT reboot, so caching locally is not a problem.
92* Note that tech_profile_id is used to differentiate service schedulers in downstream direction.
Girish Gowdraddf9a162020-01-27 12:56:27 +053093*
94* @param intf_id NNI or PON intf ID
95* @param onu_id ONU ID
96* @param uni_id UNI ID
97* @param gemport_id GEM Port ID
98* @param direction Upstream or downstream
Burak Gurdag2f2618c2020-04-23 13:20:30 +000099* @param tech_profile_id Technology Profile ID
Girish Gowdraddf9a162020-01-27 12:56:27 +0530100*
101* @return tm_sched_id
102*/
Burak Gurdag2f2618c2020-04-23 13:20:30 +0000103uint32_t get_tm_sched_id(int pon_intf_id, int onu_id, int uni_id, std::string direction, int tech_profile_id) {
104 sched_map_key_tuple key(pon_intf_id, onu_id, uni_id, direction, tech_profile_id);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530105 int sched_id = -1;
106
Girish Gowdra252f4972020-09-07 21:24:01 -0700107 bcmos_fastlock_lock(&tm_sched_bitset_lock);
108
Girish Gowdraddf9a162020-01-27 12:56:27 +0530109 std::map<sched_map_key_tuple, int>::const_iterator it = sched_map.find(key);
110 if (it != sched_map.end()) {
111 sched_id = it->second;
112 }
113 if (sched_id != -1) {
Girish Gowdra252f4972020-09-07 21:24:01 -0700114 bcmos_fastlock_unlock(&tm_sched_bitset_lock, 0);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530115 return sched_id;
116 }
117
Girish Gowdraddf9a162020-01-27 12:56:27 +0530118 // Complexity of O(n). Is there better way that can avoid linear search?
119 for (sched_id = 0; sched_id < MAX_TM_SCHED_ID; sched_id++) {
120 if (tm_sched_bitset[sched_id] == 0) {
121 tm_sched_bitset[sched_id] = 1;
122 break;
123 }
124 }
Girish Gowdraddf9a162020-01-27 12:56:27 +0530125
126 if (sched_id < MAX_TM_SCHED_ID) {
Girish Gowdraddf9a162020-01-27 12:56:27 +0530127 sched_map[key] = sched_id;
Girish Gowdra252f4972020-09-07 21:24:01 -0700128 bcmos_fastlock_unlock(&tm_sched_bitset_lock, 0);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530129 return sched_id;
130 } else {
Girish Gowdra252f4972020-09-07 21:24:01 -0700131 bcmos_fastlock_unlock(&tm_sched_bitset_lock, 0);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530132 return -1;
133 }
134}
135
136/**
Burak Gurdag2f2618c2020-04-23 13:20:30 +0000137* Free tm_sched_id for a given intf_id, onu_id, uni_id, gemport_id, direction, tech_profile_id
Girish Gowdraddf9a162020-01-27 12:56:27 +0530138*
139* @param intf_id NNI or PON intf ID
140* @param onu_id ONU ID
141* @param uni_id UNI ID
142* @param gemport_id GEM Port ID
143* @param direction Upstream or downstream
Burak Gurdag2f2618c2020-04-23 13:20:30 +0000144* @param tech_profile_id Technology Profile ID
Girish Gowdraddf9a162020-01-27 12:56:27 +0530145*/
Burak Gurdag2f2618c2020-04-23 13:20:30 +0000146void free_tm_sched_id(int pon_intf_id, int onu_id, int uni_id, std::string direction, int tech_profile_id) {
147 sched_map_key_tuple key(pon_intf_id, onu_id, uni_id, direction, tech_profile_id);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530148 std::map<sched_map_key_tuple, int>::const_iterator it;
Girish Gowdra252f4972020-09-07 21:24:01 -0700149 bcmos_fastlock_lock(&tm_sched_bitset_lock);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530150 it = sched_map.find(key);
151 if (it != sched_map.end()) {
152 tm_sched_bitset[it->second] = 0;
153 sched_map.erase(it);
154 }
Girish Gowdra252f4972020-09-07 21:24:01 -0700155 bcmos_fastlock_unlock(&tm_sched_bitset_lock, 0);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530156}
157
Burak Gurdag2f2618c2020-04-23 13:20:30 +0000158bool is_tm_sched_id_present(int pon_intf_id, int onu_id, int uni_id, std::string direction, int tech_profile_id) {
159 sched_map_key_tuple key(pon_intf_id, onu_id, uni_id, direction, tech_profile_id);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530160 std::map<sched_map_key_tuple, int>::const_iterator it = sched_map.find(key);
161 if (it != sched_map.end()) {
162 return true;
163 }
164 return false;
165}
166
167/**
168* Check whether given two tm qmp profiles are equal or not
169*
170* @param tmq_map_profileA <vector> TM QUEUE MAPPING PROFILE
171* @param tmq_map_profileB <vector> TM QUEUE MAPPING PROFILE
172*
173* @return boolean, true if given tmq_map_profiles are equal else false
174*/
175
176bool check_tm_qmp_equality(std::vector<uint32_t> tmq_map_profileA, std::vector<uint32_t> tmq_map_profileB) {
177 for (uint32_t i = 0; i < TMQ_MAP_PROFILE_SIZE; i++) {
178 if (tmq_map_profileA[i] != tmq_map_profileB[i]) {
179 return false;
180 }
181 }
182 return true;
183}
184
185/**
186* Modifies given queues_pbit_map to parsable format
187* e.g: Modifes "0b00000101" to "10100000"
188*
189* @param queues_pbit_map PBIT MAP configured for each GEM in TECH PROFILE
190* @param size Queue count
191*
192* @return string queues_pbit_map
193*/
194std::string* get_valid_queues_pbit_map(std::string *queues_pbit_map, uint32_t size) {
195 for(uint32_t i=0; i < size; i++) {
196 /* Deletes 2 characters from index number 0 */
197 queues_pbit_map[i].erase(0, 2);
198 std::reverse(queues_pbit_map[i].begin(), queues_pbit_map[i].end());
199 }
200 return queues_pbit_map;
201}
202
203/**
204* Creates TM QUEUE MAPPING PROFILE for given queues_pbit_map and queues_priority_q
205*
206* @param queues_pbit_map PBIT MAP configured for each GEM in TECH PROFILE
207* @param queues_priority_q PRIORITY_Q configured for each GEM in TECH PROFILE
208* @param size Queue count
209*
210* @return <vector> TM QUEUE MAPPING PROFILE
211*/
212std::vector<uint32_t> get_tmq_map_profile(std::string *queues_pbit_map, uint32_t *queues_priority_q, uint32_t size) {
213 std::vector<uint32_t> tmq_map_profile(8,0);
214
215 for(uint32_t i=0; i < size; i++) {
216 for (uint32_t j = 0; j < queues_pbit_map[i].size(); j++) {
217 if (queues_pbit_map[i][j]=='1') {
218 tmq_map_profile.at(j) = queue_id_list[queues_priority_q[i]];
219 }
220 }
221 }
222 return tmq_map_profile;
223}
224
225/**
226* Gets corresponding tm_qmp_id for a given tmq_map_profile
227*
228* @param <vector> TM QUEUE MAPPING PROFILE
229*
230* @return tm_qmp_id
231*/
232int get_tm_qmp_id(std::vector<uint32_t> tmq_map_profile) {
233 int tm_qmp_id = -1;
234
235 std::map<int, std::vector < uint32_t > >::const_iterator it = qmp_id_to_qmp_map.begin();
236 while(it != qmp_id_to_qmp_map.end()) {
237 if(check_tm_qmp_equality(tmq_map_profile, it->second)) {
238 tm_qmp_id = it->first;
239 break;
240 }
241 it++;
242 }
243 return tm_qmp_id;
244}
245
246/**
247* Updates sched_qmp_id_map with given sched_id, pon_intf_id, onu_id, uni_id, tm_qmp_id
248*
249* @param upstream/downstream sched_id
250* @param PON intf ID
251* @param onu_id ONU ID
252* @param uni_id UNI ID
253* @param tm_qmp_id TM QUEUE MAPPING PROFILE ID
254*/
255void update_sched_qmp_id_map(uint32_t sched_id,uint32_t pon_intf_id, uint32_t onu_id, \
256 uint32_t uni_id, int tm_qmp_id) {
Girish Gowdra252f4972020-09-07 21:24:01 -0700257 bcmos_fastlock_lock(&tm_qmp_bitset_lock);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530258 sched_qmp_id_map_key_tuple key(sched_id, pon_intf_id, onu_id, uni_id);
259 sched_qmp_id_map.insert(make_pair(key, tm_qmp_id));
Girish Gowdra252f4972020-09-07 21:24:01 -0700260 bcmos_fastlock_unlock(&tm_qmp_bitset_lock, 0);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530261}
262
263/**
264* Gets corresponding tm_qmp_id for a given sched_id, pon_intf_id, onu_id, uni_id
265*
266* @param upstream/downstream sched_id
267* @param PON intf ID
268* @param onu_id ONU ID
269* @param uni_id UNI ID
270*
271* @return tm_qmp_id
272*/
273int get_tm_qmp_id(uint32_t sched_id,uint32_t pon_intf_id, uint32_t onu_id, uint32_t uni_id) {
274 sched_qmp_id_map_key_tuple key(sched_id, pon_intf_id, onu_id, uni_id);
275 int tm_qmp_id = -1;
276
277 std::map<sched_qmp_id_map_key_tuple, int>::const_iterator it = sched_qmp_id_map.find(key);
278 if (it != sched_qmp_id_map.end()) {
279 tm_qmp_id = it->second;
280 }
281 return tm_qmp_id;
282}
283
284/**
285* Gets a unique tm_qmp_id for a given tmq_map_profile
286* The tm_qmp_id is locally cached in a map, so that it can be rendered when necessary.
287* VOLTHA replays whole configuration on OLT reboot, so caching locally is not a problem
288*
289* @param upstream/downstream sched_id
290* @param PON intf ID
291* @param onu_id ONU ID
292* @param uni_id UNI ID
293* @param <vector> TM QUEUE MAPPING PROFILE
294*
295* @return tm_qmp_id
296*/
297int get_tm_qmp_id(uint32_t sched_id,uint32_t pon_intf_id, uint32_t onu_id, uint32_t uni_id, \
298 std::vector<uint32_t> tmq_map_profile) {
299 int tm_qmp_id;
300
Girish Gowdra252f4972020-09-07 21:24:01 -0700301 bcmos_fastlock_lock(&tm_qmp_bitset_lock);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530302 /* Complexity of O(n). Is there better way that can avoid linear search? */
303 for (tm_qmp_id = 0; tm_qmp_id < MAX_TM_QMP_ID; tm_qmp_id++) {
304 if (tm_qmp_bitset[tm_qmp_id] == 0) {
305 tm_qmp_bitset[tm_qmp_id] = 1;
306 break;
307 }
308 }
Girish Gowdraddf9a162020-01-27 12:56:27 +0530309
310 if (tm_qmp_id < MAX_TM_QMP_ID) {
Girish Gowdraddf9a162020-01-27 12:56:27 +0530311 qmp_id_to_qmp_map.insert(make_pair(tm_qmp_id, tmq_map_profile));
Girish Gowdra252f4972020-09-07 21:24:01 -0700312 bcmos_fastlock_unlock(&tm_qmp_bitset_lock, 0);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530313 update_sched_qmp_id_map(sched_id, pon_intf_id, onu_id, uni_id, tm_qmp_id);
314 return tm_qmp_id;
315 } else {
Girish Gowdra252f4972020-09-07 21:24:01 -0700316 bcmos_fastlock_unlock(&tm_qmp_bitset_lock, 0);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530317 return -1;
318 }
319}
320
321/**
322* Free tm_qmp_id for a given sched_id, pon_intf_id, onu_id, uni_id
323*
324* @param upstream/downstream sched_id
325* @param PON intf ID
326* @param onu_id ONU ID
327* @param uni_id UNI ID
328* @param tm_qmp_id TM QUEUE MAPPING PROFILE ID
329*
330* @return boolean, true if no more reference for TM QMP else false
331*/
332bool free_tm_qmp_id(uint32_t sched_id,uint32_t pon_intf_id, uint32_t onu_id, \
333 uint32_t uni_id, int tm_qmp_id) {
334 bool result;
335 sched_qmp_id_map_key_tuple key(sched_id, pon_intf_id, onu_id, uni_id);
336 std::map<sched_qmp_id_map_key_tuple, int>::const_iterator it = sched_qmp_id_map.find(key);
Girish Gowdra252f4972020-09-07 21:24:01 -0700337 bcmos_fastlock_lock(&tm_qmp_bitset_lock);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530338 if (it != sched_qmp_id_map.end()) {
339 sched_qmp_id_map.erase(it);
340 }
Girish Gowdraddf9a162020-01-27 12:56:27 +0530341
342 uint32_t tm_qmp_ref_count = 0;
343 std::map<sched_qmp_id_map_key_tuple, int>::const_iterator it2 = sched_qmp_id_map.begin();
344 while(it2 != sched_qmp_id_map.end()) {
345 if(it2->second == tm_qmp_id) {
346 tm_qmp_ref_count++;
347 }
348 it2++;
349 }
350
351 if (tm_qmp_ref_count == 0) {
352 std::map<int, std::vector < uint32_t > >::const_iterator it3 = qmp_id_to_qmp_map.find(tm_qmp_id);
353 if (it3 != qmp_id_to_qmp_map.end()) {
Girish Gowdraddf9a162020-01-27 12:56:27 +0530354 tm_qmp_bitset[tm_qmp_id] = 0;
355 qmp_id_to_qmp_map.erase(it3);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530356 OPENOLT_LOG(INFO, openolt_log_id, "Reference count for tm qmp profile id %d is : %d. So clearing it\n", \
357 tm_qmp_id, tm_qmp_ref_count);
358 result = true;
359 }
360 } else {
361 OPENOLT_LOG(INFO, openolt_log_id, "Reference count for tm qmp profile id %d is : %d. So not clearing it\n", \
362 tm_qmp_id, tm_qmp_ref_count);
363 result = false;
364 }
Girish Gowdra252f4972020-09-07 21:24:01 -0700365 bcmos_fastlock_unlock(&tm_qmp_bitset_lock, 0);
366
Girish Gowdraddf9a162020-01-27 12:56:27 +0530367 return result;
368}
369
Thiyagarajan Subramani1744c922020-02-16 18:55:02 +0530370/* ACL ID is a shared resource, caller of this function has to ensure atomicity using locks
371 Gets free ACL ID if available, else -1. */
Girish Gowdraddf9a162020-01-27 12:56:27 +0530372int get_acl_id() {
373 int acl_id;
Thiyagarajan Subramani1744c922020-02-16 18:55:02 +0530374
Girish Gowdra252f4972020-09-07 21:24:01 -0700375 bcmos_fastlock_lock(&acl_id_bitset_lock);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530376 /* Complexity of O(n). Is there better way that can avoid linear search? */
377 for (acl_id = 0; acl_id < MAX_ACL_ID; acl_id++) {
378 if (acl_id_bitset[acl_id] == 0) {
379 acl_id_bitset[acl_id] = 1;
380 break;
381 }
382 }
Girish Gowdra252f4972020-09-07 21:24:01 -0700383 bcmos_fastlock_unlock(&acl_id_bitset_lock, 0);
384
Girish Gowdraddf9a162020-01-27 12:56:27 +0530385 if (acl_id < MAX_ACL_ID) {
386 return acl_id ;
387 } else {
388 return -1;
389 }
390}
391
Thiyagarajan Subramani1744c922020-02-16 18:55:02 +0530392/* ACL ID is a shared resource, caller of this function has to ensure atomicity using locks
393 Frees up the ACL ID. */
Girish Gowdraddf9a162020-01-27 12:56:27 +0530394void free_acl_id (int acl_id) {
Girish Gowdra252f4972020-09-07 21:24:01 -0700395 bcmos_fastlock_lock(&acl_id_bitset_lock);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530396 if (acl_id < MAX_ACL_ID) {
Girish Gowdraddf9a162020-01-27 12:56:27 +0530397 acl_id_bitset[acl_id] = 0;
Girish Gowdraddf9a162020-01-27 12:56:27 +0530398 }
Girish Gowdra252f4972020-09-07 21:24:01 -0700399 bcmos_fastlock_unlock(&acl_id_bitset_lock, 0);
400}
401
402/* Gets a free Flow ID if available, else INVALID_FLOW_ID */
403uint16_t get_flow_id() {
404 uint16_t flow_id;
405
406 bcmos_fastlock_lock(&flow_id_bitset_lock);
407 /* Complexity of O(n). Is there better way that can avoid linear search? */
408 // start flow_id from 1 as 0 is invalid
409 for (flow_id = FLOW_ID_START; flow_id <= FLOW_ID_END; flow_id++) {
410 if (flow_id_bitset[flow_id] == 0) {
411 flow_id_bitset[flow_id] = 1;
412 break;
413 }
414 }
415 bcmos_fastlock_unlock(&flow_id_bitset_lock, 0);
416
417 if (flow_id <= MAX_FLOW_ID) {
418 return flow_id ;
419 } else {
420 return INVALID_FLOW_ID;
421 }
422}
423
424/* Gets requested number of Flow IDs.
425 'num_of_flow_ids' is number of flow_ids requested. This cannot be more than NUMBER_OF_PBITS
426 'flow_ids' is pointer to array of size NUMBER_OF_PBITS
427 If the operation is successful, returns true else false
428 The operation is successful if we can allocate fully the number of flow_ids requested.
429 */
430bool get_flow_ids(int num_of_flow_ids, uint16_t *flow_ids) {
431 if (num_of_flow_ids > NUMBER_OF_PBITS) {
432 OPENOLT_LOG(ERROR, openolt_log_id, "requested number of flow_ids is more than 8\n");
433 return false;
434 }
435 int cnt = 0;
436
437 bcmos_fastlock_lock(&flow_id_bitset_lock);
438 /* Complexity of O(n). Is there better way that can avoid linear search? */
439 // start flow_id from 1 as 0 is invalid
440 for (uint16_t flow_id = FLOW_ID_START; flow_id <= FLOW_ID_END && cnt < num_of_flow_ids; flow_id++) {
441 if (flow_id_bitset[flow_id] == 0) {
442 flow_id_bitset[flow_id] = 1;
443 flow_ids[cnt] = flow_id;
444 cnt++;
445 }
446 }
447 bcmos_fastlock_unlock(&flow_id_bitset_lock, 0);
448 // If we could not allocate the requested number of flow_ids free the allocated flow_ids
449 // and return false
450 if (cnt != num_of_flow_ids) {
451 OPENOLT_LOG(ERROR, openolt_log_id, "could not allocated the rquested number of flows ids. requested=%d, allocated=%d", num_of_flow_ids, cnt);
452 if (cnt > 0) {
453 for(int i=0; i < cnt; i++) {
454 free_flow_id(flow_ids[i]);
455 }
456 }
457 return false;
458 }
459 return true;
460}
461
462/* Frees up the FLOW ID. */
463void free_flow_id (uint16_t flow_id) {
464 bcmos_fastlock_lock(&flow_id_bitset_lock);
465 if (flow_id <= MAX_FLOW_ID) {
466 flow_id_bitset[flow_id] = 0;
467 }
468 bcmos_fastlock_unlock(&flow_id_bitset_lock, 0);
469}
470
471void free_flow_ids(uint8_t num_flows, uint16_t *flow_ids) {
472 for (uint8_t i = 0; i < num_flows; i++) {
473 bcmos_fastlock_lock(&flow_id_bitset_lock);
474 if (flow_ids[i] <= MAX_FLOW_ID) {
475 flow_id_bitset[flow_ids[i]] = 0;
476 }
477 bcmos_fastlock_unlock(&flow_id_bitset_lock, 0);
478 }
Girish Gowdraddf9a162020-01-27 12:56:27 +0530479}
480
481/**
482* Returns qos type as string
483*
484* @param qos_type bcmolt_egress_qos_type enum
485*/
486std::string get_qos_type_as_string(bcmolt_egress_qos_type qos_type) {
487 switch (qos_type)
488 {
489 case BCMOLT_EGRESS_QOS_TYPE_FIXED_QUEUE: return "FIXED_QUEUE";
490 case BCMOLT_EGRESS_QOS_TYPE_TC_TO_QUEUE: return "TC_TO_QUEUE";
491 case BCMOLT_EGRESS_QOS_TYPE_PBIT_TO_TC: return "PBIT_TO_TC";
492 case BCMOLT_EGRESS_QOS_TYPE_NONE: return "NONE";
493 case BCMOLT_EGRESS_QOS_TYPE_PRIORITY_TO_QUEUE: return "PRIORITY_TO_QUEUE";
494 default: OPENOLT_LOG(ERROR, openolt_log_id, "qos-type-not-supported %d\n", qos_type);
495 return "qos-type-not-supported";
496 }
497}
498
499/**
500* Gets/Updates qos type for given pon_intf_id, onu_id, uni_id
501*
502* @param PON intf ID
503* @param onu_id ONU ID
504* @param uni_id UNI ID
505* @param queue_size TrafficQueues Size
506*
507* @return qos_type
508*/
509bcmolt_egress_qos_type get_qos_type(uint32_t pon_intf_id, uint32_t onu_id, uint32_t uni_id, uint32_t queue_size) {
510 qos_type_map_key_tuple key(pon_intf_id, onu_id, uni_id);
511 bcmolt_egress_qos_type egress_qos_type = BCMOLT_EGRESS_QOS_TYPE_FIXED_QUEUE;
512 std::string qos_string;
513
514 std::map<qos_type_map_key_tuple, bcmolt_egress_qos_type>::const_iterator it = qos_type_map.find(key);
515 if (it != qos_type_map.end()) {
516 egress_qos_type = it->second;
517 qos_string = get_qos_type_as_string(egress_qos_type);
518 OPENOLT_LOG(INFO, openolt_log_id, "Qos-type for subscriber connected to pon_intf_id %d, onu_id %d and uni_id %d is %s\n", \
519 pon_intf_id, onu_id, uni_id, qos_string.c_str());
520 }
521 else {
522 /* QOS Type has been pre-defined as Fixed Queue but it will be updated based on number of GEMPORTS
523 associated for a given subscriber. If GEM count = 1 for a given subscriber, qos_type will be Fixed Queue
524 else Priority to Queue */
525 egress_qos_type = (queue_size > 1) ? \
526 BCMOLT_EGRESS_QOS_TYPE_PRIORITY_TO_QUEUE : BCMOLT_EGRESS_QOS_TYPE_FIXED_QUEUE;
527 bcmos_fastlock_lock(&data_lock);
528 qos_type_map.insert(make_pair(key, egress_qos_type));
529 bcmos_fastlock_unlock(&data_lock, 0);
530 qos_string = get_qos_type_as_string(egress_qos_type);
531 OPENOLT_LOG(INFO, openolt_log_id, "Qos-type for subscriber connected to pon_intf_id %d, onu_id %d and uni_id %d is %s\n", \
532 pon_intf_id, onu_id, uni_id, qos_string.c_str());
533 }
534 return egress_qos_type;
535}
536
537/**
538* Clears qos type for given pon_intf_id, onu_id, uni_id
539*
540* @param PON intf ID
541* @param onu_id ONU ID
542* @param uni_id UNI ID
543*/
544void clear_qos_type(uint32_t pon_intf_id, uint32_t onu_id, uint32_t uni_id) {
545 qos_type_map_key_tuple key(pon_intf_id, onu_id, uni_id);
546 std::map<qos_type_map_key_tuple, bcmolt_egress_qos_type>::const_iterator it = qos_type_map.find(key);
547 bcmos_fastlock_lock(&data_lock);
548 if (it != qos_type_map.end()) {
549 qos_type_map.erase(it);
550 OPENOLT_LOG(INFO, openolt_log_id, "Cleared Qos-type for subscriber connected to pon_intf_id %d, onu_id %d and uni_id %d\n", \
551 pon_intf_id, onu_id, uni_id);
552 }
553 bcmos_fastlock_unlock(&data_lock, 0);
554}
555
556/**
557* Returns Scheduler/Queue direction as string
558*
559* @param direction as specified in tech_profile.proto
560*/
561std::string GetDirection(int direction) {
562 switch (direction)
563 {
564 case tech_profile::Direction::UPSTREAM: return upstream;
565 case tech_profile::Direction::DOWNSTREAM: return downstream;
566 default: OPENOLT_LOG(ERROR, openolt_log_id, "direction-not-supported %d\n", direction);
567 return "direction-not-supported";
568 }
569}
570
571// This method handles waiting for AllocObject configuration.
572// Returns error if the AllocObject is not in the appropriate state based on action requested.
573bcmos_errno wait_for_alloc_action(uint32_t intf_id, uint32_t alloc_id, AllocCfgAction action) {
574 Queue<alloc_cfg_complete_result> cfg_result;
575 alloc_cfg_compltd_key k(intf_id, alloc_id);
Thiyagarajan Subramanie976fcf2021-05-07 22:46:57 +0530576 bcmos_fastlock_lock(&alloc_cfg_wait_lock);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530577 alloc_cfg_compltd_map[k] = &cfg_result;
Thiyagarajan Subramanie976fcf2021-05-07 22:46:57 +0530578 bcmos_fastlock_unlock(&alloc_cfg_wait_lock, 0);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530579 bcmos_errno err = BCM_ERR_OK;
Girish Gowdraddf9a162020-01-27 12:56:27 +0530580
581 // Try to pop the result from BAL with a timeout of ALLOC_CFG_COMPLETE_WAIT_TIMEOUT ms
582 std::pair<alloc_cfg_complete_result, bool> result = cfg_result.pop(ALLOC_CFG_COMPLETE_WAIT_TIMEOUT);
583 if (result.second == false) {
Girish Gowdracdd5e5f2021-12-05 16:48:08 +0530584 OPENOLT_LOG(ERROR, openolt_log_id, "timeout waiting for alloc cfg complete indication intf_id %d, alloc_id %d, action = %d\n",
585 intf_id, alloc_id, action);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530586 // Invalidate the queue pointer.
587 bcmos_fastlock_lock(&alloc_cfg_wait_lock);
588 alloc_cfg_compltd_map[k] = NULL;
589 bcmos_fastlock_unlock(&alloc_cfg_wait_lock, 0);
590 err = BCM_ERR_INTERNAL;
Girish Gowdracdd5e5f2021-12-05 16:48:08 +0530591 // If the Alloc object is already in the right state after the performed operation, return OK.
592 bcmolt_activation_state state;
593 err = get_alloc_obj_state(intf_id, alloc_id, &state);
594 if (err) {
595 OPENOLT_LOG(ERROR, openolt_log_id, "error fetching alloc obj state intf_id = %d, alloc_id %d, action = %d, err = %d\n",
596 intf_id, alloc_id, action, err);
597 return err;
598 }
599 if ((state == BCMOLT_ACTIVATION_STATE_NOT_CONFIGURED && action == ALLOC_OBJECT_DELETE) ||
600 (state == BCMOLT_ACTIVATION_STATE_ACTIVE && action == ALLOC_OBJECT_CREATE)) {
601 OPENOLT_LOG(WARNING, openolt_log_id, "operation timed out, but the alloc object is the right state intf_id = %d, gem_port_id %d, action = %d\n",
602 intf_id, alloc_id, action);
603 return BCM_ERR_OK;
604 }
Girish Gowdraddf9a162020-01-27 12:56:27 +0530605 }
606 else if (result.first.status == ALLOC_CFG_STATUS_FAIL) {
Girish Gowdracdd5e5f2021-12-05 16:48:08 +0530607 OPENOLT_LOG(ERROR, openolt_log_id, "error processing alloc cfg request intf_id %d, alloc_id %d, action = %d\n",
608 intf_id, alloc_id, action);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530609 err = BCM_ERR_INTERNAL;
610 }
611
612 if (err == BCM_ERR_OK) {
613 if (action == ALLOC_OBJECT_CREATE) {
614 if (result.first.state != ALLOC_OBJECT_STATE_ACTIVE) {
615 OPENOLT_LOG(ERROR, openolt_log_id, "alloc object not in active state intf_id %d, alloc_id %d alloc_obj_state %d\n",
616 intf_id, alloc_id, result.first.state);
617 err = BCM_ERR_INTERNAL;
618 } else {
619 OPENOLT_LOG(INFO, openolt_log_id, "Create upstream bandwidth allocation success, intf_id %d, alloc_id %d\n",
620 intf_id, alloc_id);
621 }
622 } else { // ALLOC_OBJECT_DELETE
623 if (result.first.state != ALLOC_OBJECT_STATE_NOT_CONFIGURED) {
624 OPENOLT_LOG(ERROR, openolt_log_id, "alloc object is not reset intf_id %d, alloc_id %d alloc_obj_state %d\n",
625 intf_id, alloc_id, result.first.state);
626 err = BCM_ERR_INTERNAL;
627 } else {
628 OPENOLT_LOG(INFO, openolt_log_id, "Remove alloc object success, intf_id %d, alloc_id %d\n",
629 intf_id, alloc_id);
630 }
631 }
632 }
633
634 // Remove entry from map
635 bcmos_fastlock_lock(&alloc_cfg_wait_lock);
636 alloc_cfg_compltd_map.erase(k);
637 bcmos_fastlock_unlock(&alloc_cfg_wait_lock, 0);
Girish Gowdra7a79dae2020-02-10 18:22:11 +0530638 return err;
639}
640
Thiyagarajan Subramanie976fcf2021-05-07 22:46:57 +0530641// This method handles waiting for GemObject configuration.
642// Returns error if the GemObject is not in the appropriate state based on action requested.
643bcmos_errno wait_for_gem_action(uint32_t intf_id, uint32_t gem_port_id, GemCfgAction action) {
644 Queue<gem_cfg_complete_result> cfg_result;
645 gem_cfg_compltd_key k(intf_id, gem_port_id);
646 bcmos_fastlock_lock(&gem_cfg_wait_lock);
647 gem_cfg_compltd_map[k] = &cfg_result;
648 bcmos_fastlock_unlock(&gem_cfg_wait_lock, 0);
649 bcmos_errno err = BCM_ERR_OK;
650
651 // Try to pop the result from BAL with a timeout of GEM_CFG_COMPLETE_WAIT_TIMEOUT ms
652 std::pair<gem_cfg_complete_result, bool> result = cfg_result.pop(GEM_CFG_COMPLETE_WAIT_TIMEOUT);
653 if (result.second == false) {
Girish Gowdracdd5e5f2021-12-05 16:48:08 +0530654 OPENOLT_LOG(ERROR, openolt_log_id, "timeout waiting for gem cfg complete indication intf_id %d, gem_port_id %d, action = %d\n",
655 intf_id, gem_port_id, action);
Thiyagarajan Subramanie976fcf2021-05-07 22:46:57 +0530656 // Invalidate the queue pointer.
657 bcmos_fastlock_lock(&gem_cfg_wait_lock);
658 gem_cfg_compltd_map[k] = NULL;
659 bcmos_fastlock_unlock(&gem_cfg_wait_lock, 0);
660 err = BCM_ERR_INTERNAL;
Girish Gowdracdd5e5f2021-12-05 16:48:08 +0530661 // If the GEM object is already in the right state after the performed operation, return OK.
662 bcmolt_activation_state state;
663 err = get_gem_obj_state(intf_id, gem_port_id, &state);
664 if (err) {
665 OPENOLT_LOG(ERROR, openolt_log_id, "error fetching gem obj state intf_id = %d, gem_port_id %d, action = %d, err = %d\n",
666 intf_id, gem_port_id, action, err);
667 return err;
668 }
669 if ((state == BCMOLT_ACTIVATION_STATE_NOT_CONFIGURED && action == GEM_OBJECT_DELETE) ||
670 (state == BCMOLT_ACTIVATION_STATE_ACTIVE && action == GEM_OBJECT_CREATE)) {
671 OPENOLT_LOG(WARNING, openolt_log_id, "operation timed out, but the gem object is the right state intf_id = %d, gem_port_id %d, action = %d\n",
672 intf_id, gem_port_id, action);
673 return BCM_ERR_OK;
674 }
Thiyagarajan Subramanie976fcf2021-05-07 22:46:57 +0530675 }
676 else if (result.first.status == GEM_CFG_STATUS_FAIL) {
Girish Gowdracdd5e5f2021-12-05 16:48:08 +0530677 OPENOLT_LOG(ERROR, openolt_log_id, "error processing gem cfg request intf_id %d, gem_port_id %d, action = %d\n",
678 intf_id, gem_port_id, action);
Thiyagarajan Subramanie976fcf2021-05-07 22:46:57 +0530679 err = BCM_ERR_INTERNAL;
680 }
681
682 if (err == BCM_ERR_OK) {
683 if (action == GEM_OBJECT_CREATE) {
684 if (result.first.state != GEM_OBJECT_STATE_ACTIVE) {
685 OPENOLT_LOG(ERROR, openolt_log_id, "gem object not in active state intf_id %d, gem_port_id %d gem_obj_state %d\n",
686 intf_id, gem_port_id, result.first.state);
687 err = BCM_ERR_INTERNAL;
688 } else {
689 OPENOLT_LOG(INFO, openolt_log_id, "Create itupon gem object success, intf_id %d, gem_port_id %d\n",
690 intf_id, gem_port_id);
691 }
692 } else if (action == GEM_OBJECT_ENCRYPT) {
693 if (result.first.state != GEM_OBJECT_STATE_ACTIVE) {
694 OPENOLT_LOG(ERROR, openolt_log_id, "gem object not in active state intf_id %d, gem_port_id %d gem_obj_state %d\n",
695 intf_id, gem_port_id, result.first.state);
696 err = BCM_ERR_INTERNAL;
697 } else {
698 OPENOLT_LOG(INFO, openolt_log_id, "Enable itupon gem object encryption success, intf_id %d, gem_port_id %d\n",
699 intf_id, gem_port_id);
700 }
701 } else { // GEM_OBJECT_DELETE
702 if (result.first.state != GEM_OBJECT_STATE_NOT_CONFIGURED) {
703 OPENOLT_LOG(ERROR, openolt_log_id, "gem object is not reset intf_id %d, gem_port_id %d gem_obj_state %d\n",
704 intf_id, gem_port_id, result.first.state);
705 err = BCM_ERR_INTERNAL;
706 } else {
707 OPENOLT_LOG(INFO, openolt_log_id, "Remove itupon gem object success, intf_id %d, gem_port_id %d\n",
708 intf_id, gem_port_id);
709 }
710 }
711 }
712
713 // Remove entry from map
714 bcmos_fastlock_lock(&gem_cfg_wait_lock);
715 gem_cfg_compltd_map.erase(k);
716 bcmos_fastlock_unlock(&gem_cfg_wait_lock, 0);
717 return err;
718}
719
Girish Gowdra7a79dae2020-02-10 18:22:11 +0530720// This method handles waiting for OnuDeactivate Completed Indication
721bcmos_errno wait_for_onu_deactivate_complete(uint32_t intf_id, uint32_t onu_id) {
722 Queue<onu_deactivate_complete_result> deact_result;
723 onu_deact_compltd_key k(intf_id, onu_id);
724 onu_deact_compltd_map[k] = &deact_result;
725 bcmos_errno err = BCM_ERR_OK;
726
727 // Try to pop the result from BAL with a timeout of ONU_DEACTIVATE_COMPLETE_WAIT_TIMEOUT ms
728 std::pair<onu_deactivate_complete_result, bool> result = deact_result.pop(ONU_DEACTIVATE_COMPLETE_WAIT_TIMEOUT);
729 if (result.second == false) {
730 OPENOLT_LOG(ERROR, openolt_log_id, "timeout waiting for onu deactivate complete indication intf_id %d, onu_id %d\n",
731 intf_id, onu_id);
732 // Invalidate the queue pointer.
733 bcmos_fastlock_lock(&onu_deactivate_wait_lock);
734 onu_deact_compltd_map[k] = NULL;
735 bcmos_fastlock_unlock(&onu_deactivate_wait_lock, 0);
736 err = BCM_ERR_INTERNAL;
737 }
738 else if (result.first.result == BCMOLT_RESULT_FAIL) {
739 OPENOLT_LOG(ERROR, openolt_log_id, "error processing onu deactivate request intf_id %d, onu_id %d, fail_reason %d\n",
740 intf_id, onu_id, result.first.reason);
741 err = BCM_ERR_INTERNAL;
742 } else if (result.first.result == BCMOLT_RESULT_SUCCESS) {
743 OPENOLT_LOG(INFO, openolt_log_id, "success processing onu deactivate request intf_id %d, onu_id %d\n",
744 intf_id, onu_id);
745 }
746
747 // Remove entry from map
748 bcmos_fastlock_lock(&onu_deactivate_wait_lock);
749 onu_deact_compltd_map.erase(k);
750 bcmos_fastlock_unlock(&onu_deactivate_wait_lock, 0);
751
Girish Gowdraddf9a162020-01-27 12:56:27 +0530752 return err;
753}
754
755char* openolt_read_sysinfo(const char* field_name, char* field_val)
756{
757 FILE *fp;
758 /* Prepare the command*/
759 char command[150];
760
761 snprintf(command, sizeof command, "bash -l -c \"onlpdump -s\" | perl -ne 'print $1 if /%s: (\\S+)/'", field_name);
762 /* Open the command for reading. */
763 fp = popen(command, "r");
764 if (fp == NULL) {
765 /*The client has to check for a Null field value in this case*/
766 OPENOLT_LOG(INFO, openolt_log_id, "Failed to query the %s\n", field_name);
767 return field_val;
768 }
769
770 /*Read the field value*/
771 if (fp) {
772 uint8_t ret;
773 ret = fread(field_val, OPENOLT_FIELD_LEN, 1, fp);
774 if (ret >= OPENOLT_FIELD_LEN)
775 OPENOLT_LOG(INFO, openolt_log_id, "Read data length %u\n", ret);
776 pclose(fp);
777 }
778 return field_val;
779}
780
781Status pushOltOperInd(uint32_t intf_id, const char *type, const char *state)
782{
Girish Gowdra252f4972020-09-07 21:24:01 -0700783 ::openolt::Indication ind;
784 ::openolt::IntfOperIndication* intf_oper_ind = new ::openolt::IntfOperIndication;
Girish Gowdraddf9a162020-01-27 12:56:27 +0530785
786 intf_oper_ind->set_type(type);
787 intf_oper_ind->set_intf_id(intf_id);
788 intf_oper_ind->set_oper_state(state);
789 ind.set_allocated_intf_oper_ind(intf_oper_ind);
790 oltIndQ.push(ind);
791 return Status::OK;
792}
793
794#define CLI_HOST_PROMPT_FORMAT "BCM.%u> "
795
796/* Build CLI prompt */
797void openolt_cli_get_prompt_cb(bcmcli_session *session, char *buf, uint32_t max_len)
798{
799 snprintf(buf, max_len, CLI_HOST_PROMPT_FORMAT, dev_id);
800}
801
802int _bal_apiend_cli_thread_handler(long data)
803{
804 char init_string[]="\n";
805 bcmcli_session *sess = current_session;
806 bcmos_task_parm bal_cli_task_p_dummy;
807
808 /* Switch to interactive mode if not stopped in the init script */
809 if (!bcmcli_is_stopped(sess)) {
810 /* Force a CLI command prompt
811 * The string passed into the parse function
812 * must be modifiable, so a string constant like
813 * bcmcli_parse(current_session, "\n") will not
814 * work.
815 */
816 bcmcli_parse(sess, init_string);
817
818 /* Process user input until EOF or quit command */
819 bcmcli_driver(sess);
820 }
821 OPENOLT_LOG(INFO, openolt_log_id, "BAL API End CLI terminated\n");
822
823 /* Cleanup */
824 bcmcli_session_close(current_session);
825 bcmcli_token_destroy(NULL);
826 return 0;
827}
828
829/* Init API CLI commands for the current device */
830bcmos_errno bcm_openolt_api_cli_init(bcmcli_entry *parent_dir, bcmcli_session *session)
831{
832 bcmos_errno rc;
833
834 api_parent_dir = parent_dir;
835
836 rc = bcm_api_cli_set_commands(session);
837
838#ifdef BCM_SUBSYSTEM_HOST
839 /* Subscribe for device change indication */
840 rc = rc ? rc : bcmolt_olt_sel_ind_register(_api_cli_olt_change_ind);
841#endif
842
843 return rc;
844}
845
846bcmos_errno bcm_cli_quit(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
847{
848 bcmcli_stop(session);
849 bcmcli_session_print(session, "CLI terminated by 'Quit' command\n");
850 status_bcm_cli_quit = BCMOS_TRUE;
851
852 return BCM_ERR_OK;
853}
854
855int get_status_bcm_cli_quit(void) {
856 return status_bcm_cli_quit;
857}
858
859bcmos_errno bcmolt_apiend_cli_init() {
860 bcmos_errno ret;
861 bcmos_task_parm bal_cli_task_p = {};
862 bcmos_task_parm bal_cli_task_p_dummy;
863
864 /** before creating the task, check if it is already created by the other half of BAL i.e. Core side */
865 if (BCM_ERR_OK != bcmos_task_query(&bal_cli_thread, &bal_cli_task_p_dummy)) {
866 /* Create BAL CLI thread */
867 bal_cli_task_p.name = bal_cli_thread_name;
868 bal_cli_task_p.handler = _bal_apiend_cli_thread_handler;
869 bal_cli_task_p.priority = TASK_PRIORITY_CLI;
870
871 ret = bcmos_task_create(&bal_cli_thread, &bal_cli_task_p);
872 if (BCM_ERR_OK != ret) {
873 bcmos_printf("Couldn't create BAL API end CLI thread\n");
874 return ret;
875 }
876 }
877}
878
Girish Gowdra72cbee92021-11-05 15:16:18 -0700879bcmos_errno get_onu_state(bcmolt_interface pon_ni, int onu_id, bcmolt_onu_state *onu_state) {
Thiyagarajan Subramaniad463232020-02-28 19:10:43 +0530880 bcmos_errno err;
881 bcmolt_onu_cfg onu_cfg;
882 bcmolt_onu_key onu_key;
883 onu_key.pon_ni = pon_ni;
884 onu_key.onu_id = onu_id;
885
886 BCMOLT_CFG_INIT(&onu_cfg, onu, onu_key);
Girish Gowdra72cbee92021-11-05 15:16:18 -0700887 BCMOLT_MSG_FIELD_GET(&onu_cfg, onu_state);
Thiyagarajan Subramaniad463232020-02-28 19:10:43 +0530888 err = bcmolt_cfg_get(dev_id, &onu_cfg.hdr);
Thiyagarajan Subramaniad463232020-02-28 19:10:43 +0530889 *onu_state = onu_cfg.data.onu_state;
890 return err;
891}
892
Girish Gowdracdd5e5f2021-12-05 16:48:08 +0530893bcmos_errno get_gem_obj_state(bcmolt_interface pon_ni, bcmolt_gem_port_id id, bcmolt_activation_state *state) {
894 bcmos_errno err;
895 bcmolt_itupon_gem_cfg cfg;
896 bcmolt_itupon_gem_key key;
897 key.pon_ni = pon_ni;
898 key.gem_port_id = id;
899
900 BCMOLT_CFG_INIT(&cfg, itupon_gem, key);
901 BCMOLT_MSG_FIELD_GET(&cfg, state);
902 err = bcmolt_cfg_get(dev_id, &cfg.hdr);
903 *state = cfg.data.state;
904 return err;
905}
906
907bcmos_errno get_alloc_obj_state(bcmolt_interface pon_ni, bcmolt_alloc_id id, bcmolt_activation_state *state) {
908 bcmos_errno err;
909 bcmolt_itupon_alloc_cfg cfg;
910 bcmolt_itupon_alloc_key key;
911 key.pon_ni = pon_ni;
912 key.alloc_id = id;
913
914 BCMOLT_CFG_INIT(&cfg, itupon_alloc, key);
915 BCMOLT_MSG_FIELD_GET(&cfg, state);
916 err = bcmolt_cfg_get(dev_id, &cfg.hdr);
917 *state = cfg.data.state;
918 return err;
919}
920
Thiyagarajan Subramaniad463232020-02-28 19:10:43 +0530921bcmos_errno get_pon_interface_status(bcmolt_interface pon_ni, bcmolt_interface_state *state, bcmolt_status *los_status) {
Girish Gowdraddf9a162020-01-27 12:56:27 +0530922 bcmos_errno err;
923 bcmolt_pon_interface_key pon_key;
924 bcmolt_pon_interface_cfg pon_cfg;
925 pon_key.pon_ni = pon_ni;
926
927 BCMOLT_CFG_INIT(&pon_cfg, pon_interface, pon_key);
928 BCMOLT_FIELD_SET_PRESENT(&pon_cfg.data, pon_interface_cfg_data, state);
Thiyagarajan Subramaniad463232020-02-28 19:10:43 +0530929 BCMOLT_FIELD_SET_PRESENT(&pon_cfg.data, pon_interface_cfg_data, los_status);
Girish Gowdraddf9a162020-01-27 12:56:27 +0530930 #ifdef TEST_MODE
931 // It is impossible to mock the setting of pon_cfg.data.state because
932 // the actual bcmolt_cfg_get passes the address of pon_cfg.hdr and we cannot
933 // set the pon_cfg.data.state. So a new stub function is created and address
934 // of pon_cfg is passed. This is one-of case where we need to add test specific
935 // code in production code.
936 err = bcmolt_cfg_get__pon_intf_stub(dev_id, &pon_cfg);
937 #else
938 err = bcmolt_cfg_get(dev_id, &pon_cfg.hdr);
939 #endif
940 *state = pon_cfg.data.state;
Thiyagarajan Subramaniad463232020-02-28 19:10:43 +0530941 *los_status = pon_cfg.data.los_status;
Girish Gowdraddf9a162020-01-27 12:56:27 +0530942 return err;
943}
944
945/* Same as bcmolt_cfg_get but with added logic of retrying the API
946 in case of some specific failures like timeout or object not yet ready
947*/
948bcmos_errno bcmolt_cfg_get_mult_retry(bcmolt_oltid olt, bcmolt_cfg *cfg) {
949 bcmos_errno err;
950 uint32_t current_try = 0;
951
952 while (current_try < MAX_BAL_API_RETRY_COUNT) {
953 err = bcmolt_cfg_get(olt, cfg);
954 current_try++;
955
956 if (err == BCM_ERR_STATE || err == BCM_ERR_TIMEOUT) {
957 OPENOLT_LOG(WARNING, openolt_log_id, "bcmolt_cfg_get: err = %s\n", bcmos_strerror(err));
958 bcmos_usleep(BAL_API_RETRY_TIME_IN_USECS);
959 continue;
960 }
961 else {
962 break;
963 }
964 }
965
966 if (err != BCM_ERR_OK) {
967 OPENOLT_LOG(ERROR, openolt_log_id, "bcmolt_cfg_get tried (%d) times with retry time(%d usecs) err = %s\n",
968 current_try,
969 BAL_API_RETRY_TIME_IN_USECS,
970 bcmos_strerror(err));
971 }
972 return err;
973}
974
975
976unsigned NumNniIf_() {return num_of_nni_ports;}
977unsigned NumPonIf_() {return num_of_pon_ports;}
978
979bcmos_errno get_nni_interface_status(bcmolt_interface id, bcmolt_interface_state *state) {
980 bcmos_errno err;
981 bcmolt_nni_interface_key nni_key;
982 bcmolt_nni_interface_cfg nni_cfg;
983 nni_key.id = id;
984
985 BCMOLT_CFG_INIT(&nni_cfg, nni_interface, nni_key);
986 BCMOLT_FIELD_SET_PRESENT(&nni_cfg.data, nni_interface_cfg_data, state);
987 #ifdef TEST_MODE
988 // It is impossible to mock the setting of nni_cfg.data.state because
989 // the actual bcmolt_cfg_get passes the address of nni_cfg.hdr and we cannot
990 // set the nni_cfg.data.state. So a new stub function is created and address
991 // of nni_cfg is passed. This is one-of case where we need to add test specific
992 // code in production code.
993 err = bcmolt_cfg_get__nni_intf_stub(dev_id, &nni_cfg);
994 #else
995 err = bcmolt_cfg_get(dev_id, &nni_cfg.hdr);
996 #endif
997 *state = nni_cfg.data.state;
998 return err;
999}
1000
Thiyagarajan Subramani19168f52021-05-25 23:26:41 +05301001Status install_gem_port(int32_t intf_id, int32_t onu_id, int32_t uni_id, int32_t gemport_id, std::string board_technology) {
Thiyagarajan Subramanie976fcf2021-05-07 22:46:57 +05301002 gemport_status_map_key_tuple gem_status_key(intf_id, onu_id, uni_id, gemport_id);
1003
1004 bcmos_fastlock_lock(&data_lock);
1005 std::map<gemport_status_map_key_tuple, bool>::const_iterator it = gemport_status_map.find(gem_status_key);
1006 if (it != gemport_status_map.end()) {
1007 if (it->second) {
1008 bcmos_fastlock_unlock(&data_lock, 0);
1009 OPENOLT_LOG(INFO, openolt_log_id, "gem port already installed = %d\n", gemport_id);
1010 return Status::OK;
1011 }
1012 }
1013 bcmos_fastlock_unlock(&data_lock, 0);
1014
Girish Gowdraddf9a162020-01-27 12:56:27 +05301015 bcmos_errno err;
1016 bcmolt_itupon_gem_cfg cfg; /* declare main API struct */
1017 bcmolt_itupon_gem_key key = {}; /* declare key */
1018 bcmolt_gem_port_configuration configuration = {};
Girish Gowdra72cbee92021-11-05 15:16:18 -07001019 bcmolt_onu_state onu_state;
Girish Gowdraddf9a162020-01-27 12:56:27 +05301020
1021 key.pon_ni = intf_id;
1022 key.gem_port_id = gemport_id;
1023
1024 BCMOLT_CFG_INIT(&cfg, itupon_gem, key);
1025
1026 bcmolt_gem_port_direction configuration_direction;
1027 configuration_direction = BCMOLT_GEM_PORT_DIRECTION_BIDIRECTIONAL;
1028 BCMOLT_FIELD_SET(&configuration, gem_port_configuration, direction, configuration_direction);
1029
1030 bcmolt_gem_port_type configuration_type;
1031 configuration_type = BCMOLT_GEM_PORT_TYPE_UNICAST;
1032 BCMOLT_FIELD_SET(&configuration, gem_port_configuration, type, configuration_type);
1033
1034 BCMOLT_FIELD_SET(&cfg.data, itupon_gem_cfg_data, configuration, configuration);
1035
1036 BCMOLT_FIELD_SET(&cfg.data, itupon_gem_cfg_data, onu_id, onu_id);
1037
1038 bcmolt_control_state encryption_mode;
1039 encryption_mode = BCMOLT_CONTROL_STATE_DISABLE;
1040 BCMOLT_FIELD_SET(&cfg.data, itupon_gem_cfg_data, encryption_mode, encryption_mode);
1041
1042 bcmolt_us_gem_port_destination upstream_destination_queue;
1043 upstream_destination_queue = BCMOLT_US_GEM_PORT_DESTINATION_DATA;
1044 BCMOLT_FIELD_SET(&cfg.data, itupon_gem_cfg_data, upstream_destination_queue, upstream_destination_queue);
1045
1046 bcmolt_control_state control;
1047 control = BCMOLT_CONTROL_STATE_ENABLE;
1048 BCMOLT_FIELD_SET(&cfg.data, itupon_gem_cfg_data, control, control);
1049
Girish Gowdracdd5e5f2021-12-05 16:48:08 +05301050 bool wait_for_gem_cfg_complt = false;
1051 if (board_technology == "GPON") {
1052 // Wait for gem cfg complete indication only if ONU state is ACTIVE
1053 err = get_onu_state((bcmolt_interface)intf_id, (bcmolt_onu_id)onu_id, &onu_state);
1054 if (err) {
1055 OPENOLT_LOG(ERROR, openolt_log_id, "failed to get onu status onu_id = %d, gem_port = %d err = %s\n", onu_id, gemport_id, bcmos_strerror(err));
1056 return bcm_to_grpc_err(err, "failed to get onu status");
1057 } else if (onu_state == BCMOLT_ONU_STATE_ACTIVE) {
1058 wait_for_gem_cfg_complt = true;
1059 }
1060 }
1061
Girish Gowdraddf9a162020-01-27 12:56:27 +05301062 err = bcmolt_cfg_set(dev_id, &cfg.hdr);
1063 if(err != BCM_ERR_OK) {
Burak Gurdaga0523592021-02-24 15:17:47 +00001064 OPENOLT_LOG(ERROR, openolt_log_id, "failed to install gem_port = %d err = %s (%d)\n", gemport_id, cfg.hdr.hdr.err_text, err);
Girish Gowdraddf9a162020-01-27 12:56:27 +05301065 return bcm_to_grpc_err(err, "Access_Control set ITU PON Gem port failed");
1066 }
1067
Girish Gowdracdd5e5f2021-12-05 16:48:08 +05301068 // Wait for gem cfg complete indication only if ONU state is ACTIVE
1069 if (wait_for_gem_cfg_complt) {
1070 err = wait_for_gem_action(intf_id, gemport_id, GEM_OBJECT_CREATE);
1071 if (err) {
1072 OPENOLT_LOG(ERROR, openolt_log_id, "failed to install gem_port = %d err = %s\n", gemport_id, bcmos_strerror(err));
1073 return bcm_to_grpc_err(err, "Access_Control set ITU PON Gem port failed");
Thiyagarajan Subramani19168f52021-05-25 23:26:41 +05301074 }
Girish Gowdracdd5e5f2021-12-05 16:48:08 +05301075 } else {
1076 OPENOLT_LOG(DEBUG, openolt_log_id, "not waiting for gem config complete indication = %d\n", gemport_id);
Thiyagarajan Subramanie976fcf2021-05-07 22:46:57 +05301077 }
Thiyagarajan Subramanie976fcf2021-05-07 22:46:57 +05301078
Girish Gowdraddf9a162020-01-27 12:56:27 +05301079 OPENOLT_LOG(INFO, openolt_log_id, "gem port installed successfully = %d\n", gemport_id);
1080
Thiyagarajan Subramanie976fcf2021-05-07 22:46:57 +05301081 bcmos_fastlock_lock(&data_lock);
1082 gemport_status_map[gem_status_key] = true;
1083 bcmos_fastlock_unlock(&data_lock, 0);
1084
Girish Gowdraddf9a162020-01-27 12:56:27 +05301085 return Status::OK;
1086}
1087
Thiyagarajan Subramani19168f52021-05-25 23:26:41 +05301088Status remove_gem_port(int32_t intf_id, int32_t onu_id, int32_t uni_id, int32_t gemport_id, std::string board_technology) {
Thiyagarajan Subramanie976fcf2021-05-07 22:46:57 +05301089 gemport_status_map_key_tuple gem_status_key(intf_id, onu_id, uni_id, gemport_id);
Girish Gowdra72cbee92021-11-05 15:16:18 -07001090 bcmolt_onu_state onu_state;
Thiyagarajan Subramanie976fcf2021-05-07 22:46:57 +05301091
1092 bcmos_fastlock_lock(&data_lock);
1093 std::map<gemport_status_map_key_tuple, bool>::const_iterator it = gemport_status_map.find(gem_status_key);
1094 if (it == gemport_status_map.end()) {
1095 bcmos_fastlock_unlock(&data_lock, 0);
1096 OPENOLT_LOG(INFO, openolt_log_id, "gem port already removed = %d\n", gemport_id);
1097 return Status::OK;
1098 }
1099 bcmos_fastlock_unlock(&data_lock, 0);
1100
Girish Gowdraddf9a162020-01-27 12:56:27 +05301101 bcmolt_itupon_gem_cfg gem_cfg;
1102 bcmolt_itupon_gem_key key = {
1103 .pon_ni = (bcmolt_interface)intf_id,
1104 .gem_port_id = (bcmolt_gem_port_id)gemport_id
1105 };
1106 bcmos_errno err;
1107
Girish Gowdracdd5e5f2021-12-05 16:48:08 +05301108 bool wait_for_gem_cfg_complt = false;
1109 if (board_technology == "GPON") {
1110 // Wait for gem cfg complete indication only if ONU state is ACTIVE
1111 err = get_onu_state((bcmolt_interface)intf_id, (bcmolt_onu_id)onu_id, &onu_state);
1112 if (err) {
1113 OPENOLT_LOG(ERROR, openolt_log_id, "failed to get onu status onu_id = %d, gem_port = %d err = %s\n", onu_id, gemport_id, bcmos_strerror(err));
1114 return bcm_to_grpc_err(err, "failed to get onu status");
1115 } else if (onu_state == BCMOLT_ONU_STATE_ACTIVE) {
1116 wait_for_gem_cfg_complt = true;
1117 }
1118 }
1119
Girish Gowdraddf9a162020-01-27 12:56:27 +05301120 BCMOLT_CFG_INIT(&gem_cfg, itupon_gem, key);
1121 err = bcmolt_cfg_clear(dev_id, &gem_cfg.hdr);
1122 if (err != BCM_ERR_OK)
1123 {
Burak Gurdaga0523592021-02-24 15:17:47 +00001124 OPENOLT_LOG(ERROR, openolt_log_id, "failed to remove gem_port = %d err = %s (%d)\n", gemport_id, gem_cfg.hdr.hdr.err_text, err);
Girish Gowdraddf9a162020-01-27 12:56:27 +05301125 return bcm_to_grpc_err(err, "Access_Control clear ITU PON Gem port failed");
1126 }
1127
Girish Gowdracdd5e5f2021-12-05 16:48:08 +05301128 if (wait_for_gem_cfg_complt) {
1129 OPENOLT_LOG(INFO, openolt_log_id, "onu state is active waiting for gem cfg complete indication intf = %d onu = %d\n",
Girish Gowdra72cbee92021-11-05 15:16:18 -07001130 intf_id, onu_id);
Girish Gowdracdd5e5f2021-12-05 16:48:08 +05301131 err = wait_for_gem_action(intf_id, gemport_id, GEM_OBJECT_DELETE);
1132 if (err) {
1133 OPENOLT_LOG(ERROR, openolt_log_id, "Failed to remove gem, intf_id %d, gemport_id %d, err = %s\n",
Girish Gowdra72cbee92021-11-05 15:16:18 -07001134 intf_id, gemport_id, bcmos_strerror(err));
Girish Gowdracdd5e5f2021-12-05 16:48:08 +05301135 return bcm_to_grpc_err(err, "failed to remove gem");
Thiyagarajan Subramanie976fcf2021-05-07 22:46:57 +05301136 }
Girish Gowdracdd5e5f2021-12-05 16:48:08 +05301137 } else {
1138 OPENOLT_LOG(DEBUG, openolt_log_id, "onu not active or/and not gpon tech, not waiting for gem cfg complete, onu_state = %d, intf = %d, gemport_id = %d, onu=%d\n",
1139 onu_state, intf_id, gemport_id, onu_id);
Thiyagarajan Subramanie976fcf2021-05-07 22:46:57 +05301140 }
1141
Girish Gowdraddf9a162020-01-27 12:56:27 +05301142 OPENOLT_LOG(INFO, openolt_log_id, "gem port removed successfully = %d\n", gemport_id);
1143
Thiyagarajan Subramanie976fcf2021-05-07 22:46:57 +05301144 bcmos_fastlock_lock(&data_lock);
1145 it = gemport_status_map.find(gem_status_key);
1146 if (it != gemport_status_map.end()) {
1147 gemport_status_map.erase(it);
1148 }
1149 bcmos_fastlock_unlock(&data_lock, 0);
1150
Girish Gowdraddf9a162020-01-27 12:56:27 +05301151 return Status::OK;
1152}
1153
Thiyagarajan Subramani19168f52021-05-25 23:26:41 +05301154Status enable_encryption_for_gem_port(int32_t intf_id, int32_t gemport_id, std::string board_technology) {
Burak Gurdaga0523592021-02-24 15:17:47 +00001155 bcmos_errno err;
1156 bcmolt_itupon_gem_cfg cfg;
1157 bcmolt_itupon_gem_key key = {
1158 .pon_ni = (bcmolt_interface)intf_id,
1159 .gem_port_id = (bcmolt_gem_port_id)gemport_id
1160 };
1161
1162 BCMOLT_CFG_INIT(&cfg, itupon_gem, key);
Thiyagarajan Subramaniff9d5ef2021-06-17 12:07:49 +05301163 BCMOLT_MSG_FIELD_GET(&cfg, encryption_mode);
1164 err = bcmolt_cfg_get(dev_id, &cfg.hdr);
1165 if (err != BCM_ERR_OK) {
Girish Gowdra72cbee92021-11-05 15:16:18 -07001166 OPENOLT_LOG(ERROR, openolt_log_id, "GEM port get encryption_mode failed err = %s (%d)\n", cfg.hdr.hdr.err_text, err);
Thiyagarajan Subramaniff9d5ef2021-06-17 12:07:49 +05301167 return bcm_to_grpc_err(err, "GEM port get encryption_mode failed");
1168 }
1169
1170 if (cfg.data.encryption_mode == BCMOLT_CONTROL_STATE_ENABLE) {
1171 OPENOLT_LOG(INFO, openolt_log_id, "gem port already encrypted = %d\n", gemport_id);
1172 return Status::OK;
1173 }
Burak Gurdaga0523592021-02-24 15:17:47 +00001174
1175 bcmolt_control_state encryption_mode;
1176 encryption_mode = BCMOLT_CONTROL_STATE_ENABLE;
1177 BCMOLT_FIELD_SET(&cfg.data, itupon_gem_cfg_data, encryption_mode, encryption_mode);
1178
1179 err = bcmolt_cfg_set(dev_id, &cfg.hdr);
1180 if(err != BCM_ERR_OK) {
1181 OPENOLT_LOG(ERROR, openolt_log_id, "failed to set encryption on pon = %d gem_port = %d, err = %s (%d)\n",
1182 intf_id, gemport_id, cfg.hdr.hdr.err_text, err);
1183 return bcm_to_grpc_err(err, "Failed to set encryption on GEM port");;
1184 }
1185
Thiyagarajan Subramanie976fcf2021-05-07 22:46:57 +05301186#ifndef SCALE_AND_PERF
Thiyagarajan Subramani19168f52021-05-25 23:26:41 +05301187 if (board_technology == "GPON") {
1188 err = wait_for_gem_action(intf_id, gemport_id, GEM_OBJECT_ENCRYPT);
1189 if (err) {
1190 OPENOLT_LOG(ERROR, openolt_log_id, "failed to enable gemport encryption, gem_port = %d err = %s\n", gemport_id, bcmos_strerror(err));
1191 return bcm_to_grpc_err(err, "Access_Control ITU PON Gem port encryption failed");
1192 }
Thiyagarajan Subramanie976fcf2021-05-07 22:46:57 +05301193 }
1194#endif
1195
Burak Gurdaga0523592021-02-24 15:17:47 +00001196 OPENOLT_LOG(INFO, openolt_log_id, "encryption set successfully on pon = %d gem_port = %d\n", intf_id, gemport_id);
1197
1198 return Status::OK;
1199}
1200
Girish Gowdraddf9a162020-01-27 12:56:27 +05301201Status update_acl_interface(int32_t intf_id, bcmolt_interface_type intf_type, uint32_t access_control_id,
1202 bcmolt_members_update_command acl_cmd) {
1203 bcmos_errno err;
1204 bcmolt_access_control_interfaces_update oper; /* declare main API struct */
1205 bcmolt_access_control_key acl_key = {}; /* declare key */
1206 bcmolt_intf_ref interface_ref_list_elem = {};
1207 bcmolt_interface_type interface_ref_list_elem_intf_type;
1208 bcmolt_interface_id interface_ref_list_elem_intf_id;
1209 bcmolt_intf_ref_list_u8 interface_ref_list = {};
1210
1211 if (acl_cmd != BCMOLT_MEMBERS_UPDATE_COMMAND_ADD && acl_cmd != BCMOLT_MEMBERS_UPDATE_COMMAND_REMOVE) {
1212 OPENOLT_LOG(ERROR, openolt_log_id, "acl cmd = %d not supported currently\n", acl_cmd);
1213 return bcm_to_grpc_err(BCM_ERR_PARM, "unsupported acl cmd");
1214 }
1215 interface_ref_list.arr = (bcmolt_intf_ref*)bcmos_calloc(sizeof(bcmolt_intf_ref)*1);
1216
1217 if (interface_ref_list.arr == NULL)
1218 return bcm_to_grpc_err(BCM_ERR_PARM, "allocate interface_ref_list failed");
1219 OPENOLT_LOG(INFO, openolt_log_id, "update acl interface received for intf_id = %d, intf_type = %s, acl_id = %d, acl_cmd = %s\n",
1220 intf_id, intf_type == BCMOLT_INTERFACE_TYPE_PON? "pon": "nni", access_control_id,
1221 acl_cmd == BCMOLT_MEMBERS_UPDATE_COMMAND_ADD? "add": "remove");
1222
1223 acl_key.id = access_control_id;
1224
1225 /* Initialize the API struct. */
1226 BCMOLT_OPER_INIT(&oper, access_control, interfaces_update, acl_key);
1227
1228 bcmolt_members_update_command command;
1229 command = acl_cmd;
1230 BCMOLT_FIELD_SET(&oper.data, access_control_interfaces_update_data, command, command);
1231
1232 interface_ref_list_elem_intf_type = intf_type;
1233 BCMOLT_FIELD_SET(&interface_ref_list_elem, intf_ref, intf_type, interface_ref_list_elem_intf_type);
1234
1235 interface_ref_list_elem_intf_id = intf_id;
1236 BCMOLT_FIELD_SET(&interface_ref_list_elem, intf_ref, intf_id, interface_ref_list_elem_intf_id);
1237
1238 interface_ref_list.len = 1;
1239 BCMOLT_ARRAY_ELEM_SET(&interface_ref_list, 0, interface_ref_list_elem);
1240
1241 BCMOLT_FIELD_SET(&oper.data, access_control_interfaces_update_data, interface_ref_list, interface_ref_list);
1242
1243 err = bcmolt_oper_submit(dev_id, &oper.hdr);
1244 if (err != BCM_ERR_OK) {
1245 OPENOLT_LOG(ERROR, openolt_log_id, "update acl interface fail for intf_id = %d, intf_type = %s, acl_id = %d, acl_cmd = %s\n",
1246 intf_id, intf_type == BCMOLT_INTERFACE_TYPE_PON? "pon": "nni", access_control_id,
1247 acl_cmd == BCMOLT_MEMBERS_UPDATE_COMMAND_ADD? "add": "remove");
1248 return bcm_to_grpc_err(err, "Access_Control submit interface failed");
1249 }
1250
1251 bcmos_free(interface_ref_list.arr);
1252 OPENOLT_LOG(INFO, openolt_log_id, "update acl interface success for intf_id = %d, intf_type = %s, acl_id = %d, acl_cmd = %s\n",
1253 intf_id, intf_type == BCMOLT_INTERFACE_TYPE_PON? "pon": "nni", access_control_id,
1254 acl_cmd == BCMOLT_MEMBERS_UPDATE_COMMAND_ADD? "add": "remove");
1255
1256 return Status::OK;
1257}
1258
1259Status install_acl(const acl_classifier_key acl_key) {
Girish Gowdraddf9a162020-01-27 12:56:27 +05301260 bcmos_errno err;
1261 bcmolt_access_control_cfg cfg;
1262 bcmolt_access_control_key key = { };
1263 bcmolt_classifier c_val = { };
1264 // hardcode the action for now.
1265 bcmolt_access_control_fwd_action_type action_type = BCMOLT_ACCESS_CONTROL_FWD_ACTION_TYPE_TRAP_TO_HOST;
Girish Gowdraddf9a162020-01-27 12:56:27 +05301266 int acl_id = get_acl_id();
1267 if (acl_id < 0) {
Girish Gowdra1935e6a2020-10-31 21:48:22 -07001268 OPENOLT_LOG(ERROR, openolt_log_id, "exhausted acl_id for eth_type = %d, ip_proto = %d, src_port = %d, dst_port = %d o_vid = %d, max_acl_hit=%d\n",
1269 acl_key.ether_type, acl_key.ip_proto, acl_key.src_port, acl_key.dst_port, acl_key.o_vid, max_acls_with_vlan_classifiers_hit);
Girish Gowdraddf9a162020-01-27 12:56:27 +05301270 return bcm_to_grpc_err(BCM_ERR_INTERNAL, "exhausted acl id");
1271 }
1272
1273 key.id = acl_id;
1274 /* config access control instance */
1275 BCMOLT_CFG_INIT(&cfg, access_control, key);
Girish Gowdraddf9a162020-01-27 12:56:27 +05301276 if (acl_key.ether_type > 0) {
1277 OPENOLT_LOG(DEBUG, openolt_log_id, "Access_Control classify ether_type 0x%04x\n", acl_key.ether_type);
1278 BCMOLT_FIELD_SET(&c_val, classifier, ether_type, acl_key.ether_type);
1279 }
1280
1281 if (acl_key.ip_proto > 0) {
1282 OPENOLT_LOG(DEBUG, openolt_log_id, "Access_Control classify ip_proto %d\n", acl_key.ip_proto);
1283 BCMOLT_FIELD_SET(&c_val, classifier, ip_proto, acl_key.ip_proto);
1284 }
1285
1286 if (acl_key.dst_port > 0) {
1287 OPENOLT_LOG(DEBUG, openolt_log_id, "Access_Control classify dst_port %d\n", acl_key.dst_port);
1288 BCMOLT_FIELD_SET(&c_val, classifier, dst_port, acl_key.dst_port);
1289 }
1290
1291 if (acl_key.src_port > 0) {
1292 OPENOLT_LOG(DEBUG, openolt_log_id, "Access_Control classify src_port %d\n", acl_key.src_port);
1293 BCMOLT_FIELD_SET(&c_val, classifier, src_port, acl_key.src_port);
1294 }
1295
Girish Gowdra1935e6a2020-10-31 21:48:22 -07001296 // Make sure that max_acls_with_vlan_classifiers_hit is not true to consider o_vid for ACL classification.
1297 if (acl_key.o_vid > 0 && acl_key.o_vid != ANY_VLAN && !max_acls_with_vlan_classifiers_hit) {
1298 OPENOLT_LOG(DEBUG, openolt_log_id, "Access_Control classify o_vid %d\n", acl_key.o_vid);
1299 BCMOLT_FIELD_SET(&c_val, classifier, o_vid, acl_key.o_vid);
1300 }
1301
Girish Gowdraddf9a162020-01-27 12:56:27 +05301302 BCMOLT_MSG_FIELD_SET(&cfg, classifier, c_val);
1303 BCMOLT_MSG_FIELD_SET(&cfg, priority, 10000);
1304 BCMOLT_MSG_FIELD_SET(&cfg, statistics_control, BCMOLT_CONTROL_STATE_ENABLE);
1305
1306 BCMOLT_MSG_FIELD_SET(&cfg, forwarding_action.action, action_type);
1307
1308 err = bcmolt_cfg_set(dev_id, &cfg.hdr);
1309 if (err != BCM_ERR_OK) {
Girish Gowdra72cbee92021-11-05 15:16:18 -07001310 OPENOLT_LOG(ERROR, openolt_log_id, "Access_Control set configuration failed, err = %s (%d)\n", cfg.hdr.hdr.err_text, err);
Girish Gowdraddf9a162020-01-27 12:56:27 +05301311 // Free the acl_id
1312 free_acl_id(acl_id);
1313 return bcm_to_grpc_err(err, "Access_Control set configuration failed");
1314 }
1315
1316 ACL_LOG(INFO, "ACL add ok", err);
1317
1318 // Update the map that we have installed an acl for the given classfier.
1319 acl_classifier_to_acl_id_map[acl_key] = acl_id;
Girish Gowdra1935e6a2020-10-31 21:48:22 -07001320 // If there was a valid vlan classifier in the ACL and the ACL ID hit the ceiling, set max_acls_with_vlan_classifiers_hit to true
1321 // After max_acls_with_vlan_classifiers_hit is set to true no more ACLs can have vlan as an ACL classifier.
1322 if (acl_key.o_vid > 0 && acl_key.o_vid != ANY_VLAN && acl_id >= MAX_ACL_WITH_VLAN_CLASSIFIER) {
1323 max_acls_with_vlan_classifiers_hit = true;
1324 }
Girish Gowdraddf9a162020-01-27 12:56:27 +05301325 return Status::OK;
1326}
1327
1328Status remove_acl(int acl_id) {
1329 bcmos_errno err;
1330 bcmolt_access_control_cfg cfg; /* declare main API struct */
1331 bcmolt_access_control_key key = {}; /* declare key */
1332
1333 key.id = acl_id;
1334
1335 /* Initialize the API struct. */
1336 BCMOLT_CFG_INIT(&cfg, access_control, key);
1337 BCMOLT_FIELD_SET_PRESENT(&cfg.data, access_control_cfg_data, state);
1338 err = bcmolt_cfg_get(dev_id, &cfg.hdr);
1339 if (err != BCM_ERR_OK) {
Girish Gowdra72cbee92021-11-05 15:16:18 -07001340 OPENOLT_LOG(ERROR, openolt_log_id, "Access_Control get state failed, err = %s (%d)\n", cfg.hdr.hdr.err_text, err);
Girish Gowdraddf9a162020-01-27 12:56:27 +05301341 return bcm_to_grpc_err(err, "Access_Control get state failed");
1342 }
1343
1344 if (cfg.data.state == BCMOLT_CONFIG_STATE_CONFIGURED) {
1345 key.id = acl_id;
1346 /* Initialize the API struct. */
1347 BCMOLT_CFG_INIT(&cfg, access_control, key);
1348
1349 err = bcmolt_cfg_clear(dev_id, &cfg.hdr);
1350 if (err != BCM_ERR_OK) {
1351 // Should we free acl_id here ? We should ideally never land here..
Girish Gowdra72cbee92021-11-05 15:16:18 -07001352 OPENOLT_LOG(ERROR, openolt_log_id, "Error %d while removing Access_Control rule ID err = %s (%d)\n",
1353 acl_id, cfg.hdr.hdr.err_text, err);
Girish Gowdraddf9a162020-01-27 12:56:27 +05301354 return Status(grpc::StatusCode::INTERNAL, "Failed to remove Access_Control");
1355 }
1356 }
1357
1358 // Free up acl_id
1359 free_acl_id(acl_id);
1360
1361 OPENOLT_LOG(INFO, openolt_log_id, "acl removed successfully %d\n", acl_id);
1362
1363 return Status::OK;
1364}
1365
1366// Formulates ACL Classifier Key based on the following fields
1367// a. ether_type b. ip_proto c. src_port d. dst_port
1368// If any of the field is not available it is populated as -1.
1369void formulate_acl_classifier_key(acl_classifier_key *key, const ::openolt::Classifier& classifier) {
1370
1371 // TODO: Is 0 a valid value for any of the following classifiers?
1372 // because in the that case, the 'if' check would fail and -1 would be filled as value.
1373 //
1374 if (classifier.eth_type()) {
1375 OPENOLT_LOG(DEBUG, openolt_log_id, "classify ether_type 0x%04x\n", classifier.eth_type());
1376 key->ether_type = classifier.eth_type();
1377 } else key->ether_type = -1;
1378
1379 if (classifier.ip_proto()) {
1380 OPENOLT_LOG(DEBUG, openolt_log_id, "classify ip_proto %d\n", classifier.ip_proto());
1381 key->ip_proto = classifier.ip_proto();
1382 } else key->ip_proto = -1;
1383
1384
1385 if (classifier.src_port()) {
1386 OPENOLT_LOG(DEBUG, openolt_log_id, "classify src_port %d\n", classifier.src_port());
1387 key->src_port = classifier.src_port();
1388 } else key->src_port = -1;
1389
1390
1391 if (classifier.dst_port()) {
1392 OPENOLT_LOG(DEBUG, openolt_log_id, "classify dst_port %d\n", classifier.dst_port());
1393 key->dst_port = classifier.dst_port();
1394 } else key->dst_port = -1;
Girish Gowdra1935e6a2020-10-31 21:48:22 -07001395
1396 // We should also check the max_acls_with_vlan_classifiers_hit flag is not false to consider the vlan for flow classifier key
1397 if (classifier.o_vid() && !max_acls_with_vlan_classifiers_hit) {
1398 OPENOLT_LOG(DEBUG, openolt_log_id, "classify o_vid %d\n", classifier.o_vid());
1399 key->o_vid = classifier.o_vid();
1400 } else key->o_vid = ANY_VLAN;
1401
Girish Gowdraddf9a162020-01-27 12:56:27 +05301402}
1403
Girish Gowdra1935e6a2020-10-31 21:48:22 -07001404Status handle_acl_rule_install(int32_t onu_id, uint64_t flow_id, int32_t gemport_id,
Girish Gowdraddf9a162020-01-27 12:56:27 +05301405 const std::string flow_type, int32_t access_intf_id,
Girish Gowdra252f4972020-09-07 21:24:01 -07001406 int32_t network_intf_id,
Girish Gowdraddf9a162020-01-27 12:56:27 +05301407 const ::openolt::Classifier& classifier) {
1408 int acl_id;
Girish Gowdrafc6c0bf2022-01-28 18:31:30 -08001409 uint32_t intf_id = flow_type == upstream? access_intf_id: network_intf_id;
1410 const std::string intf_type = flow_type == upstream? "pon": "nni";
Girish Gowdraddf9a162020-01-27 12:56:27 +05301411 bcmolt_interface_type olt_if_type = intf_type == "pon"? BCMOLT_INTERFACE_TYPE_PON: BCMOLT_INTERFACE_TYPE_NNI;
1412
1413 Status resp;
Girish Gowdra1935e6a2020-10-31 21:48:22 -07001414 trap_to_host_packet_type pkt_type = get_trap_to_host_packet_type(classifier);
1415 if (pkt_type == unsupported_trap_to_host_pkt_type) {
1416 OPENOLT_LOG(ERROR, openolt_log_id, "unsupported pkt trap type");
1417 return Status(grpc::StatusCode::UNIMPLEMENTED, "unsupported pkt trap type");
1418 }
Girish Gowdraddf9a162020-01-27 12:56:27 +05301419
1420 // few map keys we are going to use later.
1421 flow_id_flow_direction fl_id_fl_dir(flow_id, flow_type);
Girish Gowdra252f4972020-09-07 21:24:01 -07001422
Girish Gowdraddf9a162020-01-27 12:56:27 +05301423 acl_classifier_key acl_key;
1424 formulate_acl_classifier_key(&acl_key, classifier);
1425 const acl_classifier_key acl_key_const = {.ether_type=acl_key.ether_type, .ip_proto=acl_key.ip_proto,
Girish Gowdra1935e6a2020-10-31 21:48:22 -07001426 .src_port=acl_key.src_port, .dst_port=acl_key.dst_port, .o_vid=acl_key.o_vid};
1427 bcmos_fastlock_lock(&acl_packet_trap_handler_lock);
Girish Gowdraddf9a162020-01-27 12:56:27 +05301428
1429 // Check if the acl is already installed
1430 if (acl_classifier_to_acl_id_map.count(acl_key_const) > 0) {
1431 // retreive the acl_id
1432 acl_id = acl_classifier_to_acl_id_map[acl_key_const];
Girish Gowdra252f4972020-09-07 21:24:01 -07001433
1434
Girish Gowdraddf9a162020-01-27 12:56:27 +05301435 if (flow_to_acl_map.count(fl_id_fl_dir)) {
Girish Gowdra1935e6a2020-10-31 21:48:22 -07001436 // could happen if same trap flow is received again
Girish Gowdraddf9a162020-01-27 12:56:27 +05301437 OPENOLT_LOG(INFO, openolt_log_id, "flow and related acl already handled, nothing more to do\n");
Girish Gowdra1935e6a2020-10-31 21:48:22 -07001438 bcmos_fastlock_unlock(&acl_packet_trap_handler_lock, 0);
Girish Gowdraddf9a162020-01-27 12:56:27 +05301439 return Status::OK;
1440 }
1441
Girish Gowdra1935e6a2020-10-31 21:48:22 -07001442 OPENOLT_LOG(INFO, openolt_log_id, "Acl for flow_id=%lu with eth_type = %d, ip_proto = %d, src_port = %d, dst_port = %d o_vid = %d already installed with acl id = %u\n",
1443 flow_id, acl_key.ether_type, acl_key.ip_proto, acl_key.src_port, acl_key.dst_port, acl_key.o_vid, acl_id);
Girish Gowdraddf9a162020-01-27 12:56:27 +05301444
1445 // The acl_ref_cnt is needed to know how many flows refer an ACL.
1446 // When the flow is removed, we decrement the reference count.
1447 // When the reference count becomes 0, we remove the ACL.
1448 if (acl_ref_cnt.count(acl_id) > 0) {
1449 acl_ref_cnt[acl_id] ++;
1450 } else {
1451 // We should ideally not land here. The acl_ref_cnt should have been
1452 // initialized the first time acl was installed.
1453 acl_ref_cnt[acl_id] = 1;
1454 }
1455
1456 } else {
1457 resp = install_acl(acl_key_const);
1458 if (!resp.ok()) {
Girish Gowdra1935e6a2020-10-31 21:48:22 -07001459 OPENOLT_LOG(ERROR, openolt_log_id, "Acl for flow_id=%lu with eth_type = %d, ip_proto = %d, src_port = %d, dst_port = %d o_vid = %d failed\n",
1460 flow_id, acl_key_const.ether_type, acl_key_const.ip_proto, acl_key_const.src_port, acl_key_const.dst_port, acl_key_const.o_vid);
1461 bcmos_fastlock_unlock(&acl_packet_trap_handler_lock, 0);
Girish Gowdraddf9a162020-01-27 12:56:27 +05301462 return resp;
1463 }
1464
1465 acl_id = acl_classifier_to_acl_id_map[acl_key_const];
1466
1467 // Initialize the acl reference count
1468 acl_ref_cnt[acl_id] = 1;
1469
Girish Gowdra252f4972020-09-07 21:24:01 -07001470 OPENOLT_LOG(INFO, openolt_log_id, "acl add success for flow_id=%lu with acl_id=%d\n", flow_id, acl_id);
Girish Gowdraddf9a162020-01-27 12:56:27 +05301471 }
1472
1473 // Register the interface for the given acl
1474 acl_id_intf_id_intf_type ac_id_inf_id_inf_type(acl_id, intf_id, intf_type);
1475 // This is needed to keep a track of which interface (pon/nni) has registered for an ACL.
1476 // If it is registered, how many flows refer to it.
1477 if (intf_acl_registration_ref_cnt.count(ac_id_inf_id_inf_type) > 0) {
1478 intf_acl_registration_ref_cnt[ac_id_inf_id_inf_type]++;
1479 } else {
1480 // The given interface is not registered for the ACL. We need to do it now.
1481 resp = update_acl_interface(intf_id, olt_if_type, acl_id, BCMOLT_MEMBERS_UPDATE_COMMAND_ADD);
1482 if (!resp.ok()){
1483 OPENOLT_LOG(ERROR, openolt_log_id, "failed to update acl interfaces intf_id=%d, intf_type=%s, acl_id=%d", intf_id, intf_type.c_str(), acl_id);
1484 // TODO: Ideally we should return error from hear and clean up other other stateful
1485 // counters we creaed earlier. Will leave it out for now.
Girish Gowdra252f4972020-09-07 21:24:01 -07001486 }
Girish Gowdraddf9a162020-01-27 12:56:27 +05301487 intf_acl_registration_ref_cnt[ac_id_inf_id_inf_type] = 1;
1488 }
1489
Girish Gowdra252f4972020-09-07 21:24:01 -07001490 acl_id_intf_id ac_id_if_id(acl_id, intf_id);
1491 flow_to_acl_map[fl_id_fl_dir] = ac_id_if_id;
Girish Gowdraddf9a162020-01-27 12:56:27 +05301492
Girish Gowdra1935e6a2020-10-31 21:48:22 -07001493 // Populate the trap_to_host_pkt_info_with_vlan corresponding to the trap-to-host voltha flow_id key.
1494 // When the trap-to-host voltha flow-id is being removed, this entry is cleared too from the map.
1495 trap_to_host_pkt_info_with_vlan pkt_info_with_vlan((int32_t)olt_if_type, intf_id, (int32_t)pkt_type, gemport_id, (short unsigned int)classifier.o_vid());
1496 trap_to_host_pkt_info_with_vlan_for_flow_id[flow_id] = pkt_info_with_vlan;
1497 trap_to_host_pkt_info pkt_info((int32_t)olt_if_type, intf_id, (int32_t)pkt_type, gemport_id);
1498 bool duplicate = false;
1499 // Check if the vlan_id corresponding to the trap_to_host_pkt_info key is found. Set the 'duplicate' flag accordingly.
1500 if (trap_to_host_vlan_ids_for_trap_to_host_pkt_info.count(pkt_info) > 0) {
1501 auto& vlan_id_list = trap_to_host_vlan_ids_for_trap_to_host_pkt_info[pkt_info];
1502 auto it = std::find(vlan_id_list.begin(), vlan_id_list.end(), acl_key.o_vid);
1503 if (it != vlan_id_list.end()) {
1504 OPENOLT_LOG(DEBUG, openolt_log_id, "cvid = %d exists already in list", acl_key.o_vid);
1505 duplicate = true;
1506 }
1507 }
1508 // If the vlan_id is not found corresponding to the trap_to_host_pkt_info key, update it.
1509 // This will be used to validate the vlan_id in the trapped packet. If vlan_id in the
1510 // trapped packet is not match with the stored value, packet is dropped.
1511 if (!duplicate) {
1512 trap_to_host_vlan_ids_for_trap_to_host_pkt_info[pkt_info].push_back(acl_key.o_vid);
1513 }
1514
1515 bcmos_fastlock_unlock(&acl_packet_trap_handler_lock, 0);
Girish Gowdraddf9a162020-01-27 12:56:27 +05301516
1517 return Status::OK;
1518}
1519
Girish Gowdra252f4972020-09-07 21:24:01 -07001520Status handle_acl_rule_cleanup(int16_t acl_id, int32_t intf_id, const std::string flow_type) {
Girish Gowdrafc6c0bf2022-01-28 18:31:30 -08001521 const std::string intf_type= flow_type == upstream? "pon": "nni";
Girish Gowdraddf9a162020-01-27 12:56:27 +05301522 acl_id_intf_id_intf_type ac_id_inf_id_inf_type(acl_id, intf_id, intf_type);
1523 intf_acl_registration_ref_cnt[ac_id_inf_id_inf_type]--;
1524 if (intf_acl_registration_ref_cnt[ac_id_inf_id_inf_type] == 0) {
1525 bcmolt_interface_type olt_if_type = intf_type == "pon"? BCMOLT_INTERFACE_TYPE_PON: BCMOLT_INTERFACE_TYPE_NNI;
1526 Status resp = update_acl_interface(intf_id, olt_if_type, acl_id, BCMOLT_MEMBERS_UPDATE_COMMAND_REMOVE);
1527 if (!resp.ok()){
1528 OPENOLT_LOG(ERROR, openolt_log_id, "failed to update acl interfaces intf_id=%d, intf_type=%s, acl_id=%d", intf_id, intf_type.c_str(), acl_id);
1529 }
1530 intf_acl_registration_ref_cnt.erase(ac_id_inf_id_inf_type);
1531 }
1532
1533 acl_ref_cnt[acl_id]--;
1534 if (acl_ref_cnt[acl_id] == 0) {
1535 remove_acl(acl_id);
1536 acl_ref_cnt.erase(acl_id);
1537 // Iterate acl_classifier_to_acl_id_map and delete classifier the key corresponding to acl_id
1538 std::map<acl_classifier_key, uint16_t>::iterator it;
1539 for (it=acl_classifier_to_acl_id_map.begin(); it!=acl_classifier_to_acl_id_map.end(); ++it) {
1540 if (it->second == acl_id) {
1541 OPENOLT_LOG(INFO, openolt_log_id, "cleared classifier key corresponding to acl_id = %d\n", acl_id);
1542 acl_classifier_to_acl_id_map.erase(it->first);
1543 break;
1544 }
1545 }
1546 }
1547
Girish Gowdraddf9a162020-01-27 12:56:27 +05301548 return Status::OK;
1549}
1550
1551Status check_bal_ready() {
1552 bcmos_errno err;
1553 int maxTrials = 30;
1554 bcmolt_olt_cfg olt_cfg = { };
1555 bcmolt_olt_key olt_key = { };
1556
1557 BCMOLT_CFG_INIT(&olt_cfg, olt, olt_key);
1558 BCMOLT_MSG_FIELD_GET(&olt_cfg, bal_state);
1559
1560 while (olt_cfg.data.bal_state != BCMOLT_BAL_STATE_BAL_AND_SWITCH_READY) {
1561 if (--maxTrials == 0)
1562 return grpc::Status(grpc::StatusCode::UNAVAILABLE, "check bal ready failed");
1563 sleep(5);
1564 #ifdef TEST_MODE
1565 // It is impossible to mock the setting of olt_cfg.data.bal_state because
1566 // the actual bcmolt_cfg_get passes the address of olt_cfg.hdr and we cannot
1567 // set the olt_cfg.data.bal_state. So a new stub function is created and address
1568 // of olt_cfg is passed. This is one-of case where we need to add test specific
1569 // code in production code.
1570 if (bcmolt_cfg_get__bal_state_stub(dev_id, &olt_cfg)) {
1571 #else
1572 if (bcmolt_cfg_get(dev_id, &olt_cfg.hdr)) {
1573 #endif
1574 continue;
1575 }
1576 else
1577 OPENOLT_LOG(INFO, openolt_log_id, "waiting for BAL ready ...\n");
1578 }
1579
1580 OPENOLT_LOG(INFO, openolt_log_id, "BAL is ready\n");
1581 return Status::OK;
1582}
1583
1584Status check_connection() {
1585 int maxTrials = 60;
1586 while (!bcmolt_api_conn_mgr_is_connected(dev_id)) {
1587 sleep(1);
1588 if (--maxTrials == 0)
1589 return grpc::Status(grpc::StatusCode::UNAVAILABLE, "check connection failed");
1590 else
1591 OPENOLT_LOG(INFO, openolt_log_id, "waiting for daemon connection ...\n");
1592 }
1593 OPENOLT_LOG(INFO, openolt_log_id, "daemon is connected\n");
1594 return Status::OK;
1595}
1596
Thiyagarajan Subramani03bc66f2020-04-01 15:58:53 +05301597std::string get_ip_address(const char* nw_intf){
1598 std::string ipAddress = "0.0.0.0";
1599 struct ifaddrs *interfaces = NULL;
1600 struct ifaddrs *temp_addr = NULL;
1601 int success = 0;
1602 /* retrieve the current interfaces - returns 0 on success */
1603 success = getifaddrs(&interfaces);
1604 if (success == 0) {
1605 /* Loop through linked list of interfaces */
1606 temp_addr = interfaces;
1607 while(temp_addr != NULL) {
1608 if(temp_addr->ifa_addr->sa_family == AF_INET) {
1609 /* Check if interface given present in OLT, if yes return its IP Address */
1610 if(strcmp(temp_addr->ifa_name, nw_intf) == 0){
1611 ipAddress=inet_ntoa(((struct sockaddr_in*)temp_addr->ifa_addr)->sin_addr);
1612 break;
1613 }
1614 }
1615 temp_addr = temp_addr->ifa_next;
1616 }
1617 }
1618 /* Free memory */
1619 freeifaddrs(interfaces);
1620 return ipAddress;
1621}
Jason Huang1d9cfce2020-05-20 22:58:47 +08001622
1623bcmos_errno getOnuMaxLogicalDistance(uint32_t intf_id, uint32_t *mld) {
1624 bcmos_errno err = BCM_ERR_OK;
1625 bcmolt_pon_distance pon_distance = {};
1626 bcmolt_pon_interface_cfg pon_cfg; /* declare main API struct */
1627 bcmolt_pon_interface_key key = {}; /* declare key */
1628
1629 key.pon_ni = intf_id;
1630
1631 if (!state.is_activated()) {
1632 OPENOLT_LOG(ERROR, openolt_log_id, "ONU maximum logical distance is not available since OLT is not activated yet\n");
1633 return BCM_ERR_STATE;
1634 }
1635
1636 /* Initialize the API struct. */
1637 BCMOLT_CFG_INIT(&pon_cfg, pon_interface, key);
1638 BCMOLT_FIELD_SET_PRESENT(&pon_distance, pon_distance, max_log_distance);
1639 BCMOLT_FIELD_SET(&pon_cfg.data, pon_interface_cfg_data, pon_distance, pon_distance);
1640 #ifdef TEST_MODE
1641 // It is impossible to mock the setting of pon_cfg.data.state because
1642 // the actual bcmolt_cfg_get passes the address of pon_cfg.hdr and we cannot
1643 // set the pon_cfg.data.state. So a new stub function is created and address
1644 // of pon_cfg is passed. This is one-of case where we need to add test specific
1645 // code in production code.
1646 err = bcmolt_cfg_get__pon_intf_stub(dev_id, &pon_cfg);
1647 #else
1648 err = bcmolt_cfg_get(dev_id, &pon_cfg.hdr);
1649 #endif
1650 if (err != BCM_ERR_OK) {
Girish Gowdra72cbee92021-11-05 15:16:18 -07001651 OPENOLT_LOG(ERROR, openolt_log_id, "Failed to retrieve ONU maximum logical distance for PON %d, err = %s (%d)\n", intf_id, pon_cfg.hdr.hdr.err_text, err);
Jason Huang1d9cfce2020-05-20 22:58:47 +08001652 return err;
1653 }
1654 *mld = pon_distance.max_log_distance;
1655
1656 return BCM_ERR_OK;
1657}
Humera Kouser6143c9e2020-06-17 22:37:31 +05301658
1659/**
1660* Gets mac address based on interface name.
1661*
1662* @param intf_name interface name
1663* @param mac_address mac address field
1664* @param max_size_of_mac_address max sixe of the mac_address
1665* @return mac_address value in case of success or return NULL in case of failure.
1666*/
1667
1668char* get_intf_mac(const char* intf_name, char* mac_address, unsigned int max_size_of_mac_address){
1669 int fd;
1670 struct ifreq ifr;
1671 char *mac;
1672
1673 fd = socket(AF_INET, SOCK_DGRAM, 0);
1674 if ( fd == -1) {
1675 OPENOLT_LOG(ERROR, openolt_log_id, "failed to get mac, could not create file descriptor");
1676 return NULL;
1677 }
1678
1679 ifr.ifr_addr.sa_family = AF_INET;
1680 strncpy((char *)ifr.ifr_name , (const char *)intf_name , IFNAMSIZ-1);
1681 if( ioctl(fd, SIOCGIFHWADDR, &ifr) == -1)
1682 {
1683 OPENOLT_LOG(ERROR, openolt_log_id, "failed to get mac, ioctl failed and returned err");
1684 close(fd);
1685 return NULL;
1686 }
1687
1688 close(fd);
1689 mac = (char *)ifr.ifr_hwaddr.sa_data;
1690
1691 // formatted mac address
1692 snprintf(mac_address, max_size_of_mac_address, (const char *)"%.2x:%.2x:%.2x:%.2x:%.2x:%.2x", (unsigned char)mac[0], (unsigned char)mac[1], (unsigned char)mac[2], (unsigned char)mac[3], (unsigned char)mac[4], (unsigned char)mac[5]);
1693
1694 return mac_address;
1695}
Girish Gowdra252f4972020-09-07 21:24:01 -07001696
1697void update_voltha_flow_to_cache(uint64_t voltha_flow_id, device_flow dev_flow) {
1698 OPENOLT_LOG(DEBUG, openolt_log_id, "updating voltha flow=%lu to cache\n", voltha_flow_id)
1699 bcmos_fastlock_lock(&voltha_flow_to_device_flow_lock);
1700 voltha_flow_to_device_flow[voltha_flow_id] = dev_flow;
1701 bcmos_fastlock_unlock(&voltha_flow_to_device_flow_lock, 0);
1702}
1703
1704void remove_voltha_flow_from_cache(uint64_t voltha_flow_id) {
1705 bcmos_fastlock_lock(&voltha_flow_to_device_flow_lock);
1706 std::map<uint64_t, device_flow>::const_iterator it = voltha_flow_to_device_flow.find(voltha_flow_id);
1707 if (it != voltha_flow_to_device_flow.end()) {
1708 voltha_flow_to_device_flow.erase(it);
1709 }
1710 bcmos_fastlock_unlock(&voltha_flow_to_device_flow_lock, 0);
1711}
1712
1713bool is_voltha_flow_installed(uint64_t voltha_flow_id ) {
1714 int count;
1715 bcmos_fastlock_lock(&voltha_flow_to_device_flow_lock);
1716 count = voltha_flow_to_device_flow.count(voltha_flow_id);
1717 bcmos_fastlock_unlock(&voltha_flow_to_device_flow_lock, 0);
1718
1719 return count > 0 ? true : false;
1720}
1721
1722const device_flow_params* get_device_flow_params(uint64_t voltha_flow_id) {
1723 bcmos_fastlock_lock(&voltha_flow_to_device_flow_lock);
1724 std::map<uint64_t, device_flow>::const_iterator it = voltha_flow_to_device_flow.find(voltha_flow_id);
1725 if (it != voltha_flow_to_device_flow.end()) {
1726 bcmos_fastlock_unlock(&voltha_flow_to_device_flow_lock, 0);
1727 return it->second.params;
1728 }
1729 bcmos_fastlock_unlock(&voltha_flow_to_device_flow_lock, 0);
1730
1731 return NULL;
1732}
1733
1734const device_flow* get_device_flow(uint64_t voltha_flow_id) {
1735 bcmos_fastlock_lock(&voltha_flow_to_device_flow_lock);
1736 std::map<uint64_t, device_flow>::const_iterator it = voltha_flow_to_device_flow.find(voltha_flow_id);
1737 if (it != voltha_flow_to_device_flow.end()) {
1738 bcmos_fastlock_unlock(&voltha_flow_to_device_flow_lock, 0);
1739 return &it->second;
1740 }
1741 bcmos_fastlock_unlock(&voltha_flow_to_device_flow_lock, 0);
1742
1743 return NULL;
1744}
Girish Gowdra1935e6a2020-10-31 21:48:22 -07001745
1746trap_to_host_packet_type get_trap_to_host_packet_type(const ::openolt::Classifier& classifier) {
1747 trap_to_host_packet_type type = unsupported_trap_to_host_pkt_type;
1748 if (classifier.eth_type() == EAP_ETH_TYPE) {
1749 type = eap;
1750 } else if (classifier.src_port() == DHCP_SERVER_SRC_PORT || classifier.src_port() == DHCP_CLIENT_SRC_PORT) {
1751 type = dhcpv4;
1752 } else if (classifier.eth_type() == LLDP_ETH_TYPE) {
1753 type = lldp;
1754 } else if (classifier.ip_proto() == IGMPv4_PROTOCOL) {
1755 type = igmpv4;
Marcos Aurelio Carrero (Furukawa)c4c56b32021-03-08 12:20:34 -03001756 } else if (classifier.eth_type() == PPPoED_ETH_TYPE) {
Marcos Aurelio Carrero (Furukawa)cfe3e0d2021-03-03 10:36:56 -03001757 type = pppoed;
Girish Gowdra1935e6a2020-10-31 21:48:22 -07001758 }
1759
1760 return type;
1761}
1762
1763// is_packet_allowed extracts the VLAN, packet-type, interface-type, interface-id from incoming trap-to-host packet.
1764// Then it verifies if this packet can be allowed upstream to host. It does this by checking if the vlan in the incoming packet
1765//exists in trap_to_host_vlan_ids_for_trap_to_host_pkt_info map for (interface-type, interface-id, packet-type) key.
1766bool is_packet_allowed(bcmolt_access_control_receive_eth_packet_data *data, int32_t gemport_id) {
1767 bcmolt_interface_type intf_type = data->interface_ref.intf_type;
1768 uint32_t intf_id = data->interface_ref.intf_id;
1769 trap_to_host_packet_type pkt_type = unsupported_trap_to_host_pkt_type;
1770 uint16_t vlan_id = 0;
1771 int ethType;
1772
1773 struct timeval dummy_tv = {0, 0};
1774 bool free_memory_of_raw_packet = false; // This indicates the pcap library to not free the message buffer. It will freed by the caller.
1775
1776 pcpp::RawPacket rawPacket(data->buffer.arr, data->buffer.len, dummy_tv, free_memory_of_raw_packet, pcpp::LINKTYPE_ETHERNET);
1777 pcpp::Packet parsedPacket(&rawPacket);
1778 pcpp::EthLayer* ethernetLayer = parsedPacket.getLayerOfType<pcpp::EthLayer>();
1779 if (ethernetLayer == NULL)
1780 {
1781 OPENOLT_LOG(ERROR, openolt_log_id, "Something went wrong, couldn't find Ethernet layer\n");
1782 return false;
1783 }
1784
1785 // Getting Vlan layer
1786 pcpp::VlanLayer* vlanLayer = parsedPacket.getLayerOfType<pcpp::VlanLayer>();
1787 if (vlanLayer == NULL)
1788 {
1789 // Allow Untagged LLDP Ether type packet to trap from NNI
1790 if (ntohs(ethernetLayer->getEthHeader()->etherType) == LLDP_ETH_TYPE && intf_type == BCMOLT_INTERFACE_TYPE_NNI) {
1791 return true;
1792 } else {
1793 OPENOLT_LOG(WARNING, openolt_log_id, "untagged packets other than lldp packets are dropped. ethertype=%d, intftype=%d, intf_id=%d\n",
1794 ntohs(ethernetLayer->getEthHeader()->etherType), intf_type, intf_id);
1795 return false;
1796 }
1797 } else {
1798 ethType = ntohs(vlanLayer->getVlanHeader()->etherType);
1799 if (ethType == EAP_ETH_TYPE) { // single tagged packet with EAPoL payload
1800 vlan_id = vlanLayer->getVlanID();
1801 pkt_type = eap;
Marcos Aurelio Carrero (Furukawa)cfe3e0d2021-03-03 10:36:56 -03001802 } else if (ethType == PPPoED_ETH_TYPE) { // single tagged packet with PPPOeD payload
1803 vlan_id = vlanLayer->getVlanID();
1804 pkt_type = pppoed;
Girish Gowdra1935e6a2020-10-31 21:48:22 -07001805 } else if (ethType == IPV4_ETH_TYPE) { // single tagged packet with IPv4 payload
1806 vlan_id = vlanLayer->getVlanID();
1807 vlanLayer->parseNextLayer();
1808 pcpp::IPv4Layer *ipv4Layer = (pcpp::IPv4Layer*)vlanLayer->getNextLayer();
1809 if(ipv4Layer->getIPv4Header()->protocol == UDP_PROTOCOL) { // UDP payload
1810 // Check the UDP Ports to see if it is a DHCPv4 packet
1811 ipv4Layer->parseNextLayer();
1812 pcpp::UdpLayer *udpLayer = (pcpp::UdpLayer*)ipv4Layer->getNextLayer();
1813 if (ntohs(udpLayer->getUdpHeader()->portSrc) == DHCP_SERVER_SRC_PORT|| ntohs(udpLayer->getUdpHeader()->portSrc) == DHCP_CLIENT_SRC_PORT) {
1814 pkt_type = dhcpv4;
1815 } else {
1816 OPENOLT_LOG(ERROR, openolt_log_id, "unsupported udp source port = %d\n", ntohs(udpLayer->getUdpHeader()->portSrc));
1817 return false;
1818 }
1819 } else if (ipv4Layer->getIPv4Header()->protocol == IGMPv4_PROTOCOL) { // Igmpv4 payload
1820 pkt_type = igmpv4;
1821 } else {
1822 OPENOLT_LOG(ERROR, openolt_log_id, "unsupported ip protocol = %d\n", ipv4Layer->getIPv4Header()->protocol);
1823 return false;
1824 }
1825 } else if (ethType == VLAN_ETH_TYPE) { // double tagged packet
1826
1827 // Trap-to-host from NNI flows do not specify the VLANs, so no vlan validation is necessary.
1828 if (intf_type == BCMOLT_INTERFACE_TYPE_NNI) {
1829 return true;
1830 }
1831
1832 // Here we parse the inner vlan payload and currently support only IPv4 packets
1833
1834 // Extract the vlan_id for trap-to-host packets arriving from the PON
1835 // trap-to-host ACLs from the NNI do not care about VLAN.
1836 if (intf_type == BCMOLT_INTERFACE_TYPE_PON) {
1837 vlan_id = vlanLayer->getVlanID(); // This is the outer vlan id
1838 }
1839 vlanLayer->parseNextLayer();
1840 vlanLayer = (pcpp::VlanLayer*)vlanLayer->getNextLayer(); // Here we extract the inner vlan layer
1841 ethType = ntohs(vlanLayer->getVlanHeader()->etherType);
1842 if (ethType == IPV4_ETH_TYPE) { // IPv4
1843 uint16_t _inner_vlan_id = vlanLayer->getVlanID();
1844 vlanLayer->parseNextLayer();
1845 pcpp::IPv4Layer *ipv4Layer = (pcpp::IPv4Layer*)vlanLayer->getNextLayer(); // here we extract the inner vlan IPv4 payload
1846 if(ipv4Layer->getIPv4Header()->protocol == UDP_PROTOCOL) { // UDP payload
1847 // Check the UDP Ports to see if it is a DHCPv4 packet
1848 ipv4Layer->parseNextLayer();
1849 pcpp::UdpLayer *udpLayer = (pcpp::UdpLayer*)ipv4Layer->getNextLayer();
1850 if (ntohs(udpLayer->getUdpHeader()->portSrc) == DHCP_SERVER_SRC_PORT || ntohs(udpLayer->getUdpHeader()->portSrc) == DHCP_CLIENT_SRC_PORT) {
1851 pkt_type = dhcpv4;
1852 } else {
1853 OPENOLT_LOG(ERROR, openolt_log_id, "unsupported udp source port = %d\n", ntohs(udpLayer->getUdpHeader()->portSrc));
1854 return false;
1855 }
1856 } else if (ipv4Layer->getIPv4Header()->protocol == IGMPv4_PROTOCOL) { // Igmpv4 payload
1857 pkt_type = igmpv4;
1858 } else {
1859 OPENOLT_LOG(ERROR, openolt_log_id, "unsupported ip protocol = %d\n", ipv4Layer->getIPv4Header()->protocol)
1860 return false;
1861 }
1862 }
1863 } else {
1864 OPENOLT_LOG(ERROR, openolt_log_id, "unsupported ether type = 0x%x\n", ntohs((vlanLayer->getVlanHeader()->etherType)));
1865 return false;
1866 }
1867 }
1868
1869#if 0 // Debug logs for test purpose only
1870 std::cout << "vlan of received packet " << vlan_id << " intf_type " << intf_type << " intf_id " <<intf_id << " pkt_type " <<pkt_type << " gem_port_id" << gemport_id << "\n";
1871 for(std::map<trap_to_host_pkt_info, std::list<uint16_t> >::const_iterator it = trap_to_host_vlan_ids_for_trap_to_host_pkt_info.begin();
1872 it != trap_to_host_vlan_ids_for_trap_to_host_pkt_info.end(); ++it)
1873 {
1874 std::cout << "value entries" << " " << std::get<0>(it->first) << " "<< std::get<1>(it->first) << " "<< std::get<2>(it->first) << " "<< std::get<3>(it->first) << "\n\n";
1875 std::cout << "vlans for the above key are => ";
1876 for (std::list<uint16_t>::const_iterator _it=it->second.begin();
1877 _it != it->second.end();
1878 ++_it) {
1879 std::cout << *_it << " ";
1880 }
1881 std::cout << "\n\n";
1882 }
1883#endif
1884
1885 trap_to_host_pkt_info pkt_info(intf_type, intf_id, pkt_type, gemport_id);
1886 // Check for matching vlan only if the trap_to_host_pkt_info exists in the trap_to_host_vlan_ids_for_trap_to_host_pkt_info map
1887 if (trap_to_host_vlan_ids_for_trap_to_host_pkt_info.count(pkt_info) > 0) {
1888 // Iterate throught the vlan list to find matching vlan
1889 auto& vlan_id_list = trap_to_host_vlan_ids_for_trap_to_host_pkt_info[pkt_info];
1890 for (auto allowed_vlan_id : vlan_id_list) {
1891 // Found exact matching vlan in the allowed list of vlans for the trap_to_host_pkt_info key or
1892 // there is generic match ANY_VLAN in the list in the allowed vlan list.
1893 if (allowed_vlan_id == vlan_id || allowed_vlan_id == ANY_VLAN) {
1894 return true;
1895 }
1896 }
1897 }
1898 return false;
1899}
Orhan Kupusoglu1fd77072021-03-23 08:13:25 -07001900
1901std::pair<grpc_ssl_client_certificate_request_type, bool> get_grpc_tls_option(const char* tls_option) {
Girish Gowdra262b6292021-07-21 15:32:17 -07001902 static const std::map<std::string,grpc_ssl_client_certificate_request_type> grpc_security_option_map = {{"GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE",
Orhan Kupusoglu1fd77072021-03-23 08:13:25 -07001903 grpc_ssl_client_certificate_request_type::GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE},
1904 {"GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_BUT_DONT_VERIFY",
1905 grpc_ssl_client_certificate_request_type::GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_BUT_DONT_VERIFY},
1906 {"GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_AND_VERIFY",
1907 grpc_ssl_client_certificate_request_type::GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_AND_VERIFY},
1908 {"GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_BUT_DONT_VERIFY",
1909 grpc_ssl_client_certificate_request_type::GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_BUT_DONT_VERIFY},
1910 {"GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY",
1911 grpc_ssl_client_certificate_request_type::GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY}};
1912
1913 auto it = grpc_security_option_map.find(tls_option);
1914 if (it == grpc_security_option_map.end()) {
1915 OPENOLT_LOG(ERROR, openolt_log_id, "invalid gRPC Server security option: %s\n", tls_option);
1916 return {grpc_ssl_client_certificate_request_type::GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE, false};
1917 } else {
1918 OPENOLT_LOG(INFO, openolt_log_id, "valid gRPC Server security option: %s\n", tls_option);
1919 tls_option_arg = std::string{tls_option};
1920 return {it->second, true};
1921 }
1922}
1923
1924const std::string &get_grpc_tls_option() {
1925 return tls_option_arg;
1926}
1927
1928bool is_grpc_secure() {
1929 return !tls_option_arg.empty();
1930}
1931
1932std::pair<std::string, bool> read_from_txt_file(const std::string& file_name) {
1933 std::ifstream in_file(file_name);
1934
1935 if (!in_file.is_open()) {
1936 OPENOLT_LOG(ERROR, openolt_log_id, "error opening file '%s'\n", file_name.c_str());
1937 return {"", false};
1938 }
1939
1940 std::stringstream buffer;
1941 buffer << in_file.rdbuf();
1942
1943 return {buffer.str(), in_file.good()};
1944}
Orhan Kupusogluec57af02021-05-12 12:38:17 +00001945
1946bool save_to_txt_file(const std::string& file_name, const std::string& content) {
1947 std::ofstream out_file;
1948 out_file.exceptions(std::ofstream::failbit | std::ofstream::badbit);
1949
1950 try {
1951 out_file.open(file_name, std::ios::out | std::ios::trunc);
1952
1953 if (!out_file.is_open()) {
1954 std::cerr << "error while opening file '" << file_name << "'\n";
1955 return false;
1956 }
1957
1958 out_file << content;
1959 out_file.close();
1960
1961 return true;
1962 } catch (const std::ofstream::failure& e) {
1963 std::cerr << "exception while writing to file '" << file_name << "' | err: " << e.what() << '\n';
1964 return false;
1965 }
1966}