2013-02-28 16:17:58 -04:00
|
|
|
/*
|
|
|
|
DataFlash logging - file oriented variant
|
|
|
|
|
|
|
|
This uses posix file IO to create log files called logNN.dat in the
|
|
|
|
given directory
|
|
|
|
*/
|
2016-02-17 21:25:53 -04:00
|
|
|
#pragma once
|
2013-02-28 16:17:58 -04:00
|
|
|
|
2018-01-05 03:16:47 -04:00
|
|
|
#if HAL_OS_POSIX_IO || HAL_OS_FATFS_IO
|
2015-08-08 03:13:38 -03:00
|
|
|
|
2016-07-29 21:52:21 -03:00
|
|
|
#include <AP_HAL/utility/RingBuffer.h>
|
2015-06-25 10:53:20 -03:00
|
|
|
#include "DataFlash_Backend.h"
|
|
|
|
|
|
|
|
class DataFlash_File : public DataFlash_Backend
|
2013-02-28 16:17:58 -04:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
// constructor
|
2015-11-09 18:14:22 -04:00
|
|
|
DataFlash_File(DataFlash_Class &front,
|
|
|
|
DFMessageWriter_DFLogStart *,
|
|
|
|
const char *log_directory);
|
2013-02-28 16:17:58 -04:00
|
|
|
|
|
|
|
// initialisation
|
2015-11-09 18:14:22 -04:00
|
|
|
void Init() override;
|
2017-06-14 22:19:54 -03:00
|
|
|
bool CardInserted(void) const override;
|
2013-02-28 16:17:58 -04:00
|
|
|
|
|
|
|
// erase handling
|
2017-03-30 06:23:17 -03:00
|
|
|
void EraseAll() override;
|
2013-02-28 16:17:58 -04:00
|
|
|
|
2015-08-08 03:13:38 -03:00
|
|
|
// possibly time-consuming preparation handling:
|
2017-03-30 06:23:17 -03:00
|
|
|
bool NeedPrep() override;
|
|
|
|
void Prep() override;
|
2015-08-08 03:13:38 -03:00
|
|
|
|
2013-02-28 16:17:58 -04:00
|
|
|
/* Write a block of data at current offset */
|
2017-06-30 08:09:20 -03:00
|
|
|
bool _WritePrioritisedBlock(const void *pBuffer, uint16_t size, bool is_critical) override;
|
2017-03-30 06:23:17 -03:00
|
|
|
uint32_t bufferspace_available() override;
|
2013-02-28 16:17:58 -04:00
|
|
|
|
|
|
|
// high level interface
|
2015-10-20 07:32:31 -03:00
|
|
|
uint16_t find_last_log() override;
|
2017-03-30 06:23:17 -03:00
|
|
|
void get_log_boundaries(uint16_t log_num, uint16_t & start_page, uint16_t & end_page) override;
|
|
|
|
void get_log_info(uint16_t log_num, uint32_t &size, uint32_t &time_utc) override;
|
|
|
|
int16_t get_log_data(uint16_t log_num, uint16_t page, uint32_t offset, uint16_t len, uint8_t *data) override;
|
2015-10-20 07:32:31 -03:00
|
|
|
uint16_t get_num_logs() override;
|
2015-11-09 18:14:22 -04:00
|
|
|
uint16_t start_new_log(void) override;
|
2013-02-28 16:17:58 -04:00
|
|
|
|
2015-06-18 22:57:01 -03:00
|
|
|
#if CONFIG_HAL_BOARD == HAL_BOARD_SITL || CONFIG_HAL_BOARD == HAL_BOARD_LINUX
|
2017-03-30 06:23:17 -03:00
|
|
|
void flush(void) override;
|
2015-06-18 22:57:01 -03:00
|
|
|
#endif
|
2016-11-06 02:09:39 -04:00
|
|
|
void periodic_1Hz(const uint32_t now) override;
|
2017-03-30 06:23:17 -03:00
|
|
|
void periodic_fullrate(const uint32_t now) override;
|
2016-07-07 04:12:27 -03:00
|
|
|
|
|
|
|
// this method is used when reporting system status over mavlink
|
2017-03-30 06:23:17 -03:00
|
|
|
bool logging_enabled() const override;
|
|
|
|
bool logging_failed() const override;
|
2016-07-07 04:12:27 -03:00
|
|
|
|
2017-07-06 22:34:31 -03:00
|
|
|
bool logging_started(void) const override { return _write_fd != -1; }
|
|
|
|
|
2016-07-28 02:58:20 -03:00
|
|
|
void vehicle_was_disarmed() override;
|
|
|
|
|
2017-07-06 22:28:42 -03:00
|
|
|
virtual void PrepForArming() override;
|
|
|
|
|
2017-06-08 22:36:18 -03:00
|
|
|
protected:
|
|
|
|
|
|
|
|
bool WritesOK() const override;
|
2017-06-30 08:09:20 -03:00
|
|
|
bool StartNewLogOK() const override;
|
2017-06-08 22:36:18 -03:00
|
|
|
|
2013-02-28 16:17:58 -04:00
|
|
|
private:
|
2013-09-28 03:29:58 -03:00
|
|
|
int _write_fd;
|
2018-06-13 21:32:44 -03:00
|
|
|
char *_write_filename;
|
|
|
|
uint32_t _last_write_ms;
|
|
|
|
|
2013-02-28 16:17:58 -04:00
|
|
|
int _read_fd;
|
2013-12-15 03:57:49 -04:00
|
|
|
uint16_t _read_fd_log_num;
|
2013-04-17 08:32:53 -03:00
|
|
|
uint32_t _read_offset;
|
2014-01-12 23:25:16 -04:00
|
|
|
uint32_t _write_offset;
|
2014-12-20 22:31:27 -04:00
|
|
|
volatile bool _open_error;
|
2013-02-28 16:17:58 -04:00
|
|
|
const char *_log_directory;
|
|
|
|
|
2016-11-06 02:09:39 -04:00
|
|
|
uint32_t _io_timer_heartbeat;
|
|
|
|
bool io_thread_alive() const;
|
2017-04-17 07:42:30 -03:00
|
|
|
uint8_t io_thread_warning_decimation_counter;
|
2016-11-06 02:09:39 -04:00
|
|
|
|
2015-11-10 23:51:03 -04:00
|
|
|
uint16_t _cached_oldest_log;
|
|
|
|
|
2013-04-19 21:25:10 -03:00
|
|
|
/*
|
|
|
|
read a block
|
|
|
|
*/
|
2015-11-09 18:14:22 -04:00
|
|
|
bool ReadBlock(void *pkt, uint16_t size) override;
|
2013-04-19 21:25:10 -03:00
|
|
|
|
2015-10-20 07:32:31 -03:00
|
|
|
uint16_t _log_num_from_list_entry(const uint16_t list_entry);
|
|
|
|
|
2015-08-08 03:13:38 -03:00
|
|
|
// possibly time-consuming preparations handling
|
|
|
|
void Prep_MinSpace();
|
2015-10-20 07:32:31 -03:00
|
|
|
uint16_t find_oldest_log();
|
|
|
|
int64_t disk_space_avail();
|
|
|
|
int64_t disk_space();
|
2015-08-08 03:13:38 -03:00
|
|
|
float avail_space_percent();
|
|
|
|
|
2015-10-20 07:32:31 -03:00
|
|
|
bool file_exists(const char *filename) const;
|
|
|
|
bool log_exists(const uint16_t lognum) const;
|
|
|
|
|
2015-08-08 03:13:38 -03:00
|
|
|
#if CONFIG_HAL_BOARD == HAL_BOARD_SITL || CONFIG_HAL_BOARD == HAL_BOARD_LINUX
|
|
|
|
// I always seem to have less than 10% free space on my laptop:
|
|
|
|
const float min_avail_space_percent = 0.1f;
|
|
|
|
#else
|
|
|
|
const float min_avail_space_percent = 10.0f;
|
|
|
|
#endif
|
2013-02-28 16:17:58 -04:00
|
|
|
// write buffer
|
2016-07-29 21:52:21 -03:00
|
|
|
ByteBuffer _writebuf;
|
2014-01-12 23:25:16 -04:00
|
|
|
const uint16_t _writebuf_chunk;
|
2013-09-28 03:29:58 -03:00
|
|
|
uint32_t _last_write_time;
|
2013-02-28 16:17:58 -04:00
|
|
|
|
|
|
|
/* construct a file name given a log number. Caller must free. */
|
2015-10-20 07:32:31 -03:00
|
|
|
char *_log_file_name(const uint16_t log_num) const;
|
2017-02-10 22:39:50 -04:00
|
|
|
char *_log_file_name_long(const uint16_t log_num) const;
|
|
|
|
char *_log_file_name_short(const uint16_t log_num) const;
|
2015-10-20 07:32:31 -03:00
|
|
|
char *_lastlog_file_name() const;
|
|
|
|
uint32_t _get_log_size(const uint16_t log_num) const;
|
|
|
|
uint32_t _get_log_time(const uint16_t log_num) const;
|
2013-04-17 08:32:53 -03:00
|
|
|
|
2017-03-30 06:23:17 -03:00
|
|
|
void stop_logging(void) override;
|
2013-12-27 23:24:28 -04:00
|
|
|
|
2013-09-28 03:29:58 -03:00
|
|
|
void _io_timer(void);
|
2014-01-12 23:25:16 -04:00
|
|
|
|
2016-07-29 21:52:21 -03:00
|
|
|
uint32_t critical_message_reserved_space() const {
|
2015-08-06 09:18:28 -03:00
|
|
|
// possibly make this a proportional to buffer size?
|
2016-07-29 21:52:21 -03:00
|
|
|
uint32_t ret = 1024;
|
|
|
|
if (ret > _writebuf.get_size()) {
|
2015-12-03 07:01:53 -04:00
|
|
|
// in this case you will only get critical messages
|
2016-07-29 21:52:21 -03:00
|
|
|
ret = _writebuf.get_size();
|
2015-12-03 07:01:53 -04:00
|
|
|
}
|
|
|
|
return ret;
|
2015-08-06 09:18:28 -03:00
|
|
|
};
|
2016-07-30 15:13:12 -03:00
|
|
|
uint32_t non_messagewriter_message_reserved_space() const {
|
2015-09-17 07:58:35 -03:00
|
|
|
// possibly make this a proportional to buffer size?
|
2016-07-30 15:13:12 -03:00
|
|
|
uint32_t ret = 1024;
|
2016-07-29 21:52:21 -03:00
|
|
|
if (ret >= _writebuf.get_size()) {
|
2015-12-03 07:01:53 -04:00
|
|
|
// need to allow messages out from the messagewriters. In
|
|
|
|
// this case while you have a messagewriter you won't get
|
|
|
|
// any other messages. This should be a corner case!
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
return ret;
|
2015-09-17 07:58:35 -03:00
|
|
|
};
|
2015-08-06 09:18:28 -03:00
|
|
|
|
2016-07-06 05:58:47 -03:00
|
|
|
// free-space checks; filling up SD cards under NuttX leads to
|
|
|
|
// corrupt filesystems which cause loss of data, failure to gather
|
|
|
|
// data and failures-to-boot.
|
2016-11-06 01:26:31 -04:00
|
|
|
uint32_t _free_space_last_check_time; // milliseconds
|
|
|
|
const uint32_t _free_space_check_interval = 1000UL; // milliseconds
|
2016-07-06 05:58:47 -03:00
|
|
|
const uint32_t _free_space_min_avail = 8388608; // bytes
|
|
|
|
|
2017-09-12 22:46:34 -03:00
|
|
|
// semaphore mediates access to the ringbuffer
|
2015-12-16 18:23:14 -04:00
|
|
|
AP_HAL::Semaphore *semaphore;
|
2017-09-12 22:46:34 -03:00
|
|
|
// write_fd_semaphore mediates access to write_fd so the frontend
|
|
|
|
// can open/close files without causing the backend to write to a
|
|
|
|
// bad fd
|
|
|
|
AP_HAL::Semaphore *write_fd_semaphore;
|
2015-12-16 18:23:14 -04:00
|
|
|
|
2014-01-12 23:25:16 -04:00
|
|
|
// performance counters
|
2015-10-20 02:49:32 -03:00
|
|
|
AP_HAL::Util::perf_counter_t _perf_write;
|
|
|
|
AP_HAL::Util::perf_counter_t _perf_fsync;
|
|
|
|
AP_HAL::Util::perf_counter_t _perf_errors;
|
|
|
|
AP_HAL::Util::perf_counter_t _perf_overruns;
|
2017-07-27 23:07:35 -03:00
|
|
|
|
|
|
|
const char *last_io_operation = "";
|
2017-08-25 04:18:26 -03:00
|
|
|
|
|
|
|
struct df_stats {
|
|
|
|
uint16_t blocks;
|
|
|
|
uint32_t bytes;
|
|
|
|
uint32_t buf_space_min;
|
|
|
|
uint32_t buf_space_max;
|
|
|
|
uint32_t buf_space_sigma;
|
|
|
|
};
|
|
|
|
struct df_stats stats;
|
|
|
|
|
|
|
|
void Log_Write_DataFlash_Stats_File(const struct df_stats &_stats);
|
|
|
|
void df_stats_gather(uint16_t bytes_written);
|
|
|
|
void df_stats_log();
|
|
|
|
void df_stats_clear();
|
|
|
|
|
2013-02-28 16:17:58 -04:00
|
|
|
};
|
|
|
|
|
2015-08-08 03:13:38 -03:00
|
|
|
#endif // HAL_OS_POSIX_IO
|