blob: bbda618bf20a0c50c00f0440a9bc877aca058043 [file] [log] [blame]
Andrew Jeffery9c766792022-08-10 23:12:49 +09301#include "pdr.h"
2#include "platform.h"
3#include <assert.h>
Manojkiran Eda9a8e4972022-11-28 16:38:21 +05304#include <endian.h>
Andrew Jeffery9c766792022-08-10 23:12:49 +09305#include <stdlib.h>
6#include <string.h>
ArchanaKakani39bd2ea2023-02-02 02:39:18 -06007#include <errno.h>
Andrew Jeffery9c766792022-08-10 23:12:49 +09308
9typedef struct pldm_pdr_record {
10 uint32_t record_handle;
11 uint32_t size;
12 uint8_t *data;
13 struct pldm_pdr_record *next;
14 bool is_remote;
15 uint16_t terminus_handle;
16} pldm_pdr_record;
17
18typedef struct pldm_pdr {
19 uint32_t record_count;
20 uint32_t size;
21 pldm_pdr_record *first;
22 pldm_pdr_record *last;
23} pldm_pdr;
24
25static inline uint32_t get_next_record_handle(const pldm_pdr *repo,
26 const pldm_pdr_record *record)
27{
28 assert(repo != NULL);
29 assert(record != NULL);
30
31 if (record == repo->last) {
32 return 0;
33 }
34 return record->next->record_handle;
35}
36
37static void add_record(pldm_pdr *repo, pldm_pdr_record *record)
38{
39 assert(repo != NULL);
40 assert(record != NULL);
41
42 if (repo->first == NULL) {
43 assert(repo->last == NULL);
44 repo->first = record;
45 repo->last = record;
46 } else {
47 repo->last->next = record;
48 repo->last = record;
49 }
50 repo->size += record->size;
51 ++repo->record_count;
52}
53
54static inline uint32_t get_new_record_handle(const pldm_pdr *repo)
55{
56 assert(repo != NULL);
57 uint32_t last_used_hdl =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +093058 repo->last != NULL ? repo->last->record_handle : 0;
Andrew Jeffery9c766792022-08-10 23:12:49 +093059 assert(last_used_hdl != UINT32_MAX);
60
61 return last_used_hdl + 1;
62}
63
64static pldm_pdr_record *make_new_record(const pldm_pdr *repo,
65 const uint8_t *data, uint32_t size,
66 uint32_t record_handle, bool is_remote,
67 uint16_t terminus_handle)
68{
69 assert(repo != NULL);
70 assert(size != 0);
71
72 pldm_pdr_record *record = malloc(sizeof(pldm_pdr_record));
73 assert(record != NULL);
Andrew Jeffery37dd6a32023-05-12 16:04:06 +093074 record->record_handle = record_handle == 0 ?
75 get_new_record_handle(repo) :
76 record_handle;
Andrew Jeffery9c766792022-08-10 23:12:49 +093077 record->size = size;
78 record->is_remote = is_remote;
79 record->terminus_handle = terminus_handle;
80 if (data != NULL) {
81 record->data = malloc(size);
82 assert(record->data != NULL);
83 memcpy(record->data, data, size);
84 /* If record handle is 0, that is an indication for this API to
85 * compute a new handle. For that reason, the computed handle
86 * needs to be populated in the PDR header. For a case where the
87 * caller supplied the record handle, it would exist in the
88 * header already.
89 */
90 if (!record_handle) {
91 struct pldm_pdr_hdr *hdr =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +093092 (struct pldm_pdr_hdr *)(record->data);
Andrew Jeffery9c766792022-08-10 23:12:49 +093093 hdr->record_handle = htole32(record->record_handle);
94 }
95 }
96 record->next = NULL;
97
98 return record;
99}
100
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930101LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +0930102uint32_t pldm_pdr_add(pldm_pdr *repo, const uint8_t *data, uint32_t size,
103 uint32_t record_handle, bool is_remote,
104 uint16_t terminus_handle)
105{
106 assert(size != 0);
107 assert(data != NULL);
108
109 pldm_pdr_record *record = make_new_record(
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930110 repo, data, size, record_handle, is_remote, terminus_handle);
Andrew Jeffery9c766792022-08-10 23:12:49 +0930111 add_record(repo, record);
112
113 return record->record_handle;
114}
115
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930116LIBPLDM_ABI_STABLE
Andrew Jeffery319304f2023-04-05 13:53:18 +0930117pldm_pdr *pldm_pdr_init(void)
Andrew Jeffery9c766792022-08-10 23:12:49 +0930118{
119 pldm_pdr *repo = malloc(sizeof(pldm_pdr));
Andrew Jefferya8bb22e2023-06-30 12:01:12 +0930120 if (!repo) {
121 return NULL;
122 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930123 repo->record_count = 0;
124 repo->size = 0;
125 repo->first = NULL;
126 repo->last = NULL;
127
128 return repo;
129}
130
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930131LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +0930132void pldm_pdr_destroy(pldm_pdr *repo)
133{
Andrew Jefferyfca1b602023-06-30 12:29:25 +0930134 if (!repo) {
135 return;
136 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930137
138 pldm_pdr_record *record = repo->first;
139 while (record != NULL) {
140 pldm_pdr_record *next = record->next;
141 if (record->data) {
142 free(record->data);
143 record->data = NULL;
144 }
145 free(record);
146 record = next;
147 }
148 free(repo);
149}
150
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930151LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +0930152const pldm_pdr_record *pldm_pdr_find_record(const pldm_pdr *repo,
153 uint32_t record_handle,
154 uint8_t **data, uint32_t *size,
155 uint32_t *next_record_handle)
156{
157 assert(repo != NULL);
158 assert(data != NULL);
159 assert(size != NULL);
160 assert(next_record_handle != NULL);
Andrew Jeffery68b51302023-06-28 21:29:42 +0930161 if (!repo || !data || !size || !next_record_handle) {
162 return NULL;
163 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930164
165 if (!record_handle && (repo->first != NULL)) {
166 record_handle = repo->first->record_handle;
167 }
Andrew Jeffery68b51302023-06-28 21:29:42 +0930168
Andrew Jeffery9c766792022-08-10 23:12:49 +0930169 pldm_pdr_record *record = repo->first;
170 while (record != NULL) {
171 if (record->record_handle == record_handle) {
172 *size = record->size;
173 *data = record->data;
174 *next_record_handle =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930175 get_next_record_handle(repo, record);
Andrew Jeffery9c766792022-08-10 23:12:49 +0930176 return record;
177 }
178 record = record->next;
179 }
180
181 *size = 0;
182 *next_record_handle = 0;
183 return NULL;
184}
185
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930186LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +0930187const pldm_pdr_record *
188pldm_pdr_get_next_record(const pldm_pdr *repo,
189 const pldm_pdr_record *curr_record, uint8_t **data,
190 uint32_t *size, uint32_t *next_record_handle)
191{
192 assert(repo != NULL);
193 assert(curr_record != NULL);
194 assert(data != NULL);
195 assert(size != NULL);
196 assert(next_record_handle != NULL);
Andrew Jeffery68b51302023-06-28 21:29:42 +0930197 if (!repo || !curr_record || !data || !size || !next_record_handle) {
198 return NULL;
199 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930200
201 if (curr_record == repo->last) {
202 *data = NULL;
203 *size = 0;
204 *next_record_handle = get_next_record_handle(repo, curr_record);
205 return NULL;
206 }
207
208 *next_record_handle = get_next_record_handle(repo, curr_record->next);
209 *data = curr_record->next->data;
210 *size = curr_record->next->size;
211 return curr_record->next;
212}
213
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930214LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +0930215const pldm_pdr_record *
216pldm_pdr_find_record_by_type(const pldm_pdr *repo, uint8_t pdr_type,
217 const pldm_pdr_record *curr_record, uint8_t **data,
218 uint32_t *size)
219{
220 assert(repo != NULL);
Andrew Jefferyf85eeba2023-06-30 12:38:40 +0930221 if (!repo) {
222 return NULL;
223 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930224
225 pldm_pdr_record *record = repo->first;
226 if (curr_record != NULL) {
227 record = curr_record->next;
228 }
229 while (record != NULL) {
230 struct pldm_pdr_hdr *hdr = (struct pldm_pdr_hdr *)record->data;
231 if (hdr->type == pdr_type) {
232 if (data && size) {
233 *size = record->size;
234 *data = record->data;
235 }
236 return record;
237 }
238 record = record->next;
239 }
240
241 if (size) {
242 *size = 0;
243 }
244 return NULL;
245}
246
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930247LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +0930248uint32_t pldm_pdr_get_record_count(const pldm_pdr *repo)
249{
250 assert(repo != NULL);
251
252 return repo->record_count;
253}
254
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930255LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +0930256uint32_t pldm_pdr_get_repo_size(const pldm_pdr *repo)
257{
258 assert(repo != NULL);
259
260 return repo->size;
261}
262
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930263LIBPLDM_ABI_STABLE
Andrew Jeffery5565fcd2023-06-30 13:21:32 +0930264uint32_t pldm_pdr_get_record_handle(const pldm_pdr *repo
265 __attribute__((unused)),
Andrew Jeffery9c766792022-08-10 23:12:49 +0930266 const pldm_pdr_record *record)
267{
268 assert(repo != NULL);
269 assert(record != NULL);
270
271 return record->record_handle;
272}
273
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930274LIBPLDM_ABI_STABLE
275bool pldm_pdr_record_is_remote(const pldm_pdr_record *record)
Andrew Jeffery9c766792022-08-10 23:12:49 +0930276{
277 assert(record != NULL);
278
279 return record->is_remote;
280}
281
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930282LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +0930283uint32_t pldm_pdr_add_fru_record_set(pldm_pdr *repo, uint16_t terminus_handle,
284 uint16_t fru_rsi, uint16_t entity_type,
285 uint16_t entity_instance_num,
286 uint16_t container_id,
287 uint32_t bmc_record_handle)
288{
289 uint32_t size = sizeof(struct pldm_pdr_hdr) +
290 sizeof(struct pldm_pdr_fru_record_set);
291 uint8_t data[size];
292
293 struct pldm_pdr_hdr *hdr = (struct pldm_pdr_hdr *)&data;
294 hdr->version = 1;
295 hdr->record_handle = bmc_record_handle;
296 hdr->type = PLDM_PDR_FRU_RECORD_SET;
297 hdr->record_change_num = 0;
298 hdr->length = htole16(sizeof(struct pldm_pdr_fru_record_set));
299 struct pldm_pdr_fru_record_set *fru =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930300 (struct pldm_pdr_fru_record_set *)((uint8_t *)hdr +
301 sizeof(struct pldm_pdr_hdr));
Andrew Jeffery9c766792022-08-10 23:12:49 +0930302 fru->terminus_handle = htole16(terminus_handle);
303 fru->fru_rsi = htole16(fru_rsi);
304 fru->entity_type = htole16(entity_type);
305 fru->entity_instance_num = htole16(entity_instance_num);
306 fru->container_id = htole16(container_id);
307
308 return pldm_pdr_add(repo, data, size, bmc_record_handle, false,
309 terminus_handle);
310}
311
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930312LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +0930313const pldm_pdr_record *pldm_pdr_fru_record_set_find_by_rsi(
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930314 const pldm_pdr *repo, uint16_t fru_rsi, uint16_t *terminus_handle,
315 uint16_t *entity_type, uint16_t *entity_instance_num,
316 uint16_t *container_id)
Andrew Jeffery9c766792022-08-10 23:12:49 +0930317{
318 assert(terminus_handle != NULL);
319 assert(entity_type != NULL);
320 assert(entity_instance_num != NULL);
321 assert(container_id != NULL);
Andrew Jeffery01425e92023-06-30 13:47:40 +0930322 if (!repo || !terminus_handle || !entity_type || !entity_instance_num ||
323 !container_id) {
324 return NULL;
325 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930326
327 uint8_t *data = NULL;
328 uint32_t size = 0;
329 const pldm_pdr_record *curr_record = pldm_pdr_find_record_by_type(
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930330 repo, PLDM_PDR_FRU_RECORD_SET, NULL, &data, &size);
Andrew Jeffery9c766792022-08-10 23:12:49 +0930331 while (curr_record != NULL) {
332 struct pldm_pdr_fru_record_set *fru =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930333 (struct pldm_pdr_fru_record_set
334 *)(data + sizeof(struct pldm_pdr_hdr));
Andrew Jeffery9c766792022-08-10 23:12:49 +0930335 if (fru->fru_rsi == htole16(fru_rsi)) {
336 *terminus_handle = le16toh(fru->terminus_handle);
337 *entity_type = le16toh(fru->entity_type);
338 *entity_instance_num =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930339 le16toh(fru->entity_instance_num);
Andrew Jeffery9c766792022-08-10 23:12:49 +0930340 *container_id = le16toh(fru->container_id);
341 return curr_record;
342 }
343 data = NULL;
344 curr_record = pldm_pdr_find_record_by_type(
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930345 repo, PLDM_PDR_FRU_RECORD_SET, curr_record, &data,
346 &size);
Andrew Jeffery9c766792022-08-10 23:12:49 +0930347 }
348
349 *terminus_handle = 0;
350 *entity_type = 0;
351 *entity_instance_num = 0;
352 *container_id = 0;
353
354 return NULL;
355}
356
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930357LIBPLDM_ABI_STABLE
Andrew Jeffery6005f1c2023-04-05 20:02:52 +0930358/* NOLINTNEXTLINE(readability-identifier-naming) */
359void pldm_pdr_update_TL_pdr(const pldm_pdr *repo, uint16_t terminus_handle,
360 uint8_t tid, uint8_t tl_eid, bool valid_bit)
Andrew Jeffery9c766792022-08-10 23:12:49 +0930361{
Andrew Jeffery6005f1c2023-04-05 20:02:52 +0930362 uint8_t *out_data = NULL;
Andrew Jeffery9c766792022-08-10 23:12:49 +0930363 uint32_t size = 0;
364 const pldm_pdr_record *record;
365 record = pldm_pdr_find_record_by_type(repo, PLDM_TERMINUS_LOCATOR_PDR,
Andrew Jeffery6005f1c2023-04-05 20:02:52 +0930366 NULL, &out_data, &size);
Andrew Jeffery9c766792022-08-10 23:12:49 +0930367
368 do {
369 if (record != NULL) {
370 struct pldm_terminus_locator_pdr *pdr =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930371 (struct pldm_terminus_locator_pdr *)out_data;
Andrew Jeffery9c766792022-08-10 23:12:49 +0930372 struct pldm_terminus_locator_type_mctp_eid *value =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930373 (struct pldm_terminus_locator_type_mctp_eid *)
374 pdr->terminus_locator_value;
Andrew Jeffery6005f1c2023-04-05 20:02:52 +0930375 if (pdr->terminus_handle == terminus_handle &&
376 pdr->tid == tid && value->eid == tl_eid) {
377 pdr->validity = valid_bit;
Andrew Jeffery9c766792022-08-10 23:12:49 +0930378 break;
379 }
380 }
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930381 record = pldm_pdr_find_record_by_type(repo,
382 PLDM_TERMINUS_LOCATOR_PDR,
383 record, &out_data, &size);
Andrew Jeffery9c766792022-08-10 23:12:49 +0930384 } while (record);
385}
386
Pavithra Barithaya5dc02572023-05-19 09:24:36 -0500387static bool pldm_record_handle_in_range(uint32_t record_handle,
388 uint32_t first_record_handle,
389 uint32_t last_record_handle)
390{
391 return record_handle >= first_record_handle &&
392 record_handle <= last_record_handle;
393}
394
395LIBPLDM_ABI_TESTING
Pavithra Barithaya8cf70452023-06-22 04:36:19 -0500396int pldm_pdr_find_child_container_id_index_range_exclude(
Pavithra Barithaya5dc02572023-05-19 09:24:36 -0500397 const pldm_pdr *repo, uint16_t entity_type, uint16_t entity_instance,
Pavithra Barithaya8cf70452023-06-22 04:36:19 -0500398 uint8_t child_index, uint32_t range_exclude_start_handle,
399 uint32_t range_exclude_end_handle, uint16_t *container_id)
Pavithra Barithaya5dc02572023-05-19 09:24:36 -0500400{
401 pldm_pdr_record *record;
402 if (!repo) {
403 return -EINVAL;
404 }
405
406 for (record = repo->first; record; record = record->next) {
407 bool is_container_entity_instance_number;
408 struct pldm_pdr_entity_association *pdr;
409 bool is_container_entity_type;
410 struct pldm_entity *child;
411 struct pldm_pdr_hdr *hdr;
412 bool in_range;
413
414 // pldm_pdr_add() takes only uint8_t* data as an argument.
415 // The expectation here is the pldm_pdr_hdr is the first field of the record data
416 hdr = (struct pldm_pdr_hdr *)record->data;
417 if (hdr->type != PLDM_PDR_ENTITY_ASSOCIATION) {
418 continue;
419 }
420 in_range = pldm_record_handle_in_range(
421 record->record_handle, range_exclude_start_handle,
422 range_exclude_end_handle);
423 if (in_range) {
424 continue;
425 }
426
427 // this cast is valid with respect to alignment because
428 // struct pldm_pdr_hdr is declared with __attribute__((packed))
429 pdr = (void *)(record->data + sizeof(struct pldm_pdr_hdr));
Pavithra Barithaya8cf70452023-06-22 04:36:19 -0500430 if (child_index >= pdr->num_children) {
Pavithra Barithaya5dc02572023-05-19 09:24:36 -0500431 continue;
432 }
Pavithra Barithaya8cf70452023-06-22 04:36:19 -0500433
434 child = (&pdr->children[child_index]);
Pavithra Barithaya5dc02572023-05-19 09:24:36 -0500435 is_container_entity_type = pdr->container.entity_type ==
436 entity_type;
437 is_container_entity_instance_number =
438 pdr->container.entity_instance_num == entity_instance;
439 if (is_container_entity_type &&
440 is_container_entity_instance_number) {
441 *container_id = le16toh(child->entity_container_id);
Pavithra Barithayaffd53422023-06-23 23:20:48 -0500442 return 0;
Pavithra Barithaya5dc02572023-05-19 09:24:36 -0500443 }
444 }
445 return -ENOKEY;
446}
447
Andrew Jeffery9c766792022-08-10 23:12:49 +0930448typedef struct pldm_entity_association_tree {
449 pldm_entity_node *root;
450 uint16_t last_used_container_id;
451} pldm_entity_association_tree;
452
453typedef struct pldm_entity_node {
454 pldm_entity entity;
455 pldm_entity parent;
ArchanaKakani39bd2ea2023-02-02 02:39:18 -0600456 uint16_t remote_container_id;
Andrew Jeffery9c766792022-08-10 23:12:49 +0930457 pldm_entity_node *first_child;
458 pldm_entity_node *next_sibling;
459 uint8_t association_type;
460} pldm_entity_node;
461
462static inline uint16_t next_container_id(pldm_entity_association_tree *tree)
463{
464 assert(tree != NULL);
465 assert(tree->last_used_container_id != UINT16_MAX);
466
467 return ++tree->last_used_container_id;
468}
469
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930470LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +0930471pldm_entity pldm_entity_extract(pldm_entity_node *node)
472{
473 assert(node != NULL);
474
475 return node->entity;
476}
477
ArchanaKakani39bd2ea2023-02-02 02:39:18 -0600478LIBPLDM_ABI_TESTING
Andrew Jeffery15b88182023-06-30 13:29:17 +0930479uint16_t
480pldm_entity_node_get_remote_container_id(const pldm_entity_node *entity)
ArchanaKakani39bd2ea2023-02-02 02:39:18 -0600481{
Andrew Jeffery15b88182023-06-30 13:29:17 +0930482 assert(entity != NULL);
ArchanaKakani39bd2ea2023-02-02 02:39:18 -0600483
Andrew Jeffery15b88182023-06-30 13:29:17 +0930484 return entity->remote_container_id;
ArchanaKakani39bd2ea2023-02-02 02:39:18 -0600485}
486
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930487LIBPLDM_ABI_STABLE
Andrew Jeffery319304f2023-04-05 13:53:18 +0930488pldm_entity_association_tree *pldm_entity_association_tree_init(void)
Andrew Jeffery9c766792022-08-10 23:12:49 +0930489{
490 pldm_entity_association_tree *tree =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930491 malloc(sizeof(pldm_entity_association_tree));
Andrew Jefferyc40037d2023-06-30 13:50:12 +0930492 if (!tree) {
493 return NULL;
494 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930495 tree->root = NULL;
496 tree->last_used_container_id = 0;
497
498 return tree;
499}
500
501static pldm_entity_node *find_insertion_at(pldm_entity_node *start,
502 uint16_t entity_type)
503{
504 assert(start != NULL);
505
506 /* Insert after the the last node that matches the input entity type, or
507 * at the end if no such match occurrs
508 */
509 while (start->next_sibling != NULL) {
510 uint16_t this_type = start->entity.entity_type;
511 pldm_entity_node *next = start->next_sibling;
512 if (this_type == entity_type &&
513 (this_type != next->entity.entity_type)) {
514 break;
515 }
516 start = start->next_sibling;
517 }
518
519 return start;
520}
521
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930522LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +0930523pldm_entity_node *pldm_entity_association_tree_add(
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930524 pldm_entity_association_tree *tree, pldm_entity *entity,
525 uint16_t entity_instance_number, pldm_entity_node *parent,
526 uint8_t association_type)
Andrew Jeffery9c766792022-08-10 23:12:49 +0930527{
Pavithra Barithaya9947f9d2023-05-18 05:20:24 -0500528 return pldm_entity_association_tree_add_entity(tree, entity,
529 entity_instance_number,
530 parent, association_type,
531 false, true, 0xFFFF);
532}
533
534LIBPLDM_ABI_TESTING
535pldm_entity_node *pldm_entity_association_tree_add_entity(
536 pldm_entity_association_tree *tree, pldm_entity *entity,
537 uint16_t entity_instance_number, pldm_entity_node *parent,
538 uint8_t association_type, bool is_remote, bool is_update_container_id,
539 uint16_t container_id)
540{
541 if ((!tree) || (!entity)) {
542 return NULL;
543 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930544
545 if (entity_instance_number != 0xFFFF && parent != NULL) {
546 pldm_entity node;
547 node.entity_type = entity->entity_type;
548 node.entity_instance_num = entity_instance_number;
549 if (pldm_is_current_parent_child(parent, &node)) {
550 return NULL;
551 }
552 }
Pavithra Barithaya9947f9d2023-05-18 05:20:24 -0500553 if (association_type != PLDM_ENTITY_ASSOCIAION_PHYSICAL &&
554 association_type != PLDM_ENTITY_ASSOCIAION_LOGICAL) {
555 return NULL;
556 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930557 pldm_entity_node *node = malloc(sizeof(pldm_entity_node));
Pavithra Barithaya9947f9d2023-05-18 05:20:24 -0500558 if (!node) {
559 return NULL;
560 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930561 node->first_child = NULL;
562 node->next_sibling = NULL;
563 node->parent.entity_type = 0;
564 node->parent.entity_instance_num = 0;
565 node->parent.entity_container_id = 0;
566 node->entity.entity_type = entity->entity_type;
567 node->entity.entity_instance_num =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930568 entity_instance_number != 0xFFFF ? entity_instance_number : 1;
Andrew Jeffery9c766792022-08-10 23:12:49 +0930569 node->association_type = association_type;
ArchanaKakani39bd2ea2023-02-02 02:39:18 -0600570 node->remote_container_id = 0;
Andrew Jeffery9c766792022-08-10 23:12:49 +0930571 if (tree->root == NULL) {
Pavithra Barithaya9947f9d2023-05-18 05:20:24 -0500572 if (parent != NULL) {
573 free(node);
574 return NULL;
575 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930576 tree->root = node;
577 /* container_id 0 here indicates this is the top-most entry */
578 node->entity.entity_container_id = 0;
ArchanaKakani39bd2ea2023-02-02 02:39:18 -0600579 node->remote_container_id = node->entity.entity_container_id;
Andrew Jeffery9c766792022-08-10 23:12:49 +0930580 } else if (parent != NULL && parent->first_child == NULL) {
581 parent->first_child = node;
582 node->parent = parent->entity;
Pavithra Barithaya9947f9d2023-05-18 05:20:24 -0500583
584 if (is_remote) {
585 node->remote_container_id = entity->entity_container_id;
586 }
587 if (is_update_container_id) {
588 if (container_id != 0xFFFF) {
589 node->entity.entity_container_id = container_id;
590 } else {
591 node->entity.entity_container_id =
592 next_container_id(tree);
593 }
594 } else {
595 node->entity.entity_container_id =
596 entity->entity_container_id;
597 }
598
599 if (!is_remote) {
600 node->remote_container_id =
601 node->entity.entity_container_id;
602 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930603 } else {
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930604 pldm_entity_node *start = parent == NULL ? tree->root :
605 parent->first_child;
Andrew Jeffery9c766792022-08-10 23:12:49 +0930606 pldm_entity_node *prev =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930607 find_insertion_at(start, entity->entity_type);
Pavithra Barithaya9947f9d2023-05-18 05:20:24 -0500608 if (!prev) {
609 free(node);
610 return NULL;
611 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930612 pldm_entity_node *next = prev->next_sibling;
613 if (prev->entity.entity_type == entity->entity_type) {
Pavithra Barithaya9947f9d2023-05-18 05:20:24 -0500614 if (prev->entity.entity_instance_num == UINT16_MAX) {
615 free(node);
616 return NULL;
617 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930618 node->entity.entity_instance_num =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930619 entity_instance_number != 0xFFFF ?
620 entity_instance_number :
621 prev->entity.entity_instance_num + 1;
Andrew Jeffery9c766792022-08-10 23:12:49 +0930622 }
623 prev->next_sibling = node;
624 node->parent = prev->parent;
625 node->next_sibling = next;
626 node->entity.entity_container_id =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930627 prev->entity.entity_container_id;
ArchanaKakani39bd2ea2023-02-02 02:39:18 -0600628 node->remote_container_id = entity->entity_container_id;
Andrew Jeffery9c766792022-08-10 23:12:49 +0930629 }
630 entity->entity_instance_num = node->entity.entity_instance_num;
Pavithra Barithaya9947f9d2023-05-18 05:20:24 -0500631 if (is_update_container_id) {
632 entity->entity_container_id = node->entity.entity_container_id;
633 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930634 return node;
635}
636
637static void get_num_nodes(pldm_entity_node *node, size_t *num)
638{
639 if (node == NULL) {
640 return;
641 }
642
643 ++(*num);
644 get_num_nodes(node->next_sibling, num);
645 get_num_nodes(node->first_child, num);
646}
647
648static void entity_association_tree_visit(pldm_entity_node *node,
649 pldm_entity *entities, size_t *index)
650{
651 if (node == NULL) {
652 return;
653 }
654
655 pldm_entity *entity = &entities[*index];
656 ++(*index);
657 entity->entity_type = node->entity.entity_type;
658 entity->entity_instance_num = node->entity.entity_instance_num;
659 entity->entity_container_id = node->entity.entity_container_id;
660
661 entity_association_tree_visit(node->next_sibling, entities, index);
662 entity_association_tree_visit(node->first_child, entities, index);
663}
664
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930665LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +0930666void pldm_entity_association_tree_visit(pldm_entity_association_tree *tree,
667 pldm_entity **entities, size_t *size)
668{
669 assert(tree != NULL);
Andrew Jefferycd17e5c2023-06-30 14:06:18 +0930670 if (!tree || !entities || !size) {
671 return;
672 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930673
674 *size = 0;
675 if (tree->root == NULL) {
676 return;
677 }
678
679 get_num_nodes(tree->root, size);
680 *entities = malloc(*size * sizeof(pldm_entity));
Andrew Jefferycd17e5c2023-06-30 14:06:18 +0930681 if (!entities) {
682 return;
683 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930684 size_t index = 0;
685 entity_association_tree_visit(tree->root, *entities, &index);
686}
687
688static void entity_association_tree_destroy(pldm_entity_node *node)
689{
690 if (node == NULL) {
691 return;
692 }
693
694 entity_association_tree_destroy(node->next_sibling);
695 entity_association_tree_destroy(node->first_child);
696 free(node);
697}
698
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930699LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +0930700void pldm_entity_association_tree_destroy(pldm_entity_association_tree *tree)
701{
Andrew Jefferya89e0152023-06-30 14:24:05 +0930702 if (!tree) {
703 return;
704 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930705
706 entity_association_tree_destroy(tree->root);
707 free(tree);
708}
709
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930710LIBPLDM_ABI_STABLE
711bool pldm_entity_is_node_parent(pldm_entity_node *node)
Andrew Jeffery9c766792022-08-10 23:12:49 +0930712{
713 assert(node != NULL);
714
715 return node->first_child != NULL;
716}
717
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930718LIBPLDM_ABI_STABLE
719pldm_entity pldm_entity_get_parent(pldm_entity_node *node)
Andrew Jeffery9c766792022-08-10 23:12:49 +0930720{
721 assert(node != NULL);
722
723 return node->parent;
724}
725
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930726LIBPLDM_ABI_STABLE
727bool pldm_entity_is_exist_parent(pldm_entity_node *node)
Andrew Jeffery9c766792022-08-10 23:12:49 +0930728{
729 assert(node != NULL);
730
731 if (node->parent.entity_type == 0 &&
732 node->parent.entity_instance_num == 0 &&
733 node->parent.entity_container_id == 0) {
734 return false;
735 }
736
737 return true;
738}
739
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930740LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +0930741uint8_t pldm_entity_get_num_children(pldm_entity_node *node,
742 uint8_t association_type)
743{
744 assert(node != NULL);
Andrew Jeffery6e8a2612023-06-30 15:36:48 +0930745 if (!node) {
746 return 0;
747 }
748
Andrew Jeffery9c766792022-08-10 23:12:49 +0930749 assert(association_type == PLDM_ENTITY_ASSOCIAION_PHYSICAL ||
750 association_type == PLDM_ENTITY_ASSOCIAION_LOGICAL);
Andrew Jeffery6e8a2612023-06-30 15:36:48 +0930751 if (!(association_type == PLDM_ENTITY_ASSOCIAION_PHYSICAL ||
752 association_type == PLDM_ENTITY_ASSOCIAION_LOGICAL)) {
753 return 0;
754 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930755
756 size_t count = 0;
757 pldm_entity_node *curr = node->first_child;
758 while (curr != NULL) {
759 if (curr->association_type == association_type) {
760 ++count;
761 }
762 curr = curr->next_sibling;
763 }
764
765 assert(count < UINT8_MAX);
766 return count;
767}
768
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930769LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +0930770bool pldm_is_current_parent_child(pldm_entity_node *parent, pldm_entity *node)
771{
772 assert(parent != NULL);
773 assert(node != NULL);
Andrew Jeffery375d9fc2023-06-30 15:45:54 +0930774 if (!parent || !node) {
775 return false;
776 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930777
778 pldm_entity_node *curr = parent->first_child;
779 while (curr != NULL) {
780 if (node->entity_type == curr->entity.entity_type &&
781 node->entity_instance_num ==
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930782 curr->entity.entity_instance_num) {
Andrew Jeffery9c766792022-08-10 23:12:49 +0930783 return true;
784 }
785 curr = curr->next_sibling;
786 }
787
788 return false;
789}
790
Pavithra Barithaya25ddbcc2023-05-19 08:28:59 -0500791static void entity_association_pdr_add_children(
792 pldm_entity_node *curr, pldm_pdr *repo, uint16_t size,
793 uint8_t contained_count, uint8_t association_type, bool is_remote,
794 uint16_t terminus_handle, uint32_t record_handle)
Andrew Jeffery9c766792022-08-10 23:12:49 +0930795{
796 uint8_t pdr[size];
797 uint8_t *start = pdr;
798
799 struct pldm_pdr_hdr *hdr = (struct pldm_pdr_hdr *)start;
800 hdr->version = 1;
801 hdr->record_handle = 0;
802 hdr->type = PLDM_PDR_ENTITY_ASSOCIATION;
803 hdr->record_change_num = 0;
804 hdr->length = htole16(size - sizeof(struct pldm_pdr_hdr));
805 start += sizeof(struct pldm_pdr_hdr);
806
807 uint16_t *container_id = (uint16_t *)start;
808 *container_id = htole16(curr->first_child->entity.entity_container_id);
809 start += sizeof(uint16_t);
810 *start = association_type;
811 start += sizeof(uint8_t);
812
813 pldm_entity *entity = (pldm_entity *)start;
814 entity->entity_type = htole16(curr->entity.entity_type);
815 entity->entity_instance_num = htole16(curr->entity.entity_instance_num);
816 entity->entity_container_id = htole16(curr->entity.entity_container_id);
817 start += sizeof(pldm_entity);
818
819 *start = contained_count;
820 start += sizeof(uint8_t);
821
822 pldm_entity_node *node = curr->first_child;
823 while (node != NULL) {
824 if (node->association_type == association_type) {
825 pldm_entity *entity = (pldm_entity *)start;
826 entity->entity_type = htole16(node->entity.entity_type);
827 entity->entity_instance_num =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930828 htole16(node->entity.entity_instance_num);
Andrew Jeffery9c766792022-08-10 23:12:49 +0930829 entity->entity_container_id =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930830 htole16(node->entity.entity_container_id);
Andrew Jeffery9c766792022-08-10 23:12:49 +0930831 start += sizeof(pldm_entity);
832 }
833 node = node->next_sibling;
834 }
835
Pavithra Barithaya25ddbcc2023-05-19 08:28:59 -0500836 pldm_pdr_add(repo, pdr, size, record_handle, is_remote,
837 terminus_handle);
Andrew Jeffery9c766792022-08-10 23:12:49 +0930838}
839
840static void entity_association_pdr_add_entry(pldm_entity_node *curr,
841 pldm_pdr *repo, bool is_remote,
Pavithra Barithaya25ddbcc2023-05-19 08:28:59 -0500842 uint16_t terminus_handle,
843 uint32_t record_handle)
Andrew Jeffery9c766792022-08-10 23:12:49 +0930844{
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930845 uint8_t num_logical_children = pldm_entity_get_num_children(
846 curr, PLDM_ENTITY_ASSOCIAION_LOGICAL);
847 uint8_t num_physical_children = pldm_entity_get_num_children(
848 curr, PLDM_ENTITY_ASSOCIAION_PHYSICAL);
Andrew Jeffery9c766792022-08-10 23:12:49 +0930849
850 if (num_logical_children) {
851 uint16_t logical_pdr_size =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930852 sizeof(struct pldm_pdr_hdr) + sizeof(uint16_t) +
853 sizeof(uint8_t) + sizeof(pldm_entity) +
854 sizeof(uint8_t) +
855 (num_logical_children * sizeof(pldm_entity));
Andrew Jeffery4edb7082023-04-05 19:09:52 +0930856 entity_association_pdr_add_children(
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930857 curr, repo, logical_pdr_size, num_logical_children,
858 PLDM_ENTITY_ASSOCIAION_LOGICAL, is_remote,
Pavithra Barithaya25ddbcc2023-05-19 08:28:59 -0500859 terminus_handle, record_handle);
Andrew Jeffery9c766792022-08-10 23:12:49 +0930860 }
861
862 if (num_physical_children) {
863 uint16_t physical_pdr_size =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930864 sizeof(struct pldm_pdr_hdr) + sizeof(uint16_t) +
865 sizeof(uint8_t) + sizeof(pldm_entity) +
866 sizeof(uint8_t) +
867 (num_physical_children * sizeof(pldm_entity));
Andrew Jeffery4edb7082023-04-05 19:09:52 +0930868 entity_association_pdr_add_children(
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930869 curr, repo, physical_pdr_size, num_physical_children,
870 PLDM_ENTITY_ASSOCIAION_PHYSICAL, is_remote,
Pavithra Barithaya25ddbcc2023-05-19 08:28:59 -0500871 terminus_handle, record_handle);
Andrew Jeffery9c766792022-08-10 23:12:49 +0930872 }
873}
874
Andrew Jefferyd11bf9f2023-06-30 15:47:41 +0930875LIBPLDM_ABI_DEPRECATED
Andrew Jeffery9c766792022-08-10 23:12:49 +0930876bool is_present(pldm_entity entity, pldm_entity **entities, size_t num_entities)
877{
878 if (entities == NULL || num_entities == 0) {
879 return true;
880 }
881 size_t i = 0;
882 while (i < num_entities) {
883 if ((*entities + i)->entity_type == entity.entity_type) {
884 return true;
885 }
886 i++;
887 }
888 return false;
889}
890
891static void entity_association_pdr_add(pldm_entity_node *curr, pldm_pdr *repo,
892 pldm_entity **entities,
893 size_t num_entities, bool is_remote,
Pavithra Barithaya25ddbcc2023-05-19 08:28:59 -0500894 uint16_t terminus_handle,
895 uint32_t record_handle)
Andrew Jeffery9c766792022-08-10 23:12:49 +0930896{
897 if (curr == NULL) {
898 return;
899 }
900 bool to_add = true;
901 to_add = is_present(curr->entity, entities, num_entities);
902 if (to_add) {
Pavithra Barithaya25ddbcc2023-05-19 08:28:59 -0500903 entity_association_pdr_add_entry(
904 curr, repo, is_remote, terminus_handle, record_handle);
Andrew Jeffery9c766792022-08-10 23:12:49 +0930905 }
906 entity_association_pdr_add(curr->next_sibling, repo, entities,
Pavithra Barithaya25ddbcc2023-05-19 08:28:59 -0500907 num_entities, is_remote, terminus_handle,
908 record_handle);
Andrew Jeffery9c766792022-08-10 23:12:49 +0930909 entity_association_pdr_add(curr->first_child, repo, entities,
Pavithra Barithaya25ddbcc2023-05-19 08:28:59 -0500910 num_entities, is_remote, terminus_handle,
911 record_handle);
Andrew Jeffery9c766792022-08-10 23:12:49 +0930912}
913
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930914LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +0930915void pldm_entity_association_pdr_add(pldm_entity_association_tree *tree,
916 pldm_pdr *repo, bool is_remote,
917 uint16_t terminus_handle)
918{
919 assert(tree != NULL);
920 assert(repo != NULL);
Andrew Jefferyc7883482023-06-30 15:52:04 +0930921 if (!tree || !repo) {
922 return;
923 }
Andrew Jeffery9c766792022-08-10 23:12:49 +0930924
925 entity_association_pdr_add(tree->root, repo, NULL, 0, is_remote,
Pavithra Barithaya25ddbcc2023-05-19 08:28:59 -0500926 terminus_handle, 0);
Andrew Jeffery9c766792022-08-10 23:12:49 +0930927}
928
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930929LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +0930930void pldm_entity_association_pdr_add_from_node(
Andrew Jeffery37dd6a32023-05-12 16:04:06 +0930931 pldm_entity_node *node, pldm_pdr *repo, pldm_entity **entities,
932 size_t num_entities, bool is_remote, uint16_t terminus_handle)
Andrew Jeffery9c766792022-08-10 23:12:49 +0930933{
Andrew Jefferycc394522023-07-03 12:49:31 +0930934 int rc = pldm_entity_association_pdr_add_from_node_check(
935 node, repo, entities, num_entities, is_remote, terminus_handle);
936 (void)rc;
937 assert(!rc);
938}
Andrew Jeffery9c766792022-08-10 23:12:49 +0930939
Andrew Jefferycc394522023-07-03 12:49:31 +0930940LIBPLDM_ABI_TESTING
941int pldm_entity_association_pdr_add_from_node_check(
942 pldm_entity_node *node, pldm_pdr *repo, pldm_entity **entities,
943 size_t num_entities, bool is_remote, uint16_t terminus_handle)
944{
945 return pldm_entity_association_pdr_add_from_node_with_record_handle(
Pavithra Barithaya25ddbcc2023-05-19 08:28:59 -0500946 node, repo, entities, num_entities, is_remote, terminus_handle,
947 0);
948}
949
950LIBPLDM_ABI_TESTING
951int pldm_entity_association_pdr_add_from_node_with_record_handle(
952 pldm_entity_node *node, pldm_pdr *repo, pldm_entity **entities,
953 size_t num_entities, bool is_remote, uint16_t terminus_handle,
954 uint32_t record_handle)
955{
956 if (!node || !repo || !entities) {
957 return -EINVAL;
958 }
959
Andrew Jeffery9c766792022-08-10 23:12:49 +0930960 entity_association_pdr_add(node, repo, entities, num_entities,
Pavithra Barithaya25ddbcc2023-05-19 08:28:59 -0500961 is_remote, terminus_handle, record_handle);
962
963 return 0;
Andrew Jeffery9c766792022-08-10 23:12:49 +0930964}
965
Andrew Jefferybfeb65e2023-06-30 16:02:15 +0930966LIBPLDM_ABI_DEPRECATED
Andrew Jeffery9c766792022-08-10 23:12:49 +0930967void find_entity_ref_in_tree(pldm_entity_node *tree_node, pldm_entity entity,
968 pldm_entity_node **node)
969{
ArchanaKakani39bd2ea2023-02-02 02:39:18 -0600970 bool is_entity_container_id;
971 bool is_entity_instance_num;
972 bool is_type;
973
Andrew Jeffery9c766792022-08-10 23:12:49 +0930974 if (tree_node == NULL) {
975 return;
976 }
977
ArchanaKakani39bd2ea2023-02-02 02:39:18 -0600978 is_type = tree_node->entity.entity_type == entity.entity_type;
979 is_entity_instance_num = tree_node->entity.entity_instance_num ==
980 entity.entity_instance_num;
981 is_entity_container_id = tree_node->entity.entity_container_id ==
982 entity.entity_container_id;
983
984 if (is_type && is_entity_instance_num && is_entity_container_id) {
Andrew Jeffery9c766792022-08-10 23:12:49 +0930985 *node = tree_node;
986 return;
987 }
988
989 find_entity_ref_in_tree(tree_node->first_child, entity, node);
990 find_entity_ref_in_tree(tree_node->next_sibling, entity, node);
991}
992
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +0930993LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +0930994void pldm_find_entity_ref_in_tree(pldm_entity_association_tree *tree,
995 pldm_entity entity, pldm_entity_node **node)
996{
997 assert(tree != NULL);
Andrew Jefferyba47e832023-07-03 11:41:03 +0930998 if (!tree || !node) {
999 return;
1000 }
1001
Andrew Jeffery9c766792022-08-10 23:12:49 +09301002 find_entity_ref_in_tree(tree->root, entity, node);
1003}
1004
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +09301005LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +09301006void pldm_pdr_remove_pdrs_by_terminus_handle(pldm_pdr *repo,
1007 uint16_t terminus_handle)
1008{
1009 assert(repo != NULL);
Andrew Jeffery438dd492023-07-03 11:51:43 +09301010 if (!repo) {
1011 return;
1012 }
1013
Andrew Jeffery9c766792022-08-10 23:12:49 +09301014 bool removed = false;
1015
1016 pldm_pdr_record *record = repo->first;
1017 pldm_pdr_record *prev = NULL;
1018 while (record != NULL) {
1019 pldm_pdr_record *next = record->next;
1020 if (record->terminus_handle == terminus_handle) {
1021 if (repo->first == record) {
1022 repo->first = next;
1023 } else {
1024 prev->next = next;
1025 }
1026 if (repo->last == record) {
1027 repo->last = prev;
1028 }
1029 if (record->data) {
1030 free(record->data);
1031 }
1032 --repo->record_count;
1033 repo->size -= record->size;
1034 free(record);
1035 removed = true;
1036 } else {
1037 prev = record;
1038 }
1039 record = next;
1040 }
1041
1042 if (removed == true) {
1043 record = repo->first;
1044 uint32_t record_handle = 0;
1045 while (record != NULL) {
1046 record->record_handle = ++record_handle;
1047 if (record->data != NULL) {
1048 struct pldm_pdr_hdr *hdr =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +09301049 (struct pldm_pdr_hdr *)(record->data);
Andrew Jeffery9c766792022-08-10 23:12:49 +09301050 hdr->record_handle =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +09301051 htole32(record->record_handle);
Andrew Jeffery9c766792022-08-10 23:12:49 +09301052 }
1053 record = record->next;
1054 }
1055 }
1056}
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +09301057
1058LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +09301059void pldm_pdr_remove_remote_pdrs(pldm_pdr *repo)
1060{
1061 assert(repo != NULL);
Andrew Jeffery3e1d6592023-07-03 11:57:16 +09301062 if (!repo) {
1063 return;
1064 }
1065
Andrew Jeffery9c766792022-08-10 23:12:49 +09301066 bool removed = false;
1067
1068 pldm_pdr_record *record = repo->first;
1069 pldm_pdr_record *prev = NULL;
1070 while (record != NULL) {
1071 pldm_pdr_record *next = record->next;
1072 if (record->is_remote == true) {
1073 if (repo->first == record) {
1074 repo->first = next;
1075 } else {
1076 prev->next = next;
1077 }
1078 if (repo->last == record) {
1079 repo->last = prev;
1080 }
1081 if (record->data) {
1082 free(record->data);
1083 }
1084 --repo->record_count;
1085 repo->size -= record->size;
1086 free(record);
1087 removed = true;
1088 } else {
1089 prev = record;
1090 }
1091 record = next;
1092 }
1093
1094 if (removed == true) {
1095 record = repo->first;
1096 uint32_t record_handle = 0;
1097 while (record != NULL) {
1098 record->record_handle = ++record_handle;
1099 if (record->data != NULL) {
1100 struct pldm_pdr_hdr *hdr =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +09301101 (struct pldm_pdr_hdr *)(record->data);
Andrew Jeffery9c766792022-08-10 23:12:49 +09301102 hdr->record_handle =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +09301103 htole32(record->record_handle);
Andrew Jeffery9c766792022-08-10 23:12:49 +09301104 }
1105 record = record->next;
1106 }
1107 }
1108}
1109
Pavithra Barithaya4d694342023-05-19 08:04:41 -05001110LIBPLDM_ABI_TESTING
1111pldm_pdr_record *pldm_pdr_find_last_in_range(const pldm_pdr *repo,
1112 uint32_t first, uint32_t last)
1113{
1114 pldm_pdr_record *record = NULL;
1115 pldm_pdr_record *curr;
1116
1117 if (!repo) {
1118 return NULL;
1119 }
1120 for (curr = repo->first; curr; curr = curr->next) {
1121 if (first > curr->record_handle || last < curr->record_handle) {
1122 continue;
1123 }
1124 if (!record || curr->record_handle > record->record_handle) {
1125 record = curr;
1126 }
1127 }
1128
1129 return record;
1130}
1131
Pavithra Barithaya9947f9d2023-05-18 05:20:24 -05001132static void entity_association_tree_find_if_remote(pldm_entity_node *node,
1133 pldm_entity *entity,
1134 pldm_entity_node **out,
1135 bool is_remote)
1136{
1137 assert(out != NULL && *out == NULL);
1138 if (node == NULL) {
1139 return;
1140 }
1141 bool is_entity_type;
1142 bool is_entity_instance_num;
1143
1144 is_entity_type = node->entity.entity_type == entity->entity_type;
1145 is_entity_instance_num = node->entity.entity_instance_num ==
1146 entity->entity_instance_num;
1147
1148 if (!is_remote ||
1149 node->remote_container_id == entity->entity_container_id) {
1150 if (is_entity_type && is_entity_instance_num) {
1151 entity->entity_container_id =
1152 node->entity.entity_container_id;
1153 *out = node;
1154 return;
1155 }
1156 }
1157 entity_association_tree_find_if_remote(node->next_sibling, entity, out,
1158 is_remote);
1159 entity_association_tree_find_if_remote(node->first_child, entity, out,
1160 is_remote);
1161}
1162
1163LIBPLDM_ABI_TESTING
1164pldm_entity_node *
1165pldm_entity_association_tree_find_if_remote(pldm_entity_association_tree *tree,
1166 pldm_entity *entity, bool is_remote)
1167{
1168 if (!tree || !entity) {
1169 return NULL;
1170 }
1171 pldm_entity_node *node = NULL;
1172 entity_association_tree_find_if_remote(tree->root, entity, &node,
1173 is_remote);
1174 return node;
1175}
1176
Andrew Jeffery7f589312023-07-03 12:03:25 +09301177LIBPLDM_ABI_DEPRECATED
Andrew Jeffery9c766792022-08-10 23:12:49 +09301178void entity_association_tree_find(pldm_entity_node *node, pldm_entity *entity,
1179 pldm_entity_node **out)
1180{
1181 if (node == NULL) {
1182 return;
1183 }
1184
1185 if (node->entity.entity_type == entity->entity_type &&
1186 node->entity.entity_instance_num == entity->entity_instance_num) {
1187 entity->entity_container_id = node->entity.entity_container_id;
1188 *out = node;
1189 return;
1190 }
Andrew Jeffery9c766792022-08-10 23:12:49 +09301191 entity_association_tree_find(node->next_sibling, entity, out);
1192 entity_association_tree_find(node->first_child, entity, out);
1193}
1194
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +09301195LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +09301196pldm_entity_node *
1197pldm_entity_association_tree_find(pldm_entity_association_tree *tree,
1198 pldm_entity *entity)
1199{
1200 assert(tree != NULL);
Andrew Jeffery94e364d2023-07-03 12:26:59 +09301201 if (!tree || !entity) {
1202 return NULL;
1203 }
Andrew Jeffery9c766792022-08-10 23:12:49 +09301204
1205 pldm_entity_node *node = NULL;
1206 entity_association_tree_find(tree->root, entity, &node);
1207 return node;
1208}
1209
1210static void entity_association_tree_copy(pldm_entity_node *org_node,
1211 pldm_entity_node **new_node)
1212{
1213 if (org_node == NULL) {
1214 return;
1215 }
1216 *new_node = malloc(sizeof(pldm_entity_node));
1217 (*new_node)->parent = org_node->parent;
1218 (*new_node)->entity = org_node->entity;
1219 (*new_node)->association_type = org_node->association_type;
ArchanaKakani39bd2ea2023-02-02 02:39:18 -06001220 (*new_node)->remote_container_id = org_node->remote_container_id;
Andrew Jeffery9c766792022-08-10 23:12:49 +09301221 (*new_node)->first_child = NULL;
1222 (*new_node)->next_sibling = NULL;
1223 entity_association_tree_copy(org_node->first_child,
1224 &((*new_node)->first_child));
1225 entity_association_tree_copy(org_node->next_sibling,
1226 &((*new_node)->next_sibling));
1227}
1228
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +09301229LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +09301230void pldm_entity_association_tree_copy_root(
Andrew Jeffery37dd6a32023-05-12 16:04:06 +09301231 pldm_entity_association_tree *org_tree,
1232 pldm_entity_association_tree *new_tree)
Andrew Jeffery9c766792022-08-10 23:12:49 +09301233{
1234 new_tree->last_used_container_id = org_tree->last_used_container_id;
1235 entity_association_tree_copy(org_tree->root, &(new_tree->root));
1236}
1237
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +09301238LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +09301239void pldm_entity_association_tree_destroy_root(
Andrew Jeffery37dd6a32023-05-12 16:04:06 +09301240 pldm_entity_association_tree *tree)
Andrew Jeffery9c766792022-08-10 23:12:49 +09301241{
1242 assert(tree != NULL);
Andrew Jeffery85d7a052023-07-03 12:29:24 +09301243 if (!tree) {
1244 return;
1245 }
1246
Andrew Jeffery9c766792022-08-10 23:12:49 +09301247 entity_association_tree_destroy(tree->root);
1248 tree->last_used_container_id = 0;
1249 tree->root = NULL;
1250}
1251
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +09301252LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +09301253bool pldm_is_empty_entity_assoc_tree(pldm_entity_association_tree *tree)
1254{
1255 return ((tree->root == NULL) ? true : false);
1256}
1257
Andrew Jeffery9d2a1c62023-06-05 13:02:16 +09301258LIBPLDM_ABI_STABLE
Andrew Jeffery9c766792022-08-10 23:12:49 +09301259void pldm_entity_association_pdr_extract(const uint8_t *pdr, uint16_t pdr_len,
1260 size_t *num_entities,
1261 pldm_entity **entities)
1262{
1263 assert(pdr != NULL);
Andrew Jeffery3a5c46b2023-07-03 12:39:59 +09301264 if (!pdr || !num_entities || !entities) {
1265 return;
1266 }
1267#define PDR_MIN_SIZE \
1268 (sizeof(struct pldm_pdr_hdr) + \
1269 sizeof(struct pldm_pdr_entity_association))
1270 assert(pdr_len >= PDR_MIN_SIZE);
1271 if (pdr_len < PDR_MIN_SIZE) {
1272 return;
1273 }
1274#undef PDR_MIN_SIZE
Andrew Jeffery9c766792022-08-10 23:12:49 +09301275
1276 struct pldm_pdr_hdr *hdr = (struct pldm_pdr_hdr *)pdr;
1277 assert(hdr->type == PLDM_PDR_ENTITY_ASSOCIATION);
1278
1279 const uint8_t *start = (uint8_t *)pdr;
Andrew Jeffery3a5c46b2023-07-03 12:39:59 +09301280 const uint8_t *end __attribute__((unused)) =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +09301281 start + sizeof(struct pldm_pdr_hdr) + le16toh(hdr->length);
Andrew Jeffery9c766792022-08-10 23:12:49 +09301282 start += sizeof(struct pldm_pdr_hdr);
1283 struct pldm_pdr_entity_association *entity_association_pdr =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +09301284 (struct pldm_pdr_entity_association *)start;
Andrew Jeffery9c766792022-08-10 23:12:49 +09301285 *num_entities = entity_association_pdr->num_children + 1;
1286 assert(*num_entities >= 2);
1287 *entities = malloc(sizeof(pldm_entity) * *num_entities);
1288 assert(*entities != NULL);
1289 assert(start + sizeof(struct pldm_pdr_entity_association) +
Andrew Jeffery37dd6a32023-05-12 16:04:06 +09301290 sizeof(pldm_entity) * (*num_entities - 2) ==
Andrew Jeffery9c766792022-08-10 23:12:49 +09301291 end);
1292 (*entities)->entity_type =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +09301293 le16toh(entity_association_pdr->container.entity_type);
Andrew Jeffery9c766792022-08-10 23:12:49 +09301294 (*entities)->entity_instance_num =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +09301295 le16toh(entity_association_pdr->container.entity_instance_num);
Andrew Jeffery9c766792022-08-10 23:12:49 +09301296 (*entities)->entity_container_id =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +09301297 le16toh(entity_association_pdr->container.entity_container_id);
Andrew Jeffery9c766792022-08-10 23:12:49 +09301298 pldm_entity *curr_entity = entity_association_pdr->children;
1299 size_t i = 1;
1300 while (i < *num_entities) {
1301 (*entities + i)->entity_type =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +09301302 le16toh(curr_entity->entity_type);
Andrew Jeffery9c766792022-08-10 23:12:49 +09301303 (*entities + i)->entity_instance_num =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +09301304 le16toh(curr_entity->entity_instance_num);
Andrew Jeffery9c766792022-08-10 23:12:49 +09301305 (*entities + i)->entity_container_id =
Andrew Jeffery37dd6a32023-05-12 16:04:06 +09301306 le16toh(curr_entity->entity_container_id);
Andrew Jeffery9c766792022-08-10 23:12:49 +09301307 ++curr_entity;
1308 ++i;
1309 }
1310}