WIP: parameter export hacks

.vscode/settings.json

@@ -137,5 +137,8 @@
         "workbench.settings.enableNaturalLanguageSearch": false,
         "yaml.schemas": {
                 "${workspaceFolder}/validation/module_schema.yaml": "${workspaceFolder}/src/modules/*/module.yaml"
-        }
+        },
+        "python.autoComplete.extraPaths": [
+                "/opt/ros/foxy/lib/python3.8/site-packages"
+        ]
 }

platforms/nuttx/src/px4/common/board_crashdump.c

@@ -369,7 +369,7 @@ __EXPORT void board_crashdump(uintptr_t currentsp, FAR void *tcb, FAR const char
 		pdump->info.flags |= eInvalidUserStackPtr;
 	}
 
-	int rv = px4_savepanic(HARDFAULT_FILENO, (uint8_t *)pdump, sizeof(fullcontext_s));
+	int rv = stm32_bbsram_savepanic(HARDFAULT_FILENO, (uint8_t *)pdump, sizeof(fullcontext_s));
 
 	/* Test if memory got wiped because of using _sdata */
 

platforms/nuttx/src/px4/nxp/k66/include/px4_arch/micro_hal.h

@@ -87,10 +87,6 @@ __BEGIN_DECLS
 #define PX4_CPU_UUID_WORD32_FORMAT_SIZE         (PX4_CPU_UUID_WORD32_LENGTH-1+(2*PX4_CPU_UUID_BYTE_LENGTH)+1)
 #define PX4_CPU_MFGUID_FORMAT_SIZE              ((2*PX4_CPU_MFGUID_BYTE_LENGTH)+1)
 
-#define kinetis_bbsram_savepanic(fileno, context, length) (0) // todo:Not implemented yet
-
-#define px4_savepanic(fileno, context, length)   kinetis_bbsram_savepanic(fileno, context, length)
-
 /* bus_num is zero based on kinetis and must be translated from the legacy one based */
 
 #define PX4_BUS_OFFSET       1                  /* Kinetis buses are 0 based and adjustment is needed */

platforms/nuttx/src/px4/nxp/rt106x/include/px4_arch/micro_hal.h

@@ -82,10 +82,6 @@ __BEGIN_DECLS
 #define PX4_CPU_UUID_WORD32_FORMAT_SIZE         (PX4_CPU_UUID_WORD32_LENGTH-1+(2*PX4_CPU_UUID_BYTE_LENGTH)+1)
 #define PX4_CPU_MFGUID_FORMAT_SIZE              ((2*PX4_CPU_MFGUID_BYTE_LENGTH)+1)
 
-#define imxrt_bbsram_savepanic(fileno, context, length) (0) // todo:Not implemented yet
-
-#define px4_savepanic(fileno, context, length)   imxrt_bbsram_savepanic(fileno, context, length)
-
 /* bus_num is 1 based on imx and must be translated from the legacy one based */
 
 #define PX4_BUS_OFFSET       0                  /* imxrt buses are 1 based no adjustment needed */

platforms/nuttx/src/px4/nxp/s32k14x/include/px4_arch/micro_hal.h

@@ -89,10 +89,6 @@ __BEGIN_DECLS
 #define PX4_CPU_UUID_WORD32_FORMAT_SIZE         (PX4_CPU_UUID_WORD32_LENGTH-1+(2*PX4_CPU_UUID_BYTE_LENGTH)+1)
 #define PX4_CPU_MFGUID_FORMAT_SIZE              ((2*PX4_CPU_MFGUID_BYTE_LENGTH)+1)
 
-#define s32k1xx_bbsram_savepanic(fileno, context, length) (0) // todo:Not implemented yet
-
-#define px4_savepanic(fileno, context, length)   s32k1xx_bbsram_savepanic(fileno, context, length)
-
 /* bus_num is zero based on s32k1xx and must be translated from the legacy one based */
 
 #define PX4_BUS_OFFSET       1                  /* s32k1xx buses are 0 based and adjustment is needed */

platforms/nuttx/src/px4/stm/stm32_common/include/px4_arch/micro_hal.h

@@ -88,8 +88,6 @@ __BEGIN_DECLS
 #define PX4_CPU_UUID_WORD32_FORMAT_SIZE         (PX4_CPU_UUID_WORD32_LENGTH-1+(2*PX4_CPU_UUID_BYTE_LENGTH)+1)
 #define PX4_CPU_MFGUID_FORMAT_SIZE              ((2*PX4_CPU_MFGUID_BYTE_LENGTH)+1)
 
-#define px4_savepanic(fileno, context, length)  stm32_bbsram_savepanic(fileno, context, length)
-
 #define PX4_BUS_OFFSET       0                  /* STM buses are 1 based no adjustment needed */
 #define px4_spibus_initialize(bus_num_1based)   stm32_spibus_initialize(bus_num_1based)
 

src/lib/parameters/CMakeLists.txt

@@ -154,7 +154,7 @@ if (NOT "${PX4_BOARD}" MATCHES "px4_io")
 	)
 
 	target_link_libraries(parameters PRIVATE perf tinybson px4_layer)
