esp_websocket_client: Add Kconfig options for PSRAM allocation

This commit adds two new Kconfig options:
- ESP_WS_CLIENT_TASK_STACK_IN_EXT_RAM: Allows allocating the websocket task stack in PSRAM.
- ESP_WS_CLIENT_ALLOC_IN_EXT_RAM: Allows allocating the websocket client structure in PSRAM.

These options are useful for memory-constrained applications (like TLS-heavy projects) to save internal RAM.
The implementation uses xTaskCreateStaticPinnedToCore for PSRAM stacks and includes a fallback to internal RAM if PSRAM allocation fails.
The fix also ensures correct stack depth calculation (words vs bytes) and includes stability fixes for deferred destruction.

Author: shardt68

components/esp_websocket_client/Kconfig

@@ -20,4 +20,18 @@ menu "ESP WebSocket client"
         default 2000
         help
             Timeout for acquiring the TX lock when using separate TX lock.
+
+    config ESP_WS_CLIENT_TASK_STACK_IN_EXT_RAM
+        bool "Allocate websocket task stack in PSRAM"
+        default n
+        help
+            If enabled, the websocket task stack will be allocated in PSRAM using xTaskCreateStatic.
+            This saves internal RAM but requires PSRAM to be enabled and configured.
+
+    config ESP_WS_CLIENT_ALLOC_IN_EXT_RAM
+        bool "Allocate websocket client structure in PSRAM"
+        default n
+        help
+            If enabled, the websocket client structure and its configuration will be allocated in PSRAM.
+            This saves internal RAM but requires PSRAM to be enabled and configured.
 endmenu

components/esp_websocket_client/esp_websocket_client.c

@@ -156,6 +156,9 @@ struct esp_websocket_client {
     int                         payload_offset;
     esp_transport_keep_alive_t  keep_alive_cfg;
     struct ifreq                *if_name;
+    StackType_t                 *task_stack_buffer;
+    StaticTask_t                *task_buffer;
+    esp_timer_handle_t          destroy_timer;
 };
 
 static uint64_t _tick_get_ms(void)
@@ -498,6 +501,27 @@ static void destroy_and_free_resources(esp_websocket_client_handle_t client)
     if (client->status_bits) {
         vEventGroupDelete(client->status_bits);
     }
+    if (client->destroy_timer) {
+        esp_timer_stop(client->destroy_timer);
+        // If we are in the timer callback, we cannot delete the timer itself
+        // as it would return ESP_ERR_INVALID_STATE.
+        // However, the timer is a one-shot timer and will be cleaned up by the system
+        // if we don't delete it here, but to be safe and avoid leaks in other paths,
+        // we only delete it if we are NOT in the timer context.
+        // Since we don't have a clean way to check "is_in_timer_callback",
+        // and this is a one-shot timer, we can just delete it and ignore the error,
+        // or better: the timer handle is part of the client struct which is about to be freed.
+        esp_timer_delete(client->destroy_timer);
+        client->destroy_timer = NULL;
+    }
+    if (client->task_stack_buffer) {
+        heap_caps_free(client->task_stack_buffer);
+        client->task_stack_buffer = NULL;
+    }
+    if (client->task_buffer) {
+        heap_caps_free(client->task_buffer);
+        client->task_buffer = NULL;
+    }
     free(client);
     client = NULL;
 }
