Initializing MQTT helper library takes system into MPU fault

[haseebzaib]

Hi, I am using nrf9160 with aws_iot library with zephyr and ncs v2.6.1

Now the issue is when aws is initalized I get mpu fault, I have tracked down that issue is coming from mqtt helper library, the way I tracked it down is I ditch aws library and directly started using mqtt helper library and the issue persists and to further track down the issue from where it was coming, I then used simple mqtt library, now simple mqtt library works fine the issue arrives when I try to find ip address for the broker links here the sample code. This piece of code takes the controller into MPU fault. I could be wrong but as I went to issolate the code the issue comes from here.

`/**@brief Resolves the configured hostname and
 * initializes the MQTT broker structure
 */
static int broker_init(void)
{
	int err;
	struct addrinfo *result;
	struct addrinfo *addr;
	struct addrinfo hints = {
		.ai_family = AF_INET,
		.ai_socktype = SOCK_STREAM
	};

	err = getaddrinfo(CONFIG_MQTT_BROKER_HOSTNAME, NULL, &hints, &result);
	if (err) {
		LOG_ERR("getaddrinfo failed: %d", err);
		return -ECHILD;
	}

	addr = result;

	/* Look for address of the broker. */
	while (addr != NULL) {
		/* IPv4 Address. */
		if (addr->ai_addrlen == sizeof(struct sockaddr_in)) {
			struct sockaddr_in *broker4 =
				((struct sockaddr_in *)&broker);
			char ipv4_addr[NET_IPV4_ADDR_LEN];

			broker4->sin_addr.s_addr =
				((struct sockaddr_in *)addr->ai_addr)
				->sin_addr.s_addr;
			broker4->sin_family = AF_INET;
			broker4->sin_port = htons(CONFIG_MQTT_BROKER_PORT);

			inet_ntop(AF_INET, &broker4->sin_addr.s_addr,
				  ipv4_addr, sizeof(ipv4_addr));
			LOG_INF("IPv4 Address found %s", log_strdup(ipv4_addr));

			break;
		} else {
			LOG_ERR("ai_addrlen = %u should be %u or %u",
				(unsigned int)addr->ai_addrlen,
				(unsigned int)sizeof(struct sockaddr_in),
				(unsigned int)sizeof(struct sockaddr_in6));
		}

		addr = addr->ai_next;
	}

	/* Free the address. */
	freeaddrinfo(result);

	return err;
}`

Now getting back to aws library which in the backend using mqtt helper library which runs this specific code to find brokers ip address.

Here is my aws file code