-	target_compile_definitions(parameters PRIVATE -DMODULE_NAME="parameters")
+	target_compile_definitions(parameters PRIVATE -DMODULE_NAME="parameters" -DDEBUG_BUILD)
 	target_compile_options(parameters
 		PRIVATE
 			-Wno-cast-align		# TODO: fix and enable

src/lib/parameters/flashparams/flashparams.cpp

@@ -117,7 +117,7 @@ param_export_internal(bool only_unsaved, param_filter_func filter)
 		case PARAM_TYPE_INT32:
 			i = s->val.i;
 
-			if (bson_encoder_append_int(&encoder, param_name(s->param), i)) {
+			if (bson_encoder_append_int32(&encoder, param_name(s->param), i)) {
 				debug("BSON append failed for '%s'", param_name(s->param));
 				goto out;
 			}

src/lib/parameters/parameters.cpp

@@ -1009,6 +1009,8 @@ int param_reset_no_notification(param_t param) { return param_reset_internal(par
 static void
 param_reset_all_internal(bool auto_save)
 {
+	PX4_INFO("param_reset_all_internal");
+
 	param_lock_writer();
 
 	if (param_values != nullptr) {
@@ -1131,33 +1133,42 @@ int param_save_default()
 		return res;
 	}
 
-	/* write parameters to temp file */
-	int fd = PARAM_OPEN(filename, O_WRONLY | O_CREAT, PX4_O_MODE_666);
-
-	if (fd < 0) {
-		PX4_ERR("failed to open param file: %s", filename);
-
-		return PX4_ERROR;
-	}
-
 	int attempts = 5;
 
 	while (res != OK && attempts > 0) {
-		res = param_export(fd, false, nullptr);
-		attempts--;
 
-		if (res != PX4_OK) {
+		/* write parameters to temp file */
-			PX4_ERR("param_export failed, retrying %d", attempts);
+		int fd = ::open(filename, O_WRONLY | O_CREAT, PX4_O_MODE_666);
-			lseek(fd, 0, SEEK_SET); // jump back to the beginning of the file
+
+		if (fd >= 0) {
+			PX4_DEBUG("param export %d/5", attempts - 4);
+			res = param_export(fd, false, nullptr);
+			::close(fd);
+
+			if (res == PX4_OK) {
+				fd = -1;
+
+				static const char *backup_file = PX4_ROOTFSDIR"/eeprom/parameters_backup.bson";
+				fd = ::open(backup_file, O_WRONLY | O_CREAT, PX4_O_MODE_666);
+				res = param_export(fd, false, nullptr);
+				::close(fd);
+
+			} else {
+				PX4_ERR("param_export failed, retrying %d", attempts);
+			}
+
+		} else {
+			PX4_ERR("failed to open param file: %s", filename);
+			return PX4_ERROR;
 		}
+
+		attempts--;
 	}
 
 	if (res != OK) {
 		PX4_ERR("failed to write parameters to file: %s", filename);
 	}
 
-	PARAM_CLOSE(fd);
-
 	return res;
 }
 
@@ -1200,20 +1211,19 @@ param_load_default()
 int
 param_export(int fd, bool only_unsaved, param_filter_func filter)
 {
-	int	result = -1;
 	perf_begin(param_export_perf);
 
 	if (fd < 0) {
 		param_lock_writer();
 		// flash_param_save() will take the shutdown lock
-		result = flash_param_save(only_unsaved, filter);
+		int result = flash_param_save(only_unsaved, filter);
 		param_unlock_writer();
 		perf_end(param_export_perf);
 		return result;
 	}
 
-	param_wbuf_s *s = nullptr;
+
-	struct bson_encoder_s encoder;
+
 
 	int shutdown_lock_ret = px4_shutdown_lock();
 
@@ -1226,16 +1236,31 @@ param_export(int fd, bool only_unsaved, param_filter_func filter)
 
 	param_lock_reader();
 
+	bson_encoder_s encoder{};
 	uint8_t bson_buffer[256];
 	bson_encoder_init_buf_file(&encoder, fd, &bson_buffer, sizeof(bson_buffer));
 
+	int result = PX4_ERROR;
+	param_wbuf_s *s = nullptr;
+	uint32_t export_crc32 = 0;
+	uint32_t export_count_int32 = 0;
+	uint32_t export_count_double = 0;
+	size_t total_size = sizeof(int32_t);
+
 	/* no modified parameters -> we are done */
 	if (param_values == nullptr) {
-		result = 0;
+		result = PX4_OK;
 		goto out;
 	}
 
-	while ((s = (struct param_wbuf_s *)utarray_next(param_values, s)) != nullptr) {
+	while ((s = (param_wbuf_s *)utarray_next(param_values, s)) != nullptr) {
+
+		if (encoder.dead) {
+			PX4_ERR("bson encoder dead!");
+			result = PX4_ERROR;
+			goto out;
+		}
+
 		/*
 		 * If we are only saving values changed since last save, and this
 		 * one hasn't, then skip it
@@ -1275,28 +1300,39 @@ param_export(int fd, bool only_unsaved, param_filter_func filter)
 
 		s->unsaved = false;
 
-		const char *name = param_name(s->param);
-		const size_t size = param_size(s->param);
-
 		/* append the appropriate BSON type object */
 		switch (param_type(s->param)) {
-
 		case PARAM_TYPE_INT32: {
+				const char *name = param_name(s->param);
 				const int32_t i = s->val.i;
-				PX4_DEBUG("exporting: %s (%d) size: %lu val: %d", name, s->param, (long unsigned int)size, i);
+				size_t bson_size = sizeof(int8_t) + strlen(name) + 1 + sizeof(i);
+				total_size += bson_size;
+				PX4_DEBUG("exporting: %s (%d) (name size: %d) size: %lu val: %d - size: %d, total_size: %d", name, s->param,
+					  strlen(name) + 1, (long unsigned int)param_size(s->param), i, bson_size, total_size);
 
-				if (bson_encoder_append_int(&encoder, name, i)) {
+				if (bson_encoder_append_int32(&encoder, name, i) == 0) {
+					export_count_int32++;
+
+				} else {
 					PX4_ERR("BSON append failed for '%s'", name);
 					goto out;
 				}
+
 			}
 			break;
 
 		case PARAM_TYPE_FLOAT: {
+				const char *name = param_name(s->param);
 				const double f = (double)s->val.f;
-				PX4_DEBUG("exporting: %s (%d) size: %lu val: %.3f", name, s->param, (long unsigned int)size, (double)f);
+				size_t bson_size = sizeof(int8_t) + strlen(name) + 1 + sizeof(f);
+				total_size += bson_size;
+				PX4_DEBUG("exporting: %s (%d) (name size: %d) size: %lu val: %.3f - size: %d, total_size: %d", name, s->param,
+					  strlen(name) + 1, (long unsigned int)param_size(s->param), (double)f, bson_size, total_size);
 
-				if (bson_encoder_append_double(&encoder, name, f)) {
+				if (bson_encoder_append_double(&encoder, name, f) == 0) {
+					export_count_double++;
+
+				} else {
 					PX4_ERR("BSON append failed for '%s'", name);
 					goto out;
 				}
@@ -1307,16 +1343,29 @@ param_export(int fd, bool only_unsaved, param_filter_func filter)
 			PX4_ERR("unrecognized parameter type");
 			goto out;
 		}
+
+		const char *name = param_name(s->param);
+		const void *val = &(s->val);
+		export_crc32 = crc32part((const uint8_t *)name, strlen(name), export_crc32);
+		export_crc32 = crc32part((const uint8_t *)val, param_size(s->param), export_crc32);
 	}
 
-	result = 0;
+	result = PX4_OK;
 
 out:
 
-	if (result == 0) {
+	if (result == PX4_OK) {
+		bson_encoder_append_int32(&encoder, "PX4_PARAMETER_CRC32", export_crc32);
+		bson_encoder_append_int32(&encoder, "PX4_PARAMETER_COUNT_INT32", export_count_int32);
+		bson_encoder_append_int32(&encoder, "PX4_PARAMETER_COUNT_DOUBLE", export_count_double);
+
+		PX4_DEBUG("bson_encoder_fini");
+
 		if (bson_encoder_fini(&encoder) != PX4_OK) {
 			PX4_ERR("bson encoder finish failed");
 		}
+
+		PX4_DEBUG("BSON final size = %d, crc32: %X", encoder.total_written_size, export_crc32);
 	}
 
 	param_unlock_reader();
@@ -1373,16 +1422,22 @@ param_import_callback(bson_decoder_t decoder, void *priv, bson_node_t node)
 
 	switch (node->type) {
 	case BSON_INT32: {
-			if (param_type(param) != PARAM_TYPE_INT32) {
+			if (strcmp(node->name, "PX4_PARAMETER_CRC32") == 0) {
-				PX4_WARN("unexpected type for %s", node->name);
+				int32_t crc32 = node->i;
-				result = 1; // just skip this entry
+				PX4_INFO("%s = %X", node->name, crc32);
-				goto out;
+
+			} else {
+				if (param_type(param) != PARAM_TYPE_INT32) {
+					PX4_WARN("unexpected type for %s", node->name);
+					result = 1; // just skip this entry
+					goto out;
+				}
+
+				i = node->i;
+				v = &i;
+
+				PX4_DEBUG("Imported %s with value %d", param_name(param), i);
 			}
-
-			i = node->i;
-			v = &i;
-
-			PX4_DEBUG("Imported %s with value %d", param_name(param), i);
 		}
 		break;
 
@@ -1405,6 +1460,11 @@ param_import_callback(bson_decoder_t decoder, void *priv, bson_node_t node)
 		goto out;
 	}
 
+	{
+		decoder->import_scratch = crc32part((const uint8_t *)node->name, strlen(node->name), decoder->import_scratch);
+		decoder->import_scratch = crc32part((const uint8_t *)v, param_size(param), decoder->import_scratch);
+	}
+
 	if (param_set_internal(param, v, state->mark_saved, true)) {
 		PX4_DEBUG("error setting value for '%s'", node->name);
 		goto out;
@@ -1420,6 +1480,11 @@ out:
 static int
 param_import_internal(int fd, bool mark_saved)
 {
+
+	off_t fsize = lseek(fd, 0, SEEK_END);
+	PX4_DEBUG("param file size = %d", fsize);
+	lseek(fd, 0, SEEK_SET);
+
 	bson_decoder_s decoder;
 	param_import_state state;
 	int result = -1;
@@ -1434,7 +1499,9 @@ param_import_internal(int fd, bool mark_saved)
 	do {
 		result = bson_decoder_next(&decoder);
 
-	} while (result > 0);
+	} while (result > 0 && !decoder.dead);
+
+	PX4_DEBUG("bson decode finished total bytes: %d, crc32: %X", decoder.total_bytes_imported, decoder.import_scratch);
 
 	return result;
 }

src/lib/parameters/parameters_shmem.cpp

@@ -1149,7 +1149,7 @@ param_export(int fd, bool only_unsaved, param_filter_func filter)
 
 				PX4_DEBUG("exporting: %s (%d) size: %d val: %d", name, s->param, size, i);
 
-				if (bson_encoder_append_int(&encoder, name, i)) {
+				if (bson_encoder_append_int32(&encoder, name, i)) {
 					PX4_ERR("BSON append failed for '%s'", name);
 					goto out;
 				}

src/lib/parameters/tinybson/CMakeLists.txt

@@ -33,5 +33,5 @@
 
 add_library(tinybson tinybson.cpp)
 target_compile_definitions(tinybson PRIVATE -DMODULE_NAME="tinybson")
-target_compile_options(tinybson PRIVATE -Wno-sign-compare) # TODO: fix this
+target_compile_options(tinybson PRIVATE -Wno-sign-compare -Wno-error) # TODO: fix this
 add_dependencies(tinybson prebuild_targets)

src/lib/parameters/tinybson/tinybson.cpp

@@ -45,7 +45,7 @@
 
 #include "tinybson.h"
 
-#if 0
+#if 1
 # define debug(fmt, args...)		do { PX4_INFO("BSON: " fmt, ##args); } while(0)
 #else
 # define debug(fmt, args...)		do { } while(0)
@@ -64,7 +64,14 @@ read_x(bson_decoder_t decoder, void *p, size_t s)
 	CODER_CHECK(decoder);
 
 	if (decoder->fd > -1) {
-		return (BSON_READ(decoder->fd, p, s) == s) ? 0 : -1;
+		int ret = BSON_READ(decoder->fd, p, s);
+
+		if (ret == s) {
+			decoder->total_bytes_imported += ret;
+			return 0;
+		}
+
+		return -1;
 	}
 
 	if (decoder->buf != nullptr) {
@@ -79,6 +86,7 @@ read_x(bson_decoder_t decoder, void *p, size_t s)
 
 		memcpy(p, (decoder->buf + decoder->bufpos), s);
 		decoder->bufpos += s;
+		decoder->total_bytes_imported += s;
 		return 0;
 	}
 
@@ -113,8 +121,6 @@ read_double(bson_decoder_t decoder, double *d)
 int
 bson_decoder_init_file(bson_decoder_t decoder, int fd, bson_decoder_callback callback, void *priv)
 {
-	int32_t	junk;
-
 	decoder->fd = fd;
 	decoder->buf = nullptr;
 	decoder->dead = false;
@@ -125,10 +131,14 @@ bson_decoder_init_file(bson_decoder_t decoder, int fd, bson_decoder_callback cal
 	decoder->node.type = BSON_UNDEFINED;
 
 	/* read and discard document size */
-	if (read_int32(decoder, &junk)) {
+	int32_t	junk_size = 0;
+
+	if (read_int32(decoder, &junk_size)) {
 		CODER_KILL(decoder, "failed discarding length");
 	}
 
+	debug("junk_size = %d", junk_size);
+
 	/* ready for decoding */
 	return 0;
 }
@@ -340,7 +350,14 @@ write_x(bson_encoder_t encoder, const void *p, size_t s)
 
 	/* bson file encoder (non-buffered) */
 	if (encoder->fd > -1 && encoder->buf == nullptr) {
-		return (BSON_WRITE(encoder->fd, p, s) == (int)s) ? 0 : -1;
+		int ret = BSON_WRITE(encoder->fd, p, s);
+
+		if (ret == s) {
+			encoder->total_written_size += ret;
+			return 0;
+		}
+
+		return -1;
 	}
 
 	/* do we need to extend the buffer? */
@@ -353,6 +370,8 @@ write_x(bson_encoder_t encoder, const void *p, size_t s)
 			int ret = BSON_WRITE(encoder->fd, encoder->buf, encoder->bufpos);
 
 			if (ret == (int)encoder->bufpos) {
+				encoder->total_written_size += ret;
+
 				// reset buffer to beginning and continue
 				encoder->bufpos = 0;
 
@@ -432,6 +451,8 @@ bson_encoder_init_file(bson_encoder_t encoder, int fd)
 	encoder->buf = nullptr;
 	encoder->dead = false;
 
+	encoder->total_written_size = 0;
+
 	if (write_int32(encoder, 0)) {
 		CODER_KILL(encoder, "write error on document length");
 	}
@@ -449,6 +470,8 @@ bson_encoder_init_buf_file(bson_encoder_t encoder, int fd, void *buf, unsigned b
 	encoder->dead = false;
 	encoder->realloc_ok = false;
 
+	encoder->total_written_size = 0;
+
 	if (write_int32(encoder, 0)) {
 		CODER_KILL(encoder, "write error on document length");
 	}
@@ -473,6 +496,8 @@ bson_encoder_init_buf(bson_encoder_t encoder, void *buf, unsigned bufsize)
 		encoder->realloc_ok = false;
 	}
 
+	encoder->total_written_size = 0;
+
 	if (write_int32(encoder, 0)) {
 		CODER_KILL(encoder, "write error on document length");
 	}
@@ -489,13 +514,30 @@ bson_encoder_fini(bson_encoder_t encoder)
 		CODER_KILL(encoder, "write error on document terminator");
 	}
 
-	if (encoder->fd > -1 && encoder->buf != nullptr) {
+	if (encoder->fd > -1 && encoder->bufpos > 0) {
-		/* write final buffer to disk */
 		int ret = BSON_WRITE(encoder->fd, encoder->buf, encoder->bufpos);
 
-		if (ret != (int)encoder->bufpos) {
+		if (ret == (int)encoder->bufpos) {
+			encoder->total_written_size += ret;
+
+		} else {
 			CODER_KILL(encoder, "write error");
 		}
+	}
+
+	// record document size
+	if (encoder->fd > -1) {
+		off_t offset = lseek(encoder->fd, 0, SEEK_SET);
+
+		int32_t total_document_size = encoder->total_written_size;
+
+		debug("writing document size %d to beginning of file (%d)", total_document_size, offset);
+
+		if (BSON_WRITE(encoder->fd, &total_document_size, sizeof(total_document_size)) != sizeof(total_document_size)) {
+			CODER_KILL(encoder, "write error on document length");
+		}
+
+		BSON_FSYNC(encoder->fd);
 
 	} else if (encoder->buf != nullptr) {
 		/* update buffer length */
@@ -503,11 +545,6 @@ bson_encoder_fini(bson_encoder_t encoder)
 		memcpy(encoder->buf, &len, sizeof(len));
 	}
 
-	/* sync file */
-	if (encoder->fd > -1) {
-		BSON_FSYNC(encoder->fd);
-	}
-
 	return 0;
 }
 
@@ -549,25 +586,17 @@ int bson_encoder_append_bool(bson_encoder_t encoder, const char *name, bool valu
 }
 
 int
-bson_encoder_append_int(bson_encoder_t encoder, const char *name, int64_t value)
+bson_encoder_append_int32(bson_encoder_t encoder, const char *name, int32_t value)
 {
 	bool result;
 
 	CODER_CHECK(encoder);
 
 	/* use the smallest encoding that will hold the value */
-	if (value == (int32_t)value) {
+	debug("encoding %lld as int32", value);
-		debug("encoding %lld as int32", value);
+	result = write_int8(encoder, BSON_INT32) ||
-		result = write_int8(encoder, BSON_INT32) ||
+		 write_name(encoder, name) ||
-			 write_name(encoder, name) ||
+		 write_int32(encoder, value);
-			 write_int32(encoder, value);
-
-	} else {
-		debug("encoding %lld as int64", value);
-		result = write_int8(encoder, BSON_INT64) ||
-			 write_name(encoder, name) ||
-			 write_int64(encoder, value);
-	}
 
 	if (result) {
 		CODER_KILL(encoder, "write error on BSON_INT");

src/lib/parameters/tinybson/tinybson.h

@@ -103,19 +103,22 @@ typedef int	(* bson_decoder_callback)(bson_decoder_t decoder, void *priv, bson_n
 
 struct bson_decoder_s {
 	/* file reader state */
-	int			fd;
+	int			fd{-1};
 
 	/* buffer reader state */
-	uint8_t			*buf;
+	uint8_t			*buf{nullptr};
-	size_t			bufsize;
+	size_t			bufsize{0};
-	unsigned		bufpos;
+	unsigned		bufpos{0};
+	size_t                  total_bytes_imported{0};
 
-	bool			dead;
+	bool			dead{false};
-	bson_decoder_callback	callback;
+	bson_decoder_callback	callback{nullptr};
-	void			*priv;
+	void			*priv{nullptr};
-	unsigned		nesting;
+	unsigned		nesting{0};
 	struct bson_node_s	node;
-	int32_t			pending;
+	int32_t			pending{0};
+
+	uint32_t                import_scratch{0};
 };
 
 /**
@@ -179,6 +182,8 @@ typedef struct bson_encoder_s {
 	unsigned	bufsize;
 	unsigned	bufpos;
 
+	size_t          total_written_size{0};
+
 	bool		realloc_ok;
 	bool		dead;
 
@@ -252,7 +257,7 @@ __EXPORT int bson_encoder_append_bool(bson_encoder_t encoder, const char *name,
  * @param name			Node name.
  * @param value			Value to be encoded.
  */
-__EXPORT int bson_encoder_append_int(bson_encoder_t encoder, const char *name, int64_t value);
+__EXPORT int bson_encoder_append_int32(bson_encoder_t encoder, const char *name, int32_t value);
 
 /**
  * Append a double to the encoded stream

src/lib/systemlib/hardfault_log.h

@@ -41,10 +41,16 @@
 /****************************************************************************
  * Pre-processor Definitions
  ****************************************************************************/
+
+/* The path to the Battery Backed up SRAM */
+#define BBSRAM_PATH "/fs/bbr"
+
 #define HARDFAULT_REBOOT_FILENO 0
 #define HARDFAULT_REBOOT_PATH BBSRAM_PATH "" STRINGIFY(HARDFAULT_REBOOT_FILENO)
+
 #define HARDFAULT_ULOG_FILENO 3
 #define HARDFAULT_ULOG_PATH BBSRAM_PATH "" STRINGIFY(HARDFAULT_ULOG_FILENO)
+
 #define HARDFAULT_FILENO 4
 #define HARDFAULT_PATH BBSRAM_PATH "" STRINGIFY(HARDFAULT_FILENO)
 
@@ -63,20 +69,18 @@
  */
 #define BBSRAM_HEADER_SIZE 20 /* This is an assumption */
 #define BBSRAM_USED ((5*BBSRAM_HEADER_SIZE)+(BBSRAM_SIZE_FN0+BBSRAM_SIZE_FN1+BBSRAM_SIZE_FN2+BBSRAM_SIZE_FN3))
-#define BBSRAM_REAMINING (PX4_BBSRAM_SIZE-BBSRAM_USED)
+#define BBSRAM_REMAINING (PX4_BBSRAM_SIZE-BBSRAM_USED)
 #if CONFIG_ARCH_INTERRUPTSTACK <= 3
 #  define BBSRAM_NUMBER_STACKS 1
 #else
 #  define BBSRAM_NUMBER_STACKS 2
 #endif
 #define BBSRAM_FIXED_ELEMENTS_SIZE (sizeof(info_s))
-#define BBSRAM_LEFTOVER (BBSRAM_REAMINING-BBSRAM_FIXED_ELEMENTS_SIZE)
+#define BBSRAM_LEFTOVER (BBSRAM_REMAINING-BBSRAM_FIXED_ELEMENTS_SIZE)
 
 #define CONFIG_ISTACK_SIZE (BBSRAM_LEFTOVER/BBSRAM_NUMBER_STACKS/sizeof(stack_word_t))
 #define CONFIG_USTACK_SIZE (BBSRAM_LEFTOVER/BBSRAM_NUMBER_STACKS/sizeof(stack_word_t))
 
-/* The path to the Battery Backed up SRAM */
-#define BBSRAM_PATH "/fs/bbr"
 /* The sizes of the files to create (-1) use rest of BBSRAM memory */
 #define BSRAM_FILE_SIZES { \
 		BBSRAM_SIZE_FN0,   /* For Time stamp only */                  \
@@ -256,15 +260,13 @@ typedef struct {
 	fault_regs_s          fault_regs;             /* NVIC status */
 	stack_t               stacks;                 /* Stack info */
 #if CONFIG_TASK_NAME_SIZE > 0
-	char                  name[CONFIG_TASK_NAME_SIZE + 1]; /* Task name (with NULL
+	char                  name[CONFIG_TASK_NAME_SIZE + 1]; /* Task name (with NULL terminator) */
-													* terminator) */
 #endif
-	char                  filename[MAX_FILE_PATH_LENGTH]; /* the Last of chars in
+	char                  filename[MAX_FILE_PATH_LENGTH]; /* the Last of chars in __FILE__ to up_assert */
-												  * __FILE__ to up_assert */
 } info_s;
 
 typedef struct {
-	info_s    info;                       /* The info */
+	info_s    info;                 /* The info */
 #if CONFIG_ARCH_INTERRUPTSTACK > 3      /* The amount of stack data is compile time
 									 * sized backed on what is left after the
 									 * other BBSRAM files are defined

src/systemcmds/hardfault_log/hardfault_log.c

@@ -61,39 +61,8 @@
 
 #include "chip.h"
 
-
-/****************************************************************************
- * Public Function Prototypes
- ****************************************************************************/
-__EXPORT int hardfault_log_main(int argc, char *argv[]);
-
-/****************************************************************************
- * Pre-processor Definitions
- ****************************************************************************/
 #define OUT_BUFFER_LEN  200
 
-/****************************************************************************
- * Private Types
- ****************************************************************************/
-
-/****************************************************************************
- * Private Function Prototypes
- ****************************************************************************/
-static int genfault(int fault);
-/****************************************************************************
- * Private Data
- ****************************************************************************/
-/****************************************************************************
- * Public Data
- ****************************************************************************/
-
-/****************************************************************************
- * Private Functions
- ****************************************************************************/
-/****************************************************************************
- * genfault
- ****************************************************************************/
-
 static int genfault(int fault)
 {
 
@@ -140,7 +109,7 @@ bool verify_ram_address(uint32_t bot, uint32_t size)
 {
 	bool ret = true;
 #if defined STM32_IS_SRAM
-	ret =  STM32_IS_SRAM(bot) && STM32_IS_SRAM(bot +  size);
+	ret = STM32_IS_SRAM(bot) && STM32_IS_SRAM(bot + size);
 #endif
 	return ret;
 }
@@ -213,7 +182,6 @@ static void identify(const char *caller)
 	}
 }
 
-
 /****************************************************************************
  * hardfault_get_desc
  ****************************************************************************/
@@ -469,8 +437,7 @@ static int write_registers_info(int fdout, info_s *pi, char *buffer, int sz)
 /****************************************************************************
  * write_interrupt_stack_info
  ****************************************************************************/
-static int write_interrupt_stack_info(int fdout, info_s *pi, char *buffer,
+static int write_interrupt_stack_info(int fdout, info_s *pi, char *buffer, unsigned int sz)
-				      unsigned int sz)
 {
 	int ret = ENOENT;
 
@@ -502,8 +469,7 @@ static int write_user_stack_info(int fdout, info_s *pi, char *buffer,
 /****************************************************************************
  * write_dump_info
  ****************************************************************************/
-static int write_dump_info(int fdout, info_s *info, struct bbsramd_s *desc,
+static int write_dump_info(int fdout, info_s *info, struct bbsramd_s *desc, char *buffer, unsigned int sz)
-			   char *buffer, unsigned int sz)
 {
 	char fmtbuff[ TIME_FMT_LEN + 1];
 	format_fault_time(HEADER_TIME_FMT, &desc->lastwrite, fmtbuff, sizeof(fmtbuff));
@@ -528,11 +494,9 @@ static int write_dump_info(int fdout, info_s *info, struct bbsramd_s *desc,
 	}
 
 #ifdef CONFIG_TASK_NAME_SIZE
-	n = snprintf(buffer, sz, " in file:%s at line: %d running task: %s\n",
+	n = snprintf(buffer, sz, " in file:%s at line: %d running task: %s\n", info->filename, info->lineno, info->name);
-		     info->filename, info->lineno, info->name);
 #else
-	n = snprintf(buffer, sz, " in file:%s at line: %d \n",
+	n = snprintf(buffer, sz, " in file:%s at line: %d \n", info->filename, info->lineno);
-		     info->filename, info->lineno);
 #endif
 
 	if (n != write(fdout, buffer, n)) {
@@ -563,8 +527,7 @@ static int write_dump_info(int fdout, info_s *info, struct bbsramd_s *desc,
 /****************************************************************************
  * write_dump_time
  ****************************************************************************/
-static int write_dump_time(char *caller, char *tag, int fdout,
+static int write_dump_time(char *caller, char *tag, int fdout, struct timespec *ts, char *buffer, unsigned int sz)
-			   struct timespec *ts, char *buffer, unsigned int sz)
 {
 	int ret = OK;
 	char fmtbuff[ TIME_FMT_LEN + 1];
@@ -577,27 +540,27 @@ static int write_dump_time(char *caller, char *tag, int fdout,
 
 	return ret;
 }
+
 /****************************************************************************
  * write_dump_footer
  ****************************************************************************/
-static int write_dump_header(char *caller, int fdout, struct timespec *ts,
+static int write_dump_header(char *caller, int fdout, struct timespec *ts, char *buffer, unsigned int sz)
-			     char *buffer, unsigned int sz)
 {
 	return write_dump_time(caller, "Begin", fdout, ts, buffer, sz);
 }
+
 /****************************************************************************
  * write_dump_footer
  ****************************************************************************/
-static int write_dump_footer(char *caller, int fdout, struct timespec *ts,
+static int write_dump_footer(char *caller, int fdout, struct timespec *ts, char *buffer, unsigned int sz)
-			     char *buffer, unsigned int sz)
 {
 	return write_dump_time(caller, "END", fdout, ts, buffer, sz);
 }
+
 /****************************************************************************
  * write_intterupt_satck
  ****************************************************************************/
-static int write_intterupt_stack(int fdin, int fdout, info_s *pi, char *buffer,
+static int write_intterupt_stack(int fdin, int fdout, info_s *pi, char *buffer, unsigned int sz)
-				 unsigned int sz)
 {
 	int ret = ENOENT;
 
@@ -615,12 +578,10 @@ static int write_intterupt_stack(int fdin, int fdout, info_s *pi, char *buffer,
 	return ret;
 }
 
-
 /****************************************************************************
  * write_user_stack
  ****************************************************************************/
-static int write_user_stack(int fdin, int fdout, info_s *pi, char *buffer,
+static int write_user_stack(int fdin, int fdout, info_s *pi, char *buffer, unsigned int sz)
-			    unsigned int sz)
 {
 	int ret = ENOENT;
 
@@ -646,7 +607,6 @@ static int write_user_stack(int fdin, int fdout, info_s *pi, char *buffer,
  */
 static int hardfault_append_to_ulog(const char *caller, int fdin)
 {
-
 	int ret = 0;
 	int write_size_remaining = lseek(fdin, 0, SEEK_END);
 
@@ -769,7 +729,6 @@ static int hardfault_append_to_ulog(const char *caller, int fdin)
 		goto out;
 	}
 
-
 	// now append the data
 	lseek(ulog_fd, 0, SEEK_END);
 
@@ -835,7 +794,6 @@ out:
 	return ret;
 }
 
-
 /****************************************************************************
  * commit
  ****************************************************************************/
@@ -848,7 +806,6 @@ static int hardfault_commit(char *caller)
 	ret = hardfault_get_desc(caller, &desc, false);
 
 	if (ret >= 0) {
-
 		int fd = ret;
 		state = (desc.lastwrite.tv_sec || desc.lastwrite.tv_nsec) ?  OK : 1;
 		int rv = close(fd);
@@ -858,7 +815,6 @@ static int hardfault_commit(char *caller)
 			syslog(LOG_INFO, "Failed to Close Fault Log (%d)\n", rv);
 
 		} else {
-
 			if (state != OK) {
 				identify(caller);
 				syslog(LOG_INFO, "Nothing to save\n", path);
@@ -910,12 +866,10 @@ static int hardfault_commit(char *caller)
 	return ret;
 }
 
-
 /****************************************************************************
  * hardfault_dowrite
  ****************************************************************************/
-static int hardfault_dowrite(char *caller, int infd, int outfd,
+static int hardfault_dowrite(char *caller, int infd, int outfd, struct bbsramd_s *desc, int format)
-			     struct bbsramd_s *desc, int format)
 {
 	int ret = -ENOMEM;
 	char *line = zalloc(OUT_BUFFER_LEN);
@@ -1009,10 +963,6 @@ static int hardfault_dowrite(char *caller, int infd, int outfd,
 	return ret;
 }
 
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
 /****************************************************************************
  * hardfault_rearm
  ****************************************************************************/
@@ -1101,7 +1051,6 @@ __EXPORT int hardfault_increment_reboot(char *caller, bool reset)
 		syslog(LOG_INFO, "Failed to open Fault reboot count file [%s] (%d)\n", HARDFAULT_REBOOT_PATH, ret);
 
 	} else {
-
 		ret = OK;
 
 		if (!reset) {
@@ -1133,10 +1082,10 @@ __EXPORT int hardfault_increment_reboot(char *caller, bool reset)
 
 	return ret;
 }
+
 /****************************************************************************
  * hardfault_write
  ****************************************************************************/
-
 __EXPORT int hardfault_write(char *caller, int fd, int format, bool rearm)
 {
 	struct bbsramd_s desc;
@@ -1224,15 +1173,12 @@ __EXPORT int hardfault_log_main(int argc, char *argv[])
 	}
 
 	if (!strcmp(argv[1], "check")) {
-
 		return hardfault_check_status(self);
 
 	} else if (!strcmp(argv[1], "rearm")) {
-
 		return hardfault_rearm(self);
 
 	} else if (!strcmp(argv[1], "fault")) {
-
 		int fault = 0;
 
 		if (argc > 2) {
@@ -1242,17 +1188,13 @@ __EXPORT int hardfault_log_main(int argc, char *argv[])
 		return genfault(fault);
 
 	} else if (!strcmp(argv[1], "commit")) {
-
 		return hardfault_commit(self);
 
 	} else if (!strcmp(argv[1], "count")) {
-
 		return hardfault_increment_reboot(self, false);
 
 	} else if (!strcmp(argv[1], "reset")) {
-
 		return hardfault_increment_reboot(self, true);
-
 	}
 
 	print_usage();

src/systemcmds/tests/test_bson.cpp

@@ -66,15 +66,15 @@ encode(bson_encoder_t encoder)
 		return 1;
 	}
 
-	if (bson_encoder_append_int(encoder, "int1", sample_small_int) != 0) {
+	if (bson_encoder_append_int32(encoder, "int1", sample_small_int) != 0) {
 		PX4_ERR("FAIL: encoder: append int failed");
 		return 1;
 	}
 
-	if (bson_encoder_append_int(encoder, "int2", sample_big_int) != 0) {
+	// if (bson_encoder_append_int64(encoder, "int2", sample_big_int) != 0) {
-		PX4_ERR("FAIL: encoder: append int failed");
+	// 	PX4_ERR("FAIL: encoder: append int failed");
-		return 1;
+	// 	return 1;
-	}
+	// }
 
 	if (bson_encoder_append_double(encoder, "double1", sample_double) != 0) {
 		PX4_ERR("FAIL: encoder: append double failed");