fw/services/settings: speed up file rewrite, pause watchdog

settings_file_rewrite_filtered runs under a held mutex while issuing
flash erases and writes that, on a 1 MiB persist file, can take many
seconds. Once the per-app cap was raised the rewrite started tripping
the 5-second task watchdog and triggering App Throttling. FIRM-1649
flagged this; it didn't matter at the old 6 KiB cap.

Three changes:

- Pause the task watchdog for the duration of the rewrite (60 s
  budget, comfortably covers a worst-case 1 MiB rewrite). Same pattern
  already used during boot in main.c.
- Add settings_raw_iter_read_key_val / write_key_val helpers that
  read or write the key and value as a single contiguous PFS call.
  Drops per-record I/O from 6 PFS round-trips (separate header, key,
  val) to 4, which on a file with thousands of records saves a few
  hundred ms of seek/read state-machine overhead.
- Allocate one reusable buffer outside the rewrite loop instead of
  two kernel_malloc/kernel_free pairs per record.

Flash erase and program time still dominate, so this doesn't make
small rewrites feel different, but the watchdog pause keeps big
rewrites from triggering throttle/recovery storms in the logs.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Signed-off-by: Joshua Jun <lets@throw.rocks>

Author: jplexer

include/pbl/services/settings/settings_raw_iter.h

@@ -112,11 +112,20 @@ int settings_raw_iter_get_resumed_record_pos(SettingsRawIter *iter);
 void settings_raw_iter_read_key(SettingsRawIter *iter, uint8_t *key);
 void settings_raw_iter_read_val(SettingsRawIter *iter, uint8_t *val, int val_len);
 
+//! Read key and value into a single contiguous buffer in one PFS call.
+//! key_val_out must be at least key_len + val_len bytes. Key occupies the first
+//! key_len bytes, val the next val_len bytes.
+void settings_raw_iter_read_key_val(SettingsRawIter *iter, uint8_t *key_val_out);
+
 //! Write (over top of) the header/key/val for the current record.
 void settings_raw_iter_write_header(SettingsRawIter *iter, SettingsRecordHeader *hdr);
 void settings_raw_iter_write_key(SettingsRawIter *iter, const uint8_t *key);
 void settings_raw_iter_write_val(SettingsRawIter *iter, const uint8_t *val);
 
+//! Write key and value from a single contiguous buffer in one PFS call.
+//! Layout matches settings_raw_iter_read_key_val.
+void settings_raw_iter_write_key_val(SettingsRawIter *iter, const uint8_t *key_val);
+
 //! Write a byte in place for the current record
 void settings_raw_iter_write_byte(SettingsRawIter *iter, int offset, uint8_t byte);
 

src/fw/services/settings/settings_file.c

@@ -5,6 +5,7 @@
 #include "pbl/services/settings/settings_raw_iter.h"
 
 #include "drivers/rtc.h"
+#include "drivers/task_watchdog.h"
 #include "kernel/pbl_malloc.h"
 #include "pbl/services/filesystem/pfs.h"
 #include "system/logging.h"