`#include <zephyr/kernel.h>
#include <zephyr/sys/reboot.h>
#include <zephyr/dfu/mcuboot.h>
#include <zephyr/logging/log.h>
#include <zephyr/logging/log_ctrl.h>
#include <zephyr/net/net_if.h>
#include <zephyr/net/net_core.h>
#include <zephyr/net/net_context.h>
#include <zephyr/net/net_mgmt.h>
#include <zephyr/net/socket.h>
#include <zephyr/net/conn_mgr_connectivity.h>
#include <zephyr/net/conn_mgr_monitor.h>
#include <net/aws_iot.h>
#include <stdio.h>
#include <stdlib.h>
#include <hw_id.h>
#include "json_payload.h"

LOG_MODULE_REGISTER(app_aws);
#define CONFIG_AWS_IOT_SAMPLE_APP_VERSION "v1.0.0"
/* Application specific topics. */
#define MY_CUSTOM_TOPIC_1 "my-custom-topic/example"
#define MY_CUSTOM_TOPIC_2 "my-custom-topic/example_2"


/* Variable used to store the device's hardware ID. */
static char hw_id[HW_ID_LEN];
static bool connected;
/* Event handlers */

static void aws_iot_event_handler(const struct aws_iot_evt *const evt)
{
	switch (evt->type) {
	case AWS_IOT_EVT_CONNECTING:
		LOG_INF("AWS_IOT_EVT_CONNECTING");
		break;
	case AWS_IOT_EVT_CONNECTED:
		LOG_INF("AWS_IOT_EVT_CONNECTED");
		//on_aws_iot_evt_connected(evt);
        connected = true;
		break;
	case AWS_IOT_EVT_DISCONNECTED:
		LOG_INF("AWS_IOT_EVT_DISCONNECTED");
		//on_aws_iot_evt_disconnected();
        connected = false;
		break;
	case AWS_IOT_EVT_DATA_RECEIVED:
		LOG_INF("AWS_IOT_EVT_DATA_RECEIVED");

		LOG_INF("Received message: \"%.*s\" on topic: \"%.*s\"", evt->data.msg.len,
									 evt->data.msg.ptr,
									 evt->data.msg.topic.len,
									 evt->data.msg.topic.str);
		break;
	case AWS_IOT_EVT_PUBACK:
		LOG_INF("AWS_IOT_EVT_PUBACK, message ID: %d", evt->data.message_id);
		break;
	case AWS_IOT_EVT_PINGRESP:
		LOG_INF("AWS_IOT_EVT_PINGRESP");
		break;
	case AWS_IOT_EVT_FOTA_START:
		LOG_INF("AWS_IOT_EVT_FOTA_START");
		break;
	case AWS_IOT_EVT_FOTA_ERASE_PENDING:
		LOG_INF("AWS_IOT_EVT_FOTA_ERASE_PENDING");
		break;
	case AWS_IOT_EVT_FOTA_ERASE_DONE:
		LOG_INF("AWS_FOTA_EVT_ERASE_DONE");
		break;
	case AWS_IOT_EVT_FOTA_DONE:
		LOG_INF("AWS_IOT_EVT_FOTA_DONE");
		//on_aws_iot_evt_fota_done(evt);
		break;
	case AWS_IOT_EVT_FOTA_DL_PROGRESS:
		LOG_INF("AWS_IOT_EVT_FOTA_DL_PROGRESS, (%d%%)", evt->data.fota_progress);
		break;
	case AWS_IOT_EVT_ERROR:
		LOG_INF("AWS_IOT_EVT_ERROR, %d", evt->data.err);
		//FATAL_ERROR();
		break;
	case AWS_IOT_EVT_FOTA_ERROR:
		LOG_INF("AWS_IOT_EVT_FOTA_ERROR");
		break;
	default:
		LOG_WRN("Unknown AWS IoT event type: %d", evt->type);
		break;
	}
}

static int app_topics_subscribe(void)
{
	int err;
	static const struct mqtt_topic topic_list[] = {
		{
			.topic.utf8 = MY_CUSTOM_TOPIC_1,
			.topic.size = strlen(MY_CUSTOM_TOPIC_1),
			.qos = MQTT_QOS_1_AT_LEAST_ONCE,
		},
		{
			.topic.utf8 = MY_CUSTOM_TOPIC_2,
			.topic.size = strlen(MY_CUSTOM_TOPIC_2),
			.qos = MQTT_QOS_1_AT_LEAST_ONCE,
		}
	};

	err = aws_iot_application_topics_set(topic_list, ARRAY_SIZE(topic_list));
	if (err) {
		LOG_ERR("aws_iot_application_topics_set, error: %d", err);
		return err;
	}

	

	return 0;
}

static int aws_iot_client_init(void)
{
	int err;

	err = aws_iot_init(aws_iot_event_handler);
	if (err) {
		LOG_ERR("AWS IoT library could not be initialized, error: %d", err);
		return err;
	}

	/* Add application specific non-shadow topics to the AWS IoT library.
	 * These topics will be subscribed to when connecting to the broker.
	 */
	err = app_topics_subscribe();
	if (err) {
		LOG_ERR("Adding application specific topics failed, error: %d", err);
		return err;
	}

	return 0;
}



    int app_aws_client_init()
    {

    int err;
    err = aws_iot_client_init();
	if (err) {
		LOG_ERR("aws_iot_client_init, error: %d", err);
		return err;
	}

    }

int app_aws_init()
{
	LOG_INF("The AWS IoT sample started, version: %s", CONFIG_AWS_IOT_SAMPLE_APP_VERSION);

	int err;


	/* Get unique hardware ID, can be used as AWS IoT MQTT broker device/client ID. */
	err = hw_id_get(hw_id, ARRAY_SIZE(hw_id));
	if (err) {
		LOG_ERR("Failed to retrieve hardware ID, error: %d", err);
		return err;
	}

	LOG_INF("Hardware ID: %s", hw_id);



	const struct aws_iot_config config = {
		.client_id = hw_id,
	};

	LOG_INF("Connecting to AWS IoT");

 int rc, i = 0;

 while (i++ < 10 && !connected) {


	err = aws_iot_connect(&config);
         k_msleep(500);
	if (err == -EAGAIN) {

        LOG_INF("Connection attempt timed out");

        k_msleep(300);

	} else if (err) {
		LOG_ERR("aws_iot_connect, error: %d", err);
        return err;
	}

 }
}`