@@ -747,7 +771,11 @@ static int esp_websocket_client_send_with_exact_opcode(esp_websocket_client_hand
 
 esp_websocket_client_handle_t esp_websocket_client_init(const esp_websocket_client_config_t *config)
 {
+    #if CONFIG_ESP_WS_CLIENT_ALLOC_IN_EXT_RAM
+    esp_websocket_client_handle_t client = heap_caps_calloc(1, sizeof(struct esp_websocket_client), MALLOC_CAP_SPIRAM);
+#else
     esp_websocket_client_handle_t client = calloc(1, sizeof(struct esp_websocket_client));
+#endif
     ESP_WS_CLIENT_MEM_CHECK(TAG, client, return NULL);
 
     esp_event_loop_args_t event_args = {
@@ -782,7 +810,11 @@ esp_websocket_client_handle_t esp_websocket_client_init(const esp_websocket_clie
     ESP_WS_CLIENT_MEM_CHECK(TAG, client->tx_lock, goto _websocket_init_fail);
 #endif
 
+    #if CONFIG_ESP_WS_CLIENT_ALLOC_IN_EXT_RAM
+    client->config = heap_caps_calloc(1, sizeof(websocket_config_storage_t), MALLOC_CAP_SPIRAM);
+#else
     client->config = calloc(1, sizeof(websocket_config_storage_t));
+#endif
     ESP_WS_CLIENT_MEM_CHECK(TAG, client->config, goto _websocket_init_fail);
 
     if (config->transport == WEBSOCKET_TRANSPORT_OVER_TCP) {
@@ -887,7 +919,12 @@ esp_err_t esp_websocket_client_destroy(esp_websocket_client_handle_t client)
     }
 
     if (client->status_bits && (STOPPED_BIT & xEventGroupGetBits(client->status_bits)) == 0) {
-        stop_wait_task(client);
+        if (stop_wait_task(client) == ESP_FAIL) {
+            ESP_LOGI(TAG, "esp_websocket_client_destroy called from task, deferring...");
+            client->run = false;
+            client->selected_for_destroying = true;
+            return ESP_OK;
+        }
     }
 
     destroy_and_free_resources(client);
@@ -1118,6 +1155,21 @@ static esp_err_t esp_websocket_client_recv(esp_websocket_client_handle_t client)
 
 static int esp_websocket_client_send_close(esp_websocket_client_handle_t client, int code, const char *additional_data, int total_len, TickType_t timeout);
 
+static void esp_websocket_client_destroy_timer_cb(void *arg)
+{
+    esp_websocket_client_handle_t client = (esp_websocket_client_handle_t)arg;
+    ESP_LOGI(TAG, "Deferred destruction of websocket client");
+
+    // The timer is one-shot and has finished. We can delete it now
+    // before calling destroy, which would otherwise fail to delete it
+    // from within this callback.
+    esp_timer_handle_t timer = client->destroy_timer;
+    client->destroy_timer = NULL;
+    esp_timer_delete(timer);
+
+    esp_websocket_client_destroy(client);
+}
+
 static void esp_websocket_client_task(void *pv)
 {
     const int lock_timeout = portMAX_DELAY;
@@ -1377,7 +1429,16 @@ static void esp_websocket_client_task(void *pv)
     xEventGroupSetBits(client->status_bits, STOPPED_BIT);
     client->state = WEBSOCKET_STATE_UNKNOW;
     if (client->selected_for_destroying == true) {
-        destroy_and_free_resources(client);
+        esp_timer_create_args_t timer_args = {
+            .callback = esp_websocket_client_destroy_timer_cb,
+            .arg = client,
+            .name = "ws_destroy"
+        };
+        if (esp_timer_create(&timer_args, &client->destroy_timer) == ESP_OK) {
+            esp_timer_start_once(client->destroy_timer, 100 * 1000); // 100ms
+        } else {
+            ESP_LOGE(TAG, "Failed to create destroy timer, memory will leak");
+        }
     }
     vTaskDelete(NULL);
 }
@@ -1400,8 +1461,48 @@ esp_err_t esp_websocket_client_start(esp_websocket_client_handle_t client)
         }
     }
 
-    if (xTaskCreate(esp_websocket_client_task, client->config->task_name ? client->config->task_name : "websocket_task",
-                    client->config->task_stack, client, client->config->task_prio, &client->task_handle) != pdTRUE) {
+    #if CONFIG_ESP_WS_CLIENT_TASK_STACK_IN_EXT_RAM
+    if (client->config->task_stack > 0) {
+        if (client->task_stack_buffer == NULL) {
+            client->task_stack_buffer = (StackType_t *)heap_caps_malloc(client->config->task_stack, MALLOC_CAP_SPIRAM);
+        }
+        // TCB must be in internal RAM for xTaskCreateStaticPinnedToCore
+        if (client->task_buffer == NULL) {
+            client->task_buffer = (StaticTask_t *)heap_caps_malloc(sizeof(StaticTask_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+        }
+        
+        if (client->task_stack_buffer && client->task_buffer) {
+            ESP_LOGI(TAG, "Allocated %d bytes stack in PSRAM for WebSocket task", client->config->task_stack);
+            client->task_handle = xTaskCreateStaticPinnedToCore(
+                esp_websocket_client_task,
+                client->config->task_name ? client->config->task_name : "websocket_task",
+                client->config->task_stack / sizeof(StackType_t),
+                client,
+                client->config->task_prio,
+                client->task_stack_buffer,
+                client->task_buffer,
+                0 // Core 0 (Network)
+            );
+        } else {
+            ESP_LOGW(TAG, "Failed to allocate PSRAM stack, falling back to internal RAM");
+            if (client->task_stack_buffer) heap_caps_free(client->task_stack_buffer);
+            if (client->task_buffer) heap_caps_free(client->task_buffer);
+            client->task_stack_buffer = NULL;
+            client->task_buffer = NULL;
+            
+            xTaskCreatePinnedToCore(esp_websocket_client_task, client->config->task_name ? client->config->task_name : "websocket_task",
+                            client->config->task_stack, client, client->config->task_prio, &client->task_handle, 0);
+        }
+    } else {
+        xTaskCreatePinnedToCore(esp_websocket_client_task, client->config->task_name ? client->config->task_name : "websocket_task",
+                    client->config->task_stack, client, client->config->task_prio, &client->task_handle, 0);
+    }
+#else
+    xTaskCreatePinnedToCore(esp_websocket_client_task, client->config->task_name ? client->config->task_name : "websocket_task",
+                client->config->task_stack, client, client->config->task_prio, &client->task_handle, 0);
+#endif
+
+    if (client->task_handle == NULL) {
         ESP_LOGE(TAG, "Error create websocket task");
         return ESP_FAIL;
     }

components/mdns/mdns_service.c

@@ -261,7 +261,7 @@ static esp_err_t create_task_with_caps(void)
     s_stack_buffer = mdns_mem_task_malloc(MDNS_SERVICE_STACK_DEPTH);
     ESP_GOTO_ON_FALSE(s_stack_buffer != NULL, ESP_FAIL, alloc_failed, TAG, "failed to allocate memory for the mDNS task's stack");
 
-    s_service_task_handle = xTaskCreateStaticPinnedToCore(service_task, "mdns", MDNS_SERVICE_STACK_DEPTH, NULL, MDNS_TASK_PRIORITY, s_stack_buffer, &mdns_task_buffer, MDNS_TASK_AFFINITY);
+    s_service_task_handle = xTaskCreateStaticPinnedToCore(service_task, "mdns", MDNS_SERVICE_STACK_DEPTH / sizeof(StackType_t), NULL, MDNS_TASK_PRIORITY, s_stack_buffer, &mdns_task_buffer, MDNS_TASK_AFFINITY);
     ESP_GOTO_ON_FALSE(s_service_task_handle != NULL, ESP_FAIL, err, TAG, "failed to create task for the mDNS");
 
     return ret;