@@ -214,18 +215,28 @@ status_t settings_file_rewrite_filtered(
   PBL_LOG_INFO("FIRM-1649: settings_file_rewrite_filtered start file=%s",
                file->name);
 
+  // A 1 MiB grow can take many seconds of pure flash erase + write time. Pause
+  // the task watchdog rather than letting it trip and kick App Throttling.
+  task_watchdog_pause(60);
+
   SettingsFile new_file;
   status_t status = prv_open(&new_file, file->name, OP_FLAG_OVERWRITE | OP_FLAG_READ,
                              file->max_used_space, file->alloc_used_space,
                              file->min_alloc_used_space);
   if (status < 0) {
     PBL_LOG_ERR("Could not open temporary file to compact settings file. Error %"PRIi32".",
             status);
+    task_watchdog_resume();
     return status;
   }
 
   settings_raw_iter_begin(&new_file.iter);
 
+  // One reusable buffer for key+val per record; sized for the worst case.
+  // Avoids two malloc/free pairs per record over what can be thousands of
+  // records on a large persist file.
+  uint8_t *kv_buf = kernel_malloc(SETTINGS_KEY_MAX_LEN + SETTINGS_VAL_MAX_LEN);
+
   for (settings_raw_iter_begin(&file->iter); !settings_raw_iter_end(&file->iter);
       settings_raw_iter_next(&file->iter)) {
     SettingsRecordHeader *hdr = &file->iter.hdr;
@@ -249,22 +260,19 @@ status_t settings_file_rewrite_filtered(
       clear_flag(hdr, SETTINGS_FLAG_OVERWRITE_STARTED);
     }
 
-    // Get the old key and value
-    uint8_t *key = kernel_malloc(hdr->key_len);
-    settings_raw_iter_read_key(&file->iter, key);
-    uint8_t *val = kernel_malloc(hdr->val_len);
-    settings_raw_iter_read_val(&file->iter, val, hdr->val_len);
+    // Read key+val in a single PFS call; key occupies the first key_len bytes.
+    settings_raw_iter_read_key_val(&file->iter, kv_buf);
+    uint8_t *key = kv_buf;
+    uint8_t *val = kv_buf + hdr->key_len;
 
     // Include in re-written file if it passes the filter
     if (!filter_cb || filter_cb(key, hdr->key_len, val, hdr->val_len, context)) {
       settings_raw_iter_write_header(&new_file.iter, hdr);
-      settings_raw_iter_write_key(&new_file.iter, key);
-      settings_raw_iter_write_val(&new_file.iter, val);
+      settings_raw_iter_write_key_val(&new_file.iter, kv_buf);
       settings_raw_iter_next(&new_file.iter);
     }
-    kernel_free(key);
-    kernel_free(val);
   }
+  kernel_free(kv_buf);
   settings_file_close(file);
   // We have to close and reopen the new_file so that it's temp flag is cleared.
   // Before the close succeeds, if we reboot, we will just end up reading the
@@ -278,6 +286,8 @@ status_t settings_file_rewrite_filtered(
                     file->max_used_space, alloc_used_space, min_alloc_used_space);
   kernel_free(name);
 
+  task_watchdog_resume();
+
   // FIRM-1649: instrumentation. See note at the top of this function.
   const uint32_t rewrite_elapsed_ms =
       (uint32_t)(((rtc_get_ticks() - rewrite_start_ticks) * 1000) / RTC_TICKS_HZ);

src/fw/services/settings/settings_raw_iter.c

@@ -186,6 +186,13 @@ void settings_raw_iter_read_val(SettingsRawIter *iter, uint8_t *val_out, int val
   sfs_read(iter, val_out, val_len);
 }
 
+void settings_raw_iter_read_key_val(SettingsRawIter *iter, uint8_t *key_val_out) {
+  const int kv_len = iter->hdr.key_len + iter->hdr.val_len;
+  if (kv_len == 0) return;
+  sfs_seek(iter, iter->hdr_pos + sizeof(SettingsRecordHeader), FSeekSet);
+  sfs_read(iter, key_val_out, kv_len);
+}
+
 void settings_raw_iter_write_header(SettingsRawIter *iter, SettingsRecordHeader *hdr) {
   PBL_ASSERTN(hdr->key_len <= SETTINGS_KEY_MAX_LEN);
   PBL_ASSERTN(hdr->val_len <= SETTINGS_VAL_MAX_LEN);
@@ -203,6 +210,13 @@ void settings_raw_iter_write_val(SettingsRawIter *iter, const uint8_t *val) {
   sfs_seek(iter, iter->hdr_pos + sizeof(SettingsRecordHeader) + iter->hdr.key_len, FSeekSet);
   sfs_write(iter, val, iter->hdr.val_len);
 }
+
+void settings_raw_iter_write_key_val(SettingsRawIter *iter, const uint8_t *key_val) {
+  const int kv_len = iter->hdr.key_len + iter->hdr.val_len;
+  if (kv_len == 0) return;
+  sfs_seek(iter, iter->hdr_pos + sizeof(SettingsRecordHeader), FSeekSet);
+  sfs_write(iter, key_val, kv_len);
+}
 void settings_raw_iter_write_byte(SettingsRawIter *iter, int offset, uint8_t byte) {
   sfs_seek(iter, iter->hdr_pos +
       sizeof(SettingsRecordHeader) + iter->hdr.key_len + offset, FSeekSet);

tests/stubs/stubs_task_watchdog.h

@@ -18,3 +18,9 @@ void task_watchdog_feed(void) {
 
 void task_watchdog_bit_set(PebbleTask task) {
 }
+
+void task_watchdog_pause(unsigned int seconds) {
+}
+
+void task_watchdog_resume(void) {
+}