here is my main.c code

`#include <stdlib.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(Main);

#include <app_network.h>
#include <app_mqtt.h>
#include "app_aws.h"


int main(void)
{

int aws_client;
          LOG_INF("Main started .... ");
 /* Init network */
    app_net_init();
aws_client = app_aws_client_init();
       while (true)
    {

        struct app_event evt = {0};
        app_event_manager_get(&evt);



        switch (evt.type)
        {

        case APP_EVENT_ETHERNET_READY:
            LOG_INF("Ethernet is Ready");

            //app_mqtt_init();

            if(!aws_client)
            {
                app_aws_init();
            }
            else
            {
             LOG_INF("aws client issue");
            }
            break;
        default:
            break;
        }
    }

        return 0;
}`

here is my .conf file

`# GPIO
CONFIG_GPIO=y

# Logging
CONFIG_LOG=y
CONFIG_CONSOLE=y
#CONFIG_LOG_BUFFER_SIZE=2048
CONFIG_HW_ID_LIBRARY=y


CONFIG_JSON_LIBRARY=y


# Heap and stacks
CONFIG_HEAP_MEM_POOL_SIZE=10240
CONFIG_MAIN_STACK_SIZE=10240
#CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=2048

# Newlibc
CONFIG_NEWLIB_LIBC=y 

# Ethernet
CONFIG_SPI=y
CONFIG_NET_L2_ETHERNET=y
CONFIG_ETH_W5500=y
CONFIG_ETH_W5500_TIMEOUT=10000
CONFIG_ETHERNET_LOG_LEVEL_DBG=y
CONFIG_ETHERNET_LOG_LEVEL_INF=y
CONFIG_NETWORKING=y
CONFIG_NET_IPV6=n
CONFIG_NET_IPV4=y
CONFIG_NET_ARP=y
CONFIG_NET_UDP=y
CONFIG_NET_DHCPV4=y
CONFIG_NET_DHCPV4_OPTION_CALLBACKS=y
CONFIG_NET_SOCKETS=y
CONFIG_NET_SOCKETS_OFFLOAD=y
CONFIG_NET_TCP=y
CONFIG_NET_CONNECTION_MANAGER=y
CONFIG_NET_CONNECTION_MANAGER_MONITOR_STACK_SIZE=1024
CONFIG_DNS_RESOLVER=y
CONFIG_DNS_SERVER_IP_ADDRESSES=y
CONFIG_DNS_SERVER1="8.8.8.8"
# CONFIG_NET_CONFIG_NEED_IPV4=y
# CONFIG_NET_CONFIG_SETTINGS=y
CONFIG_TEST_RANDOM_GENERATOR=y
CONFIG_INIT_STACKS=y
CONFIG_NET_MGMT=y
CONFIG_NET_MGMT_EVENT=y
CONFIG_NET_LOG=y
#CONFIG_SLIP_STATISTICS=n
CONFIG_NET_SHELL=y


# AWS IoT library
CONFIG_AWS_IOT=y
CONFIG_AWS_IOT_CLIENT_ID_STATIC="aws_nrf9160"
CONFIG_AWS_IOT_BROKER_HOST_NAME="xxx.amazonaws.com"
CONFIG_AWS_IOT_TOPIC_UPDATE_DELTA_SUBSCRIBE=y
CONFIG_AWS_IOT_TOPIC_GET_ACCEPTED_SUBSCRIBE=y
CONFIG_AWS_IOT_TOPIC_GET_REJECTED_SUBSCRIBE=y

# MQTT helper library
CONFIG_MQTT_HELPER=y
CONFIG_MQTT_HELPER_SEC_TAG=201
CONFIG_MQTT_HELPER_LAST_WILL=y
CONFIG_MQTT_HELPER_STACK_SIZE=4096

# MQTT - Maximum MQTT keepalive timeout specified by AWS IoT Core
CONFIG_MQTT_KEEPALIVE=1200
CONFIG_MQTT_CLEAN_SESSION=y`

