Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
       2                 :            : /* Copyright 2019 IBM Corp. */
       3                 :            : 
       4                 :            : #ifndef pr_fmt
       5                 :            : #define pr_fmt(fmt) "SECVAR: " fmt
       6                 :            : #endif
       7                 :            : 
       8                 :            : #include <stdlib.h>
       9                 :            : #include <string.h>
      10                 :            : #include <skiboot.h>
      11                 :            : #include <opal.h>
      12                 :            : #include "secvar.h"
      13                 :            : 
      14                 :         78 : void clear_bank_list(struct list_head *bank)
      15                 :            : {
      16                 :            :         struct secvar *var, *next;
      17                 :            : 
      18                 :         78 :         if (!bank)
      19                 :          0 :                 return;
      20                 :            : 
      21                 :        315 :         list_for_each_safe(bank, var, next, link) {
      22                 :        237 :                 list_del(&var->link);
      23                 :        237 :                 dealloc_secvar(var);
      24                 :            :         }
      25                 :            : }
      26                 :            : 
      27                 :         36 : int copy_bank_list(struct list_head *dst, struct list_head *src)
      28                 :            : {
      29                 :            :         struct secvar *var, *tmp;
      30                 :            : 
      31                 :        219 :         list_for_each(src, var, link) {
      32                 :            :                 /* Allocate new secvar using actual data size */
      33                 :        183 :                 tmp = new_secvar(var->key, var->key_len, var->data,
      34                 :            :                                  var->data_size, var->flags);
      35                 :            :                 /* Append to new list */
      36                 :        183 :                 list_add_tail(dst, &tmp->link);
      37                 :            :         }
      38                 :            : 
      39                 :         36 :         return OPAL_SUCCESS;
      40                 :            : }
      41                 :            : 
      42                 :        242 : struct secvar *alloc_secvar(uint64_t key_len, uint64_t data_size)
      43                 :            : {
      44                 :            :         struct secvar *ret;
      45                 :            : 
      46                 :        242 :         ret = zalloc(sizeof(struct secvar));
      47                 :        242 :         if (!ret)
      48                 :          0 :                 return NULL;
      49                 :            : 
      50                 :        242 :         ret->key = zalloc(key_len);
      51                 :        242 :         if (!ret->key) {
      52                 :          0 :                 free(ret);
      53                 :          0 :                 return NULL;
      54                 :            :         }
      55                 :            : 
      56                 :        242 :         ret->data = zalloc(data_size);
      57                 :        242 :         if (!ret->data) {
      58                 :          0 :                 free(ret->key);
      59                 :          0 :                 free(ret);
      60                 :          0 :                 return NULL;
      61                 :            :         }
      62                 :            : 
      63                 :        242 :         ret->key_len = key_len;
      64                 :        242 :         ret->data_size = data_size;
      65                 :            : 
      66                 :        242 :         return ret;
      67                 :            : }
      68                 :            : 
      69                 :        234 : struct secvar *new_secvar(const char *key, uint64_t key_len,
      70                 :            :                                const char *data, uint64_t data_size,
      71                 :            :                                uint64_t flags)
      72                 :            : {
      73                 :            :         struct secvar *ret;
      74                 :            : 
      75                 :        234 :         if (!key)
      76                 :          0 :                 return NULL;
      77                 :        234 :         if ((!key_len) || (key_len > SECVAR_MAX_KEY_LEN))
      78                 :          0 :                 return NULL;
      79                 :        234 :         if ((!data) && (data_size))
      80                 :          0 :                 return NULL;
      81                 :            : 
      82                 :        234 :         ret = alloc_secvar(key_len, data_size);
      83                 :        234 :         if (!ret)
      84                 :          0 :                 return NULL;
      85                 :            : 
      86                 :        234 :         memcpy(ret->key, key, key_len);
      87                 :        234 :         ret->flags = flags;
      88                 :            : 
      89                 :        234 :         if (data)
      90                 :        227 :                 memcpy(ret->data, data, data_size);
      91                 :            : 
      92                 :        234 :         return ret;
      93                 :            : }
      94                 :            : 
      95                 :          9 : int realloc_secvar(struct secvar *var, uint64_t size)
      96                 :            : {
      97                 :            :         void *tmp;
      98                 :            : 
      99                 :          9 :         if (var->data_size >= size)
     100                 :          0 :                 return 0;
     101                 :            : 
     102                 :          9 :         tmp = zalloc(size);
     103                 :          9 :         if (!tmp)
     104                 :          0 :                 return -1;
     105                 :            : 
     106                 :          9 :         memcpy(tmp, var->data, var->data_size);
     107                 :          9 :         free(var->data);
     108                 :          9 :         var->data = tmp;
     109                 :            : 
     110                 :          9 :         return 0;
     111                 :            : }
     112                 :            : 
     113                 :        242 : void dealloc_secvar(struct secvar *var)
     114                 :            : {
     115                 :        242 :         if (!var)
     116                 :          0 :                 return;
     117                 :            : 
     118                 :        242 :         free(var->key);
     119                 :        242 :         free(var->data);
     120                 :        242 :         free(var);
     121                 :            : }
     122                 :            : 
     123                 :        138 : struct secvar *find_secvar(const char *key, uint64_t key_len, struct list_head *bank)
     124                 :            : {
     125                 :        138 :         struct secvar *var = NULL;
     126                 :            : 
     127                 :        349 :         list_for_each(bank, var, link) {
     128                 :            :                 // Prevent matching shorter key subsets / bail early
     129                 :        338 :                 if (key_len != var->key_len)
     130                 :        132 :                         continue;
     131                 :        206 :                 if (!memcmp(key, var->key, key_len))
     132                 :        127 :                         return var;
     133                 :            :         }
     134                 :            : 
     135                 :         11 :         return NULL;
     136                 :            : }
     137                 :            : 
     138                 :         14 : int is_key_empty(const char *key, uint64_t key_len)
     139                 :            : {
     140                 :            :         int i;
     141                 :         24 :         for (i = 0; i < key_len; i++) {
     142                 :         20 :                 if (key[i] != 0)
     143                 :         10 :                         return 0;
     144                 :            :         }
     145                 :            : 
     146                 :          4 :         return 1;
     147                 :            : }
     148                 :            : 
     149                 :        117 : int list_length(struct list_head *bank)
     150                 :            : {
     151                 :        117 :         int ret = 0;
     152                 :            :         struct secvar *var;
     153                 :            : 
     154                 :        373 :         list_for_each(bank, var, link)
     155                 :        256 :                 ret++;
     156                 :            : 
     157                 :        117 :         return ret;
     158                 :            : }