app_flashdb.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325
  1. /*
  2. * Copyright (c) 2006-2021, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2026-07-08 Administrator the first version
  9. * 2026-07-09 Administrator fix: drop dead code after goto, write default KVs once,
  10. * properly init blob, deinit before re-init, check default
  11. * write result, guard TSDB partition lookup.
  12. */
  13. #include <app_flashdb.h>
  14. #include <control.h>
  15. #include <string.h>
  16. #define DBG_ENABLE
  17. #define DBG_COLOR
  18. #define DBG_TAG "app_flashdb"
  19. #define DBG_LEVEL DBG_LOG
  20. #include <rtdbg.h> /* must after DBG_LVL, DBG_TAG or other options */
  21. #define FDB_LOG_TAG "[app_flashdb]"
  22. #define FLASH_FLAG_VALUE 0xAA
  23. /* device status structure */
  24. Flashdb_typedef flashdb_value;
  25. static uint32_t boot_count = 0;
  26. static time_t boot_time[10] = {0, 1, 2, 3};
  27. /* Mutex for FlashDB operations (replace __disable_irq) */
  28. static rt_mutex_t flashdb_lock = RT_NULL;
  29. /* default KV nodes.
  30. * NOTE: every entry must reference a real object whose address/size is valid,
  31. * because FlashDB will memcpy the data from the pointer at the time it is set.
  32. */
  33. static uint8_t default_flag = FLASH_FLAG_VALUE;
  34. static uint8_t default_tape_used = 0;
  35. static uint8_t default_filter_used = 0;
  36. static uint16_t default_tape_max = 6000; //60m
  37. static uint16_t default_filter_max = 1000; //10m
  38. static uint8_t default_freq_filter = 7;
  39. static uint8_t default_work_day = 0;
  40. static struct fdb_default_kv_node default_kv_table[] = {
  41. {"flag", &default_flag, sizeof(default_flag)},
  42. {"boot_count", &boot_count, sizeof(boot_count)},
  43. {"boot_time", &boot_time, sizeof(boot_time)},
  44. {"tape_used", &default_tape_used, sizeof(default_tape_used)},
  45. {"filter_used", &default_filter_used, sizeof(default_filter_used)},
  46. {"tape_max", &default_tape_max, sizeof(default_tape_max)},
  47. {"filter_max", &default_filter_max, sizeof(default_filter_max)},
  48. {"freq_filter", &default_freq_filter, sizeof(default_freq_filter)},
  49. {"worked_day", &default_work_day, sizeof(default_work_day)},
  50. };
  51. /* KVDB object */
  52. static struct fdb_kvdb kvdb = { 0 };
  53. /* KVDB 是否初始化完成(EasyFlash 兼容层使用) */
  54. static uint8_t kvdb_ready = 0;
  55. /* TSDB object */
  56. struct fdb_tsdb tsdb = { 0 };
  57. /* counts for simulated timestamp */
  58. static int counts = 0;
  59. static void lock(fdb_db_t db)
  60. {
  61. if (flashdb_lock != RT_NULL) {
  62. rt_mutex_take(flashdb_lock, RT_WAITING_FOREVER);
  63. }
  64. }
  65. static void unlock(fdb_db_t db)
  66. {
  67. if (flashdb_lock != RT_NULL) {
  68. rt_mutex_release(flashdb_lock);
  69. }
  70. }
  71. static fdb_time_t get_time(void)
  72. {
  73. /* Using the counts instead of timestamp.
  74. * Replace this with RTC time if needed.
  75. */
  76. return ++counts;
  77. }
  78. static fdb_err_t write_default_kv(struct fdb_kvdb *db)
  79. {
  80. struct fdb_blob blob;
  81. fdb_err_t result = FDB_NO_ERR;
  82. for (size_t i = 0; i < sizeof(default_kv_table) / sizeof(default_kv_table[0]); i++) {
  83. result = fdb_kv_set_blob(db,
  84. default_kv_table[i].key,
  85. fdb_blob_make(&blob,
  86. default_kv_table[i].value,
  87. default_kv_table[i].value_len));
  88. /* Yield CPU to let syswatch feed watchdog */
  89. rt_thread_mdelay(1);
  90. if (result != FDB_NO_ERR) {
  91. LOG_E("fdb_kv_set_blob(\"%s\") failed: %d",
  92. default_kv_table[i].key, (int)result);
  93. break;
  94. }
  95. }
  96. return result;
  97. }
  98. int app_flashdb_init(void)
  99. {
  100. fdb_err_t result;
  101. #ifdef FDB_USING_KVDB
  102. { /* KVDB Sample */
  103. struct fdb_default_kv default_kv;
  104. struct fdb_blob blob;
  105. struct fal_partition *kv_part;
  106. uint8_t format_retry = 0;
  107. /* Initialize mutex for FlashDB operations */
  108. flashdb_lock = rt_mutex_create("flashdb_lock", RT_IPC_FLAG_FIFO);
  109. if (flashdb_lock == RT_NULL) {
  110. LOG_E("rt_mutex_create failed!");
  111. return -1;
  112. }
  113. memset(&blob, 0, sizeof(blob));
  114. default_kv.kvs = default_kv_table;
  115. default_kv.num = sizeof(default_kv_table) / sizeof(default_kv_table[0]);
  116. /* get fdb_kv partition for fallback erase (only used on init failure) */
  117. kv_part = fal_partition_find("fdb_kv");
  118. if(kv_part==RT_NULL)
  119. {
  120. LOG_E("fdb_kv partition Not found!");
  121. return -1;
  122. }
  123. LOG_I("fdb_kv partition: flash=%s offset=0x%08X len=0x%08X",
  124. kv_part->flash_name, kv_part->offset, kv_part->len);
  125. retry_init:
  126. /* set the lock and unlock function if you want */
  127. fdb_kvdb_control(&kvdb, FDB_KVDB_CTRL_SET_LOCK, (void *)lock);
  128. fdb_kvdb_control(&kvdb, FDB_KVDB_CTRL_SET_UNLOCK, (void *)unlock);
  129. result = fdb_kvdb_init(&kvdb, "env", "fdb_kv", &default_kv, NULL);
  130. if (result != FDB_NO_ERR) {
  131. LOG_E("fdb_kvdb_init Failed:%d", result);
  132. return -1;
  133. }
  134. kvdb_ready = 1;
  135. /* integrity check, if CRC error then erase and retry once */
  136. result = fdb_kvdb_check(&kvdb);
  137. if (result != FDB_NO_ERR) {
  138. LOG_W("KVDB integrity check failed (CRC error), formatting fdb_kv partition...");
  139. if (format_retry == 0 && kv_part != RT_NULL) {
  140. fdb_kvdb_deinit(&kvdb);
  141. fal_partition_erase(kv_part, 0, kv_part->len);
  142. format_retry = 1;
  143. goto retry_init;
  144. }
  145. }
  146. /* check the flag: 0xAA means user parameters have been stored before. */
  147. memset(&blob, 0, sizeof(blob));
  148. memset(&flashdb_value, 0, sizeof(flashdb_value));
  149. fdb_kv_get_blob(&kvdb, "flag",fdb_blob_make(&blob,&flashdb_value.iSave,sizeof(flashdb_value.iSave)));
  150. if (blob.saved.len == 0 || flashdb_value.iSave != FLASH_FLAG_VALUE) {
  151. LOG_I("Flag invalid (0x%02X), initializing default parameters", flashdb_value.iSave);
  152. /* If we get here from a fresh boot the sectors are already formatted
  153. * by FlashDB itself, so we only need to write the default values. */
  154. result = write_default_kv(&kvdb);
  155. if (result != FDB_NO_ERR) {
  156. LOG_E("write_default_kv failed: %d", (int)result);
  157. return -1;
  158. }
  159. LOG_I("Default parameters saved");
  160. } else {
  161. LOG_I("Flag == 0xAA, loading existing parameters from FlashDB");
  162. fdb_kv_get_blob(&kvdb, "boot_count", fdb_blob_make(&blob, &boot_count, sizeof(boot_count)));
  163. fdb_kv_get_blob(&kvdb, "boot_time", fdb_blob_make(&blob, &boot_time, sizeof(boot_time)));
  164. fdb_kv_get_blob(&kvdb, "tape_used", fdb_blob_make(&blob, &flashdb_value.tape_used, sizeof(flashdb_value.tape_used)));
  165. fdb_kv_get_blob(&kvdb, "tape_max", fdb_blob_make(&blob, &flashdb_value.tape_max, sizeof(flashdb_value.tape_max)));
  166. fdb_kv_get_blob(&kvdb, "filter_used",fdb_blob_make(&blob, &flashdb_value.filter_used,sizeof(flashdb_value.filter_used)));
  167. fdb_kv_get_blob(&kvdb, "freq_filter",fdb_blob_make(&blob, &flashdb_value.freq_filter,sizeof(flashdb_value.freq_filter)));
  168. fdb_kv_get_blob(&kvdb, "filter_max", fdb_blob_make(&blob, &flashdb_value.filter_max, sizeof(flashdb_value.filter_max)));
  169. fdb_kv_get_blob(&kvdb, "worked_day", fdb_blob_make(&blob, &flashdb_value.worked_day, sizeof(flashdb_value.worked_day)));
  170. if(flashdb_value.filter_used>default_filter_max){
  171. flashdb_value.filter_used = default_filter_max;
  172. }
  173. FDB_INFO("boot_count:%d\n", boot_count);
  174. FDB_INFO("boot_time:%d\n", boot_time[0]);
  175. FDB_INFO("tape_used:%d\n", flashdb_value.tape_used);
  176. FDB_INFO("tape_max:%d\n", flashdb_value.tape_max);
  177. FDB_INFO("filter_used:%d\n", flashdb_value.filter_used);
  178. FDB_INFO("freq_filter:%d\n", flashdb_value.freq_filter);
  179. FDB_INFO("filter_max:%d\n", flashdb_value.filter_max);
  180. FDB_INFO("worked_day:%d\n", flashdb_value.worked_day);
  181. boot_count++;
  182. fdb_kv_set_blob(&kvdb, "boot_count",
  183. fdb_blob_make(&blob, &boot_count, sizeof(boot_count)));
  184. FDB_INFO("set the 'boot_count' value to %d\n", boot_count);
  185. }
  186. }
  187. #endif /* FDB_USING_KVDB */
  188. #ifdef _FDB_USING_TSDB
  189. { /* TSDB Sample */
  190. struct fal_partition *ts_part = fal_partition_find("fdb_ts");
  191. uint8_t ts_format_retry = 0;
  192. if (ts_part == RT_NULL) {
  193. LOG_E("fdb_ts partition Not found!");
  194. return -1;
  195. }
  196. LOG_I("fdb_ts partition: flash=%s offset=0x%08X len=0x%08X",
  197. ts_part->flash_name, ts_part->offset, ts_part->len);
  198. retry_ts_init:
  199. fdb_tsdb_control(&tsdb, FDB_TSDB_CTRL_SET_LOCK, (void *)lock);
  200. fdb_tsdb_control(&tsdb, FDB_TSDB_CTRL_SET_UNLOCK, (void *)unlock);
  201. result = fdb_tsdb_init(&tsdb, "log", "fdb_ts", get_time, 128, NULL);
  202. if (result != FDB_NO_ERR) {
  203. LOG_W("TSDB init failed, formatting fdb_ts partition...");
  204. if (ts_format_retry == 0 && ts_part != RT_NULL) {
  205. fdb_tsdb_deinit(&tsdb);
  206. fal_partition_erase(ts_part, 0, ts_part->len);
  207. ts_format_retry = 1;
  208. goto retry_ts_init;
  209. }
  210. return -1;
  211. }
  212. /* read last saved time for simulated timestamp */
  213. fdb_tsdb_control(&tsdb, FDB_TSDB_CTRL_GET_LAST_TIME, &counts);
  214. }
  215. #endif /* FDB_USING_TSDB */
  216. return 0;
  217. }
  218. /* 2026-09-28 修正: 长度由调用点显式传入(sizeof(目标变量)), 不再用 sizeof(void*)。
  219. * 原写法对 uint8_t 字段会越界读 3 字节、越界写 4 字节, 踩坏相邻成员并污染 KVDB。 */
  220. int app_flashdb_save(const char *key, const void *value, size_t len)
  221. {
  222. // 检查key是否为空
  223. if (key == NULL) {
  224. LOG_E("key is NULL");
  225. return -1;
  226. }
  227. // 检查value是否为空
  228. if (value == NULL) {
  229. LOG_E("value is NULL");
  230. return -1;
  231. }
  232. if (len == 0) {
  233. LOG_E("len is 0");
  234. return -1;
  235. }
  236. struct fdb_blob blob;
  237. memset(&blob, 0, sizeof(blob));
  238. return fdb_kv_set_blob(&kvdb, key, fdb_blob_make(&blob, value, len));
  239. }
  240. int app_flashdb_load(const char *key, void *value, size_t len)
  241. {
  242. // 检查key是否为空
  243. if (key == NULL) {
  244. LOG_E("key is NULL");
  245. return -1;
  246. }
  247. // 检查value是否为空
  248. if (value == NULL) {
  249. LOG_E("value is NULL");
  250. return -1;
  251. }
  252. if (len == 0) {
  253. LOG_E("len is 0");
  254. return -1;
  255. }
  256. struct fdb_blob blob;
  257. memset(&blob, 0, sizeof(blob));
  258. return fdb_kv_get_blob(&kvdb, key, fdb_blob_make(&blob, value, len));
  259. }
  260. /* ==================== EasyFlash 兼容层(底层为 FlashDB KVDB) ====================
  261. * 保持原 ef_get_env_blob / ef_set_env_blob 接口语义,业务代码无需改动:
  262. * - 读:key 不存在时不修改 value_buf,返回 0
  263. * - 写:返回 0 表示成功
  264. * 注意:参数存储位置由旧 easyflash 分区迁移到 fdb_kv 分区,
  265. * 升级固件后首次开机会因读取不到 iSave 标志而自动写入默认参数。
  266. */
  267. size_t ef_get_env_blob(const char *key, void *value_buf, size_t buffer_len, size_t *saved_value_len)
  268. {
  269. struct fdb_blob blob;
  270. if (!kvdb_ready || key == RT_NULL || value_buf == RT_NULL || buffer_len == 0) {
  271. if (saved_value_len != RT_NULL) {
  272. *saved_value_len = 0;
  273. }
  274. return 0;
  275. }
  276. memset(&blob, 0, sizeof(blob));
  277. fdb_kv_get_blob(&kvdb, key, fdb_blob_make(&blob, value_buf, buffer_len));
  278. if (saved_value_len != RT_NULL) {
  279. *saved_value_len = blob.saved.len;
  280. }
  281. return blob.saved.len;
  282. }
  283. int ef_set_env_blob(const char *key, const void *value_buf, size_t size)
  284. {
  285. struct fdb_blob blob;
  286. if (!kvdb_ready || key == RT_NULL || value_buf == RT_NULL || size == 0) {
  287. return -1;
  288. }
  289. memset(&blob, 0, sizeof(blob));
  290. return (fdb_kv_set_blob(&kvdb, key, fdb_blob_make(&blob, value_buf, size)) == FDB_NO_ERR) ? 0 : -1;
  291. }