And my output

`[00:00:00.381,530] <inf> eth_w5500: MAC ADDRESS: 2 8 dc 86 7 e2
[00:00:00.382,812] <inf> eth_w5500: W5500 Initialized
*** Booting nRF Connect SDK 3758bcbfa5cd ***
[00:00:00.384,552] <inf> Main: Main started .... 
[00:00:00.384,552] <inf> app_network: Network Initialization
[00:00:00.384,582] <inf> app_network: Start on eth_w5500@0: index=1
[00:00:00.384,643] <inf> app_network: Net management event: -536608761
[00:00:02.383,392] <inf> eth_w5500: eth_w5500@0: Link up
[00:00:02.383,514] <inf> app_network: LINK UP
[00:00:04.540,222] <inf> net_dhcpv4: Received: 192.168.1.95
[00:00:04.540,344] <inf> app_network: Your address: 192.168.1.95
[00:00:04.540,374] <inf> app_network: Lease time: 4294967295 seconds
[00:00:04.540,405] <inf> app_network: Subnet: 255.255.255.0
[00:00:04.540,466] <inf> app_network: Router: 192.168.1.1
[00:00:04.540,588] <inf> app_network: Network connectivity established
[00:00:04.540,618] <inf> Main: Ethernet is Ready
[00:00:04.540,649] <inf> app_aws: The AWS IoT sample started, version: v1.0.0
[00:00:04.540,863] <inf> app_aws: Hardware ID: 77C6A60DF4F93428
[00:00:04.540,863] <inf> app_aws: Connecting to AWS IoT
[00:00:04.541,198] <err> os: ***** MPU FAULT *****
[00:00:04.541,198] <err> os:   Instruction Access Violation
[00:00:04.541,229] <err> os: r0/a1:  0x0002a47a  r1/a2:  0x00000000  r2/a3:  0x2000b110
[00:00:04.541,229] <err> os: r3/a4:  0x2000b0c4 r12/ip:  0x2000b1f8 r14/lr:  0x000143eb
[00:00:04.541,259] <err> os:  xpsr:  0x08000000
[00:00:04.541,259] <err> os: Faulting instruction address (r15/pc): 0x2000b1f8
[00:00:04.541,290] <err> os: >>> ZEPHYR FATAL ERROR 20: Unknown error on CPU 0
[00:00:04.541,320] <err> os: Current thread: 0x20002088 (main)
[00:00:04.712,432] <err> fatal_error: Resetting system`

now output shows that main thread failed but in my .conf file you can see I have allocated alot of space for heap and main thread as well and it still fails. I am lost at this part.

[haseebzaib]

I was able to solve the issue of MPU fault by removing CONFIG_NET_SOCKETS_OFFLOAD=y this. This caused the issue for some reason.