kv_aos.c 3.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169
  1. /*
  2. * Copyright (C) 2019-2020 Alibaba Group Holding Limited
  3. */
  4. #include <stdint.h>
  5. #include <ulog/ulog.h>
  6. #include <aos/kv.h>
  7. #include "kv_linux.h"
  8. #define TAG "KV"
  9. static kv_t g_kv;
  10. static aos_kv_mutex_t g_kv_lock;
  11. static int __kv_init(const char *pathname)
  12. {
  13. g_kv_lock.key_file = pathname;
  14. int ret = kv_init(&g_kv, pathname);
  15. /* shmkey ftok need real path, must call after kv_init */
  16. aos_kv_mutex_new(&g_kv_lock);
  17. return ret;
  18. }
  19. static int __kv_setdata(char *key, char *buf, int bufsize)
  20. {
  21. if (g_kv.handle < 0) {
  22. return -1;
  23. }
  24. aos_kv_mutex_lock(&g_kv_lock, -1);
  25. int ret = kv_set(&g_kv, key, buf, bufsize) >= 0 ? 0 : -1;
  26. aos_kv_mutex_unlock(&g_kv_lock);
  27. return ret;
  28. }
  29. static int __kv_getdata(char *key, char *buf, int bufsize)
  30. {
  31. if (g_kv.handle < 0) {
  32. return -1;
  33. }
  34. if (key == NULL || buf == NULL || bufsize <= 0)
  35. return -1;
  36. aos_kv_mutex_lock(&g_kv_lock, -1);
  37. int ret = kv_get(&g_kv, key, buf, bufsize);
  38. aos_kv_mutex_unlock(&g_kv_lock);
  39. return ret;
  40. }
  41. static int __kv_del(char *key)
  42. {
  43. if (g_kv.handle < 0) {
  44. return -1;
  45. }
  46. aos_kv_mutex_lock(&g_kv_lock, -1);
  47. int ret = kv_rm(&g_kv, key);
  48. aos_kv_mutex_unlock(&g_kv_lock);
  49. return ret;
  50. }
  51. static int __kv_reset(void)
  52. {
  53. if (g_kv.handle < 0) {
  54. return -1;
  55. }
  56. aos_kv_mutex_lock(&g_kv_lock, -1);
  57. int ret = kv_reset(&g_kv);
  58. aos_kv_mutex_unlock(&g_kv_lock);
  59. return ret;
  60. }
  61. void __kv_foreach(void (*func)(char *key, char *val, uint16_t val_size, void *arg), void *arg)
  62. {
  63. if (func == NULL) {
  64. LOGE(TAG, "%s: param error", __FUNCTION__);
  65. return;
  66. }
  67. aos_kv_mutex_lock(&g_kv_lock, -1);
  68. kv_iter(&g_kv, func, arg);
  69. aos_kv_mutex_unlock(&g_kv_lock);
  70. }
  71. int aos_kv_init(const char *pathname)
  72. {
  73. return __kv_init(pathname);
  74. }
  75. __attribute__((weak)) int aos_kv_set(const char *key, void *value, int len, int sync)
  76. {
  77. return __kv_setdata((char *)key, value, len);
  78. }
  79. __attribute__((weak)) int aos_kv_setstring(const char *key, const char *v)
  80. {
  81. return __kv_setdata((char *)key, (void *)v, strlen(v));
  82. }
  83. __attribute__((weak)) int aos_kv_setfloat(const char *key, float v)
  84. {
  85. return __kv_setdata((char *)key, (void *)&v, sizeof(v));
  86. }
  87. __attribute__((weak)) int aos_kv_setint(const char *key, int v)
  88. {
  89. return __kv_setdata((char *)key, (void *)&v, sizeof(v));
  90. }
  91. __attribute__((weak)) int aos_kv_get(const char *key, void *buffer, int *buffer_len)
  92. {
  93. if (buffer_len) {
  94. int ret = __kv_getdata((char *)key, buffer, *buffer_len);
  95. if (ret > 0) {
  96. *buffer_len = ret;
  97. }
  98. return (ret <= 0) ? -1 : 0;
  99. }
  100. return -1;
  101. }
  102. __attribute__((weak)) int aos_kv_getstring(const char *key, char *value, int len)
  103. {
  104. int ret;
  105. ret = __kv_getdata((char *)key, (char *)value, len - 1);
  106. if (ret > 0) {
  107. value[ret < len ? ret : len - 1] = '\0';
  108. }
  109. return ret;
  110. }
  111. __attribute__((weak)) int aos_kv_getfloat(const char *key, float *value)
  112. {
  113. int ret = __kv_getdata((char *)key, (char *)value, sizeof(float));
  114. return (ret == sizeof(float)) ? 0 : -1;
  115. }
  116. __attribute__((weak)) int aos_kv_getint(const char *key, int *value)
  117. {
  118. int ret = __kv_getdata((char *)key, (char *)value, sizeof(int));
  119. return (ret == sizeof(int)) ? 0 : -1;
  120. }
  121. __attribute__((weak)) int aos_kv_del(const char *key)
  122. {
  123. return __kv_del((char *)key);
  124. }
  125. __attribute__((weak)) int aos_kv_reset(void)
  126. {
  127. return __kv_reset();
  128. }
  129. __attribute__((weak)) void aos_kv_foreach(void (*func)(char *key, char *val, uint16_t val_size, void *arg), void *arg)
  130. {
  131. __kv_foreach(func, arg);
  132. }