event_handler.c

[詳解]

#pragma section REPRO
#include "event_handler.h"
#include <string.h>
#include <stdlib.h>
#include "../../TlmCmd/common_cmd_packet_util.h"
#include "../../Applications/timeline_command_dispatcher_id_define.h"
#include "../TimeManager/time_manager.h"
 
#ifdef EL_IS_ENABLE_TLOG
 
typedef enum
{
  EH_EL_LOCAL_ID_EL_TOTAL_COUNTER_ERR = 0,  
  EH_EL_LOCAL_ID_EL_COUNTER_ERR,            
  EH_EL_LOCAL_ID_TOO_MANY_EVENT,            
  EH_EL_LOCAL_ID_FAIL_TO_RESPOND,           
  EH_EL_LOCAL_ID_LOG_TABLE_FULL,            
  EH_EL_LOCAL_ID_SEARCH_ERR,                
  EH_EL_LOCAL_ID_RECURSION_ERR,             
  EH_EL_LOCAL_ID_UNKNOWN_ERR                
} EH_EL_LOCAL_ID;
 
typedef enum
{
  EH_ACK_OK,
  EH_ACK_ERR
} EH_ACK;
 
typedef enum
{
  EH_RULE_SORTED_INDEX_ACK_OK = 0,           
  EH_RULE_SORTED_INDEX_ACK_ILLEGAL_RULE_ID,  
  EH_RULE_SORTED_INDEX_ACK_NOT_FOUND,        
  EH_RULE_SORTED_INDEX_ACK_FULL,             
  EH_RULE_SORTED_INDEX_ACK_RULE_OVERWRITE,   
  EH_RULE_SORTED_INDEX_ACK_DUPLICATE_FULL    
} EH_RULE_SORTED_INDEX_ACK;
 
typedef enum
{
  EH_CKECK_RULE_ACK_MATCH = 0,          
  EH_CKECK_RULE_ACK_NOT_MATCH           
} EH_CKECK_RULE_ACK;
 
 
static void EH_clear_rules_(void);
 
static void EH_clear_log_(void);
 
static EH_ACK EH_check_el_event_counter_(void);
 
static const EL_Event* EH_get_event_to_check_rule_(void);
 
static uint8_t EH_check_event_and_respond_(const EL_Event* event);
 
static uint8_t EH_check_rule_and_respond_(EH_RULE_ID rule_id, const EL_Event* event);
 
static uint8_t EH_check_higher_level_rule_and_respond_(EH_RULE_ID rule_id);
 
static EH_CKECK_RULE_ACK EH_check_rule_(EH_RULE_ID rule_id, const EL_Event* event);
 
static EH_CKECK_RULE_ACK EH_check_single_rule_(EH_RULE_ID rule_id, const EL_Event* event);
 
static EH_CKECK_RULE_ACK EH_check_continuous_rule_(EH_RULE_ID rule_id, const EL_Event* event);
 
static EH_CKECK_RULE_ACK EH_check_cumulative_rule_(EH_RULE_ID rule_id, const EL_Event* event);
 
static void EH_respond_(EH_RULE_ID rule_id);
 
static void EH_record_responded_log_(EH_RULE_ID rule_id, CCP_EXEC_STS deploy_cmd_ack);
 
static const EL_Event* EH_get_oldest_event_excluding_eh_error_level_(void);
 
static EH_RULE_SORTED_INDEX_ACK EH_search_rule_table_index_(EL_GROUP group,
                                                            uint32_t local,
                                                            EH_RULE_ID found_ids[EH_MAX_RULE_NUM_OF_EL_ID_DUPLICATES],
                                                            uint16_t found_sorted_idxes[EH_MAX_RULE_NUM_OF_EL_ID_DUPLICATES],
                                                            uint8_t* found_id_num);
 
static int EH_compare_sorted_index_for_bsearch_(const void* key, const void* elem);
 
static EH_RULE_SORTED_INDEX_ACK EH_search_rule_table_index_by_event_group_(EL_GROUP group,
                                                                           uint16_t* least_found_sorted_idx,
                                                                           uint16_t* found_sorted_idx_num);
 
static int EH_compare_sorted_index_by_event_group_for_bsearch_(const void* key, const void* elem);
 
static EH_RULE_SORTED_INDEX_ACK EH_insert_rule_table_(EH_RULE_ID id, const EH_Rule* rule);
 
static EH_RULE_SORTED_INDEX_ACK EH_delete_rule_table_(EH_RULE_ID id);
 
static EH_CHECK_RULE_ACK EH_check_rule_id_(EH_RULE_ID id);
 
static void EH_exec_func_by_event_group_(EL_GROUP group,
                                         EH_CHECK_RULE_ACK (*func)(EH_RULE_ID));
 
 
static EventHandler event_handler_;
const EventHandler* const event_handler = &event_handler_;
 
 
void EH_initialize(void)
{
  memset(&event_handler_, 0x00, sizeof(EventHandler));
 
  EH_clear_rules_();
  EH_clear_log_();
 
  EH_match_event_counter_to_el();
  event_handler_.exec_settings.max_response_num = EH_MAX_RESPONSE_NUM_DEFAULT;
  event_handler_.exec_settings.max_check_event_num = EH_MAX_CHECK_EVENT_NUM_DEFAULT;
  event_handler_.exec_settings.max_multi_level_num = EH_MAX_MULTI_LEVEL_NUM_DEFAULT;
  event_handler_.exec_info.current_multi_level = 0;
 
  EH_load_default_rules();
}
 
 
static void EH_clear_rules_(void)
{
  int i;
  memset(&event_handler_.rule_table, 0x00, sizeof(EH_RuleTable));
  // 現時点で EL_CORE_GROUP_NULL == 0 であるため，以下は不要．
  // for (i = 0; i < (int)EH_RULE_MAX; ++i)
  // {
  //   event_handler_.rule_table.rules[i].settings.event.group = (EL_GROUP)EL_CORE_GROUP_NULL;
  // }
 
  // EH_RuleSortedIndex もクリア
  memset(event_handler_.sorted_idxes, 0x00, sizeof(EH_RuleSortedIndex) * EH_RULE_MAX);
  for (i = 0; i < (int)EH_RULE_MAX; ++i)
  {
    // 現時点で EL_CORE_GROUP_NULL == 0 であるため，以下は不要．
    // event_handler_.sorted_idxes[i].group = (EL_GROUP)EL_CORE_GROUP_NULL;
    event_handler_.sorted_idxes[i].rule_id = EH_RULE_MAX;
  }
}
 
 
static void EH_clear_log_(void)
{
  int i;
  memset(&event_handler_.log_table, 0x00, sizeof(EH_LogTable));
 
  for (i = 0; i < EH_LOG_MAX; ++i)
  {
    event_handler_.log_table.logs[i].rule_id = EH_RULE_MAX;
  }
}
 
 
void EH_execute(void)
{
  uint8_t responded_count = 0;
  EH_ACK ack;
  uint16_t i;
 
  ack = EH_check_el_event_counter_();
  if (ack != EH_ACK_OK) return;
 
  for (i = 0; i < event_handler_.exec_settings.max_check_event_num; ++i)
  {
    const EL_Event* event = EH_get_event_to_check_rule_();
    if (event == NULL)
    {
      // もうチェックすべきイベントはなし
      break;
    }
 
    event_handler_.exec_info.current_multi_level = 0;
    responded_count += EH_check_event_and_respond_(event);
    if (responded_count >= event_handler_.exec_settings.max_response_num) break;
  }
}
 
 
static EH_ACK EH_check_el_event_counter_(void)
{
  int32_t delta_counter = event_logger->statistics.record_counter_total - event_handler_.el_event_counter.counter_total;
  int32_t delta_counters[EL_ERROR_LEVEL_MAX];
  uint8_t err_level;
  int32_t subtotal = 0;
 
  // カウンタ不整合を調べる．
  // エラー等は定期的にリセットされているはずなので，オーバーフローは考慮していない
  if (delta_counter < 0)
  {
    // 不整合
    EL_record_event((EL_GROUP)EL_CORE_GROUP_EVENT_HANDLER,
                    EH_EL_LOCAL_ID_EL_TOTAL_COUNTER_ERR,
                    EL_ERROR_LEVEL_HIGH,
                    (uint32_t)(-delta_counter));
    // 仕方がないので強制的に合わせる
    EH_match_event_counter_to_el();
    return EH_ACK_ERR;
  }
 
  for (err_level = 0; err_level < EL_ERROR_LEVEL_MAX; ++err_level)
  {
    delta_counters[err_level] = event_logger->statistics.record_counters[err_level] - event_handler_.el_event_counter.counters[err_level];
    if (delta_counters[err_level] < 0)
    {
      // 不整合
      EL_record_event((EL_GROUP)EL_CORE_GROUP_EVENT_HANDLER,
                      EH_EL_LOCAL_ID_EL_COUNTER_ERR,
                      EL_ERROR_LEVEL_HIGH,
                      (uint32_t)(err_level));
      // 仕方がないので強制的に合わせる
      EH_match_event_counter_to_el();
      return EH_ACK_ERR;
    }
 
    subtotal += delta_counters[err_level];
  }
 
  if (delta_counter != (int32_t)subtotal)
  {
    // 不整合
    EL_record_event((EL_GROUP)EL_CORE_GROUP_EVENT_HANDLER,
                    EH_EL_LOCAL_ID_EL_COUNTER_ERR,
                    EL_ERROR_LEVEL_HIGH,
                    EL_ERROR_LEVEL_MAX);    // ここの note は少し考える？
    // 仕方がないので強制的に合わせる
    EH_match_event_counter_to_el();
    return EH_ACK_ERR;
  }
 
  return EH_ACK_OK;
}
 
 
static const EL_Event* EH_get_event_to_check_rule_(void)
{
  const EL_Event* event = EH_get_oldest_event_excluding_eh_error_level_();
  if (event == NULL) return NULL;
 
  // 処理する EL_Event が見つかったので，カウントアップ
  event_handler_.el_event_counter.counter_total++;
  event_handler_.el_event_counter.counters[event->err_level]++;
 
  return event;
}
 
static uint8_t EH_check_event_and_respond_(const EL_Event* event)
{
  EH_RULE_SORTED_INDEX_ACK search_ack;
  EH_RULE_ID found_ids[EH_MAX_RULE_NUM_OF_EL_ID_DUPLICATES];
  uint16_t found_sorted_idxes[EH_MAX_RULE_NUM_OF_EL_ID_DUPLICATES];
  uint8_t found_id_num;
  uint8_t i;
  uint8_t responded_num = 0;
 
  search_ack = EH_search_rule_table_index_(event->group,
                                           event->local,
                                           found_ids,
                                           found_sorted_idxes,
                                           &found_id_num);
 
  if (search_ack == EH_RULE_SORTED_INDEX_ACK_NOT_FOUND)
  {
    // 対応する EH_Rule なし
    return 0;
  }
  if (search_ack != EH_RULE_SORTED_INDEX_ACK_OK)
  {
    EL_record_event((EL_GROUP)EL_CORE_GROUP_EVENT_HANDLER,
                    EH_EL_LOCAL_ID_SEARCH_ERR,
                    EL_ERROR_LEVEL_HIGH,
                    (uint32_t)search_ack);
    return 0;
  }
 
  // ルールチェック & 対応
  for (i = 0; i < found_id_num; ++i)
  {
    responded_num += EH_check_rule_and_respond_(found_ids[i], event);
  }
 
  return responded_num;
}
 
 
static uint8_t EH_check_rule_and_respond_(EH_RULE_ID rule_id, const EL_Event* event)
{
  EH_RuleSettings* rule_settings = &event_handler_.rule_table.rules[rule_id].settings;
  uint8_t responded_num = 0;
 
  if (rule_settings->event.group != event->group || rule_settings->event.local != event->local)
  {
    // 何かがおかしい（ありえないが，安全のため入れている．問題なさそうなら消してよし）
    EL_record_event((EL_GROUP)EL_CORE_GROUP_EVENT_HANDLER,
                    EH_EL_LOCAL_ID_UNKNOWN_ERR,
                    EL_ERROR_LEVEL_HIGH,
                    (uint32_t)rule_id);
    return 0;
  }
 
  if (EH_check_rule_(rule_id, event) != EH_CKECK_RULE_ACK_MATCH)
  {
    return 0;
  }
 
  // ここまで来たら引数に取った EH_RULE_ID は EH_Rule にマッチした
  EL_record_event((EL_GROUP)EL_CORE_GROUP_EH_MATCH_RULE,
                  (uint32_t)rule_id,
                  EL_ERROR_LEVEL_EH,
                  (uint32_t)event->err_level);
 
  // 上位の EH_Rule にマッチしないか問い合わせ
  responded_num = EH_check_higher_level_rule_and_respond_(rule_id);
 
  if (responded_num > 0)
  {
    // 上位で対応された
    EL_record_event((EL_GROUP)EL_CORE_GROUP_EH_RESPOND_WITH_HIGHER_LEVEL_RULE,
                    (uint32_t)rule_id,
                    EL_ERROR_LEVEL_EH,
                    (uint32_t)responded_num);
    return responded_num;
  }
 
  // このルールで対応する
  EH_respond_(rule_id);
  return 1;
}
 
 
static uint8_t EH_check_higher_level_rule_and_respond_(EH_RULE_ID rule_id)
{
  const EL_Event* higher_level_trigger_event = EL_get_the_nth_tlog_from_the_latest(EL_ERROR_LEVEL_EH, 0);
  int32_t delta_counter = event_logger->statistics.record_counters[EL_ERROR_LEVEL_EH] -
                          event_handler_.el_event_counter.counters[EL_ERROR_LEVEL_EH];
 
  event_handler_.exec_info.current_multi_level++;
 
  if (event_handler_.exec_info.current_multi_level >= event_handler_.exec_settings.max_multi_level_num)
  {
    // これ以上の再帰回数は認められない
    EL_record_event((EL_GROUP)EL_CORE_GROUP_EVENT_HANDLER,
                    EH_EL_LOCAL_ID_RECURSION_ERR,
                    EL_ERROR_LEVEL_HIGH,
                    0);
    return 0;
  }
 
  if (delta_counter < 1)
  {
    // 何かがおかしい（ありえないが，安全のため入れている．問題なさそうなら消してよし）
    EL_record_event((EL_GROUP)EL_CORE_GROUP_EVENT_HANDLER,
                    EH_EL_LOCAL_ID_UNKNOWN_ERR,
                    EL_ERROR_LEVEL_HIGH,
                    0);
    return 0;
  }
  if (higher_level_trigger_event->group != (EL_GROUP)EL_CORE_GROUP_EH_MATCH_RULE || higher_level_trigger_event->local != rule_id)
  {
    // 何かがおかしい（ありえないが，安全のため入れている．問題なさそうなら消してよし）
    EL_record_event((EL_GROUP)EL_CORE_GROUP_EVENT_HANDLER,
                    EH_EL_LOCAL_ID_UNKNOWN_ERR,
                    EL_ERROR_LEVEL_HIGH,
                    0);
    return 0;
  }
 
  // EL_Event を処理したのでカウントアップ
  event_handler_.el_event_counter.counter_total += delta_counter;
  event_handler_.el_event_counter.counters[EL_ERROR_LEVEL_EH] += delta_counter;
 
  // 上位の EH_Rule があるか検索して対応（再帰）
  return EH_check_event_and_respond_(higher_level_trigger_event);
}
 
 
static EH_CKECK_RULE_ACK EH_check_rule_(EH_RULE_ID rule_id, const EL_Event* event)
{
  EH_RuleSettings* rule_settings = &event_handler_.rule_table.rules[rule_id].settings;
 
  if (!(rule_settings->is_active))
  {
    return EH_CKECK_RULE_ACK_NOT_MATCH;
  }
  if (rule_settings->should_match_err_level)
  {
    if (rule_settings->event.err_level != event->err_level)
    {
      return EH_CKECK_RULE_ACK_NOT_MATCH;
    }
  }
 
  switch (rule_settings->condition.type)
  {
  case EH_RESPONSE_CONDITION_SINGLE:
    return EH_check_single_rule_(rule_id, event);
  case EH_RESPONSE_CONDITION_CONTINUOUS:
    return EH_check_continuous_rule_(rule_id, event);
  case EH_RESPONSE_CONDITION_CUMULATIVE:
    return EH_check_cumulative_rule_(rule_id, event);
  default:
    // 何かがおかしい（ありえないが，安全のため入れている．問題なさそうなら消してよし）
    EL_record_event((EL_GROUP)EL_CORE_GROUP_EVENT_HANDLER,
                    EH_EL_LOCAL_ID_UNKNOWN_ERR,
                    EL_ERROR_LEVEL_HIGH,
                    (uint32_t)rule_id);
    return EH_CKECK_RULE_ACK_NOT_MATCH;
  }
}
 
 
static EH_CKECK_RULE_ACK EH_check_single_rule_(EH_RULE_ID rule_id, const EL_Event* event)
{
  EH_Rule* rule = &event_handler_.rule_table.rules[rule_id];
  rule->last_event_time = event->time;
  return EH_CKECK_RULE_ACK_MATCH;
}
 
 
static EH_CKECK_RULE_ACK EH_check_continuous_rule_(EH_RULE_ID rule_id, const EL_Event* event)
{
  EH_Rule* rule = &event_handler_.rule_table.rules[rule_id];
  uint32_t delta_time_ms = OBCT_diff_in_msec(&rule->last_event_time, &event->time);
  rule->last_event_time = event->time;
 
  if (delta_time_ms > rule->settings.condition.time_threshold_ms)
  {
    // 連続ではなくなった
    EH_clear_rule_counter(rule_id);
  }
 
  rule->counter++;
 
  if (rule->counter < rule->settings.condition.count_threshold)
  {
    return EH_CKECK_RULE_ACK_NOT_MATCH;
  }
 
  EH_clear_rule_counter(rule_id);
  return EH_CKECK_RULE_ACK_MATCH;
}
 
 
static EH_CKECK_RULE_ACK EH_check_cumulative_rule_(EH_RULE_ID rule_id, const EL_Event* event)
{
  EH_Rule* rule = &event_handler_.rule_table.rules[rule_id];
  rule->last_event_time = event->time;
  rule->counter++;
 
  if (rule->counter < rule->settings.condition.count_threshold)
  {
    return EH_CKECK_RULE_ACK_NOT_MATCH;
  }
 
  EH_clear_rule_counter(rule_id);
  return EH_CKECK_RULE_ACK_MATCH;
}
 
 
static void EH_respond_(EH_RULE_ID rule_id)
{
  EH_Rule* rule = &event_handler_.rule_table.rules[rule_id];
  CCP_CmdRet cmd_ret;
 
  cmd_ret = CCP_form_and_exec_block_deploy_cmd(TLCD_ID_DEPLOY_BC, rule->settings.deploy_bct_id);
  if (cmd_ret.exec_sts != CCP_EXEC_SUCCESS)
  {
    uint32_t note = ((0x0000ffff & cmd_ret.exec_sts) << 16) | (0x0000ffff & cmd_ret.err_code);
    if ((PL_ACK)cmd_ret.err_code == PL_BC_TIME_ADJUSTED)
    {
      EL_record_event((EL_GROUP)EL_CORE_GROUP_EVENT_HANDLER,
                      EH_EL_LOCAL_ID_FAIL_TO_RESPOND,
                      EL_ERROR_LEVEL_LOW,
                      note);
    }
    else
    {
      EL_record_event((EL_GROUP)EL_CORE_GROUP_EVENT_HANDLER,
                      EH_EL_LOCAL_ID_FAIL_TO_RESPOND,
                      EL_ERROR_LEVEL_HIGH,
                      note);
    }
  }
 
  EH_inactivate_rule_for_multi_level(rule_id);
 
  EH_record_responded_log_(rule_id, cmd_ret.exec_sts);
}
 
 
// FIXME: CCP_EXEC_STS -> CCP_CmdRet にしてもいいかも？
static void EH_record_responded_log_(EH_RULE_ID rule_id, CCP_EXEC_STS deploy_cmd_ack)
{
  EH_LogTable* log_table = &event_handler_.log_table;
 
  log_table->respond_counter++;
 
  log_table->logs[log_table->log_wp].rule_id = rule_id;
  log_table->logs[log_table->log_wp].respond_time_in_master_cycle = TMGR_get_master_total_cycle();
  log_table->logs[log_table->log_wp].deploy_cmd_ack = deploy_cmd_ack;
 
  log_table->log_wp++;
  if (log_table->log_wp >= EH_LOG_MAX)
  {
    log_table->log_wp = 0;
    EL_record_event((EL_GROUP)EL_CORE_GROUP_EVENT_HANDLER,
                    EH_EL_LOCAL_ID_LOG_TABLE_FULL,
                    EL_ERROR_LEVEL_HIGH,
                    0);
  }
}
 
 
static const EL_Event* EH_get_oldest_event_excluding_eh_error_level_(void)
{
  uint8_t err_level;      // for で回すので u8 で
  ObcTime oldest_time = OBCT_get_max();
  const EL_Event* oldest_event = NULL;
 
  for (err_level = 0; err_level < EL_ERROR_LEVEL_MAX; ++err_level)
  {
    // EH 実行中にも EL のイベント登録は発生するため，ここで最新の情報を元に処理する
    int32_t delta_counter = event_logger->statistics.record_counters[err_level] - event_handler_.el_event_counter.counters[err_level];
    const uint16_t tlog_capacity = event_logger->tlogs[err_level].log_capacity;
    const EL_Event* event;
 
    if (err_level == EL_ERROR_LEVEL_EH) continue;
    if (delta_counter <= 0) continue;
 
    // キャパを溢れていたら，諦めて情報を修正する
    if (delta_counter > tlog_capacity)
    {
      const uint16_t keep_tlogs_num = (uint16_t)(tlog_capacity / 2);
      uint32_t drop_tlog_num;
 
      // イベントが発生しすぎて，TLogが失われている
      EL_record_event((EL_GROUP)EL_CORE_GROUP_EVENT_HANDLER,
                      EH_EL_LOCAL_ID_TOO_MANY_EVENT,
                      EL_ERROR_LEVEL_HIGH,
                      (uint32_t)(err_level));
 
      // 溢れかえっているということなので，またすぐ溢れることを考慮し
      // tlog_capacity の半分ぐらいまでのこし，後は諦める
      drop_tlog_num = (uint32_t)(delta_counter - keep_tlogs_num);
 
      event_handler_.el_event_counter.counter_total += drop_tlog_num;
      event_handler_.el_event_counter.counters[err_level] += drop_tlog_num;
 
      // カウンタを変えたので，更新
      delta_counter = event_logger->statistics.record_counters[err_level] - event_handler_.el_event_counter.counters[err_level];
    }
 
    event = EL_get_the_nth_tlog_from_the_latest((EL_ERROR_LEVEL)err_level, (uint16_t)(delta_counter - 1));
    if (OBCT_compare(&event->time, &oldest_time) == 1)
    {
      oldest_event = event;
      oldest_time = event->time;
    }
  }
 
  return oldest_event;
}
 
 
static EH_RULE_SORTED_INDEX_ACK EH_search_rule_table_index_(EL_GROUP group,
                                                            uint32_t local,
                                                            EH_RULE_ID found_ids[EH_MAX_RULE_NUM_OF_EL_ID_DUPLICATES],
                                                            uint16_t found_sorted_idxes[EH_MAX_RULE_NUM_OF_EL_ID_DUPLICATES],
                                                            uint8_t* found_id_num)
{
  // idx: 0 ~ rule_table.registered_rule_num の間で二分探索する
  // 重複もあり得ることを考慮する (duplicate_id は異なる)
 
  uint16_t found_idx = EH_RULE_MAX;
  const EH_RuleSortedIndex* p_searched_sorted_idx = NULL;
  EH_RuleSortedIndex target_sorted_idx;
  uint16_t i;
  uint16_t possible_num_of_id_duplicates;
 
  if (event_handler_.rule_table.registered_rule_num == 0)
  {
    return EH_RULE_SORTED_INDEX_ACK_NOT_FOUND;
  }
 
  memset(&target_sorted_idx, 0x00, sizeof(EH_RuleSortedIndex));
  target_sorted_idx.group = group;
  target_sorted_idx.local = local;
  p_searched_sorted_idx = (EH_RuleSortedIndex*)bsearch(&target_sorted_idx,
                                                       event_handler_.sorted_idxes,
                                                       event_handler_.rule_table.registered_rule_num,
                                                       sizeof(EH_RuleSortedIndex),
                                                       EH_compare_sorted_index_for_bsearch_);
  if (p_searched_sorted_idx == NULL) return EH_RULE_SORTED_INDEX_ACK_NOT_FOUND;
  found_idx = (uint16_t)(p_searched_sorted_idx - (&event_handler_.sorted_idxes[0]));
 
  // 見つかった．後は，いくつあるか？
  *found_id_num = 0;
  possible_num_of_id_duplicates = EH_MAX_RULE_NUM_OF_EL_ID_DUPLICATES;
  if (possible_num_of_id_duplicates > event_handler_.rule_table.registered_rule_num - found_idx)
  {
    possible_num_of_id_duplicates = event_handler_.rule_table.registered_rule_num - found_idx;
  }
  for (i = 0; i < possible_num_of_id_duplicates; ++i)
  {
    EH_RuleSortedIndex* p_idx = &event_handler_.sorted_idxes[found_idx + i];
    if ( !(p_idx->group == group && p_idx->local == local) )
    {
      break;
    }
    found_sorted_idxes[i] = (uint16_t)(found_idx + i);
    found_ids[i] = p_idx->rule_id;
    (*found_id_num)++;
  }
 
  return EH_RULE_SORTED_INDEX_ACK_OK;
}
 
 
static int EH_compare_sorted_index_for_bsearch_(const void* key, const void* elem)
{
  const EH_RuleSortedIndex* p_key  = (const EH_RuleSortedIndex*)key;
  const EH_RuleSortedIndex* p_elem = (const EH_RuleSortedIndex*)elem;
 
  if (p_elem->group == p_key->group)
  {
    if (p_elem->local == p_key->local)
    {
      if (p_elem->duplicate_id == 0)
      {
        // 探してたもの
        return 0;
      }
      else
      {
        // もっと手前にあるはず
        return -1;
      }
    }
    else if (p_elem->local < p_key->local)
    {
      return 1;
    }
    else
    {
      return -1;
    }
  }
  else if (p_elem->group < p_key->group)
  {
    return 1;
  }
  else
  {
    return -1;
  }
}
 
 
static EH_RULE_SORTED_INDEX_ACK EH_search_rule_table_index_by_event_group_(EL_GROUP group,
                                                                           uint16_t* least_found_sorted_idx,
                                                                           uint16_t* found_sorted_idx_num)
{
  // idx: 0 ~ rule_table.registered_rule_num の間で二分探索する
  // 重複もあり得ることを考慮する (duplicate_id は異なる)
 
  uint16_t found_idx = EH_RULE_MAX;
  uint16_t last_found_sorted_idx = 0;
  const EH_RuleSortedIndex* p_searched_sorted_idx = NULL;
  EH_RuleSortedIndex target_sorted_idx;
  uint16_t i;
 
  if (event_handler_.rule_table.registered_rule_num == 0)
  {
    return EH_RULE_SORTED_INDEX_ACK_NOT_FOUND;
  }
 
  memset(&target_sorted_idx, 0x00, sizeof(EH_RuleSortedIndex));
  target_sorted_idx.group = group;
  p_searched_sorted_idx = (EH_RuleSortedIndex*)bsearch(&target_sorted_idx,
                                                       event_handler_.sorted_idxes,
                                                       event_handler_.rule_table.registered_rule_num,
                                                       sizeof(EH_RuleSortedIndex),
                                                       EH_compare_sorted_index_by_event_group_for_bsearch_);
  if (p_searched_sorted_idx == NULL) return EH_RULE_SORTED_INDEX_ACK_NOT_FOUND;
  found_idx = (uint16_t)(p_searched_sorted_idx - (&event_handler_.sorted_idxes[0]));
  *least_found_sorted_idx = found_idx;
 
  // ひとまず見つかったので，最も若いものを探す
  for (i = found_idx; i >= 0; --i)
  {
    if (event_handler_.sorted_idxes[i].group == group)
    {
      *least_found_sorted_idx = i;
    }
    else
    {
      break;
    }
  }
 
  // 最も後ろのものを探す
  for (i = found_idx; i < event_handler_.rule_table.registered_rule_num; ++i)
  {
    if (event_handler_.sorted_idxes[i].group == group)
    {
      last_found_sorted_idx = i;
    }
    else
    {
      break;
    }
  }
 
  *found_sorted_idx_num = (uint16_t)(last_found_sorted_idx - *least_found_sorted_idx + 1);
  return EH_RULE_SORTED_INDEX_ACK_OK;
}
 
 
static int EH_compare_sorted_index_by_event_group_for_bsearch_(const void* key, const void* elem)
{
  const EH_RuleSortedIndex* p_key  = (const EH_RuleSortedIndex*)key;
  const EH_RuleSortedIndex* p_elem = (const EH_RuleSortedIndex*)elem;
 
  if (p_elem->group == p_key->group)
  {
    return 0;       // 注意: 同じ group のものが複数あった時，どれを bsearch が返すかは未規定
  }
  else if (p_elem->group < p_key->group)
  {
    return 1;
  }
  else
  {
    return -1;
  }
}
 
 
static EH_RULE_SORTED_INDEX_ACK EH_insert_rule_table_(EH_RULE_ID id, const EH_Rule* rule)
{
  // insert は，めんどくさい & 頻繁には起きないので，二分探索せずにやっていく
  EH_RuleTable* p_rule_table = &event_handler_.rule_table;
  EH_RuleSortedIndex* p_sorted_idxes = event_handler_.sorted_idxes;
  const EL_GROUP insert_group = rule->settings.event.group;
  const uint32_t insert_local = rule->settings.event.local;
  uint16_t i;
  uint8_t j;
  uint16_t insert_idx;
  uint8_t duplicate_id;
 
  EH_CHECK_RULE_ACK check_ack = EH_check_rule_id_(id);
  if (check_ack == EH_CHECK_RULE_ACK_INVALID_RULE_ID) return EH_RULE_SORTED_INDEX_ACK_ILLEGAL_RULE_ID;
  if (check_ack == EH_CHECK_RULE_ACK_OK) return EH_RULE_SORTED_INDEX_ACK_RULE_OVERWRITE;
 
  if (p_rule_table->registered_rule_num >= EH_RULE_MAX)
  {
    return EH_RULE_SORTED_INDEX_ACK_FULL;
  }
 
  insert_idx = p_rule_table->registered_rule_num;
  duplicate_id = 0;
  for (i = 0; i < p_rule_table->registered_rule_num; ++i)
  {
    EH_RuleSortedIndex* p_sorted_idx = &p_sorted_idxes[i];
    uint8_t break_flag = 0;
 
    if (p_sorted_idx->group < insert_group) continue;
 
    if (p_sorted_idx->group > insert_group)
    {
      // 挿入する場所はここ
      insert_idx = i;
      break;
    }
 
    // ここまできたら p_sorted_idx->group == insert_group
    if (p_sorted_idx->local < insert_local) continue;
 
    if (p_sorted_idx->local > insert_local)
    {
      // 挿入する場所はここ
      insert_idx = i;
      break;
    }
 
    // ここまできたら
    // - p_sorted_idx->group == insert_group
    // - p_sorted_idx->local == insert_local
 
    // 重複してる or する
    for (j = 1; j < EH_MAX_RULE_NUM_OF_EL_ID_DUPLICATES; ++j)
    {
      uint16_t idx = (uint16_t)(i + j);
      EH_RuleSortedIndex* p_sorted_idx = &p_sorted_idxes[idx];
 
      if (idx >= p_rule_table->registered_rule_num)
      {
        // 末端まできたので，ここが挿入する場所
        insert_idx = idx;
        duplicate_id = j;
        break_flag = 1;
        break;
      }
 
      if (p_sorted_idx->group == insert_group && p_sorted_idx->local == insert_local)
      {
        // まだ重複している
        continue;
      }
 
      // 重複しなくなったので，ここが挿入する場所
      insert_idx = idx;
      duplicate_id = j;
      break_flag = 1;
      break;
    }
    if (break_flag) break;
 
    // 重複上限まで重複してしまっている
    return EH_RULE_SORTED_INDEX_ACK_DUPLICATE_FULL;
  }
 
  // ここまで来たら，挿入できる
  // insert_idx, duplicate_id が出揃っているはず
  memmove(&p_sorted_idxes[insert_idx + 1],
          &p_sorted_idxes[insert_idx],
          sizeof(EH_RuleSortedIndex) * (EH_RULE_MAX - insert_idx - 1));
  p_sorted_idxes[insert_idx].group        = insert_group;
  p_sorted_idxes[insert_idx].local        = insert_local;
  p_sorted_idxes[insert_idx].duplicate_id = duplicate_id;
  p_sorted_idxes[insert_idx].rule_id      = id;
 
  p_rule_table->rules[id] = *rule;
  p_rule_table->registered_rule_num++;
 
  return EH_RULE_SORTED_INDEX_ACK_OK;
}
 
 
static EH_RULE_SORTED_INDEX_ACK EH_delete_rule_table_(EH_RULE_ID id)
{
  // delete は，めんどくさい & 頻繁には起きないので，二分探索せずにやっていく
  EH_RuleTable* p_rule_table = &event_handler_.rule_table;
  EH_RuleSortedIndex* p_sorted_idxes = event_handler_.sorted_idxes;
  EL_GROUP delete_group;
  uint32_t delete_local;
  uint16_t i;
  uint8_t j;
  uint16_t delete_idx;
 
  EH_CHECK_RULE_ACK check_ack = EH_check_rule_id_(id);
  if (check_ack == EH_CHECK_RULE_ACK_INVALID_RULE_ID) return EH_RULE_SORTED_INDEX_ACK_ILLEGAL_RULE_ID;
  if (check_ack == EH_CHECK_RULE_ACK_UNREGISTERED) return EH_RULE_SORTED_INDEX_ACK_NOT_FOUND;
 
  // この２個，const にしたい．．．
  delete_group = p_rule_table->rules[id].settings.event.group;
  delete_local = p_rule_table->rules[id].settings.event.local;
 
  delete_idx = EH_RULE_MAX;
  for (i = 0; i < p_rule_table->registered_rule_num; ++i)
  {
    if (id == p_sorted_idxes[i].rule_id)
    {
      // 見つかった
      delete_idx = i;
      break;
    }
  }
 
  if (delete_idx == EH_RULE_MAX)
  {
    // 本当はこれはありえないはず
    // （ありえないが，安全のため入れている．問題なさそうなら消してよし）
    EL_record_event((EL_GROUP)EL_CORE_GROUP_EVENT_HANDLER,
                    EH_EL_LOCAL_ID_UNKNOWN_ERR,
                    EL_ERROR_LEVEL_HIGH,
                    0xffffffff);
    return EH_RULE_SORTED_INDEX_ACK_NOT_FOUND;
  }
 
  // ここまで来たら削除できる
  memmove(&p_sorted_idxes[delete_idx],
          &p_sorted_idxes[delete_idx + 1],
          sizeof(EH_RuleSortedIndex) * (EH_RULE_MAX - delete_idx - 1));
  memset(&p_sorted_idxes[EH_RULE_MAX - 1], 0x00, sizeof(EH_RuleSortedIndex));
  p_sorted_idxes[EH_RULE_MAX - 1].group = (EL_GROUP)EL_CORE_GROUP_NULL;
  p_sorted_idxes[EH_RULE_MAX - 1].rule_id = EH_RULE_MAX;
 
  // 重複IDの処理
  for (j = 0; j < (EH_MAX_RULE_NUM_OF_EL_ID_DUPLICATES - 1); ++j)
  {
    uint16_t idx = (uint16_t)(delete_idx + j);
    EH_RuleSortedIndex* p_sorted_idx = &p_sorted_idxes[idx];
 
    if (p_sorted_idx->group == delete_group && p_sorted_idx->local == delete_local)
    {
      p_sorted_idx->duplicate_id--;
    }
    else
    {
      break;
    }
  }
 
  memset(&p_rule_table->rules[id], 0x00, sizeof(EH_Rule));
  p_rule_table->rules[id].settings.event.group = (EL_GROUP)EL_CORE_GROUP_NULL;
  p_rule_table->registered_rule_num--;
 
  return EH_RULE_SORTED_INDEX_ACK_OK;
}
 
 
EH_REGISTER_ACK EH_register_rule(EH_RULE_ID id, const EH_RuleSettings* settings)
{
  EH_RULE_SORTED_INDEX_ACK ack;
  EH_Rule rule;
 
  if (settings->event.group >= EL_GROUP_MAX)                 return EH_REGISTER_ACK_ILLEGAL_GROUP;
  if (settings->event.group <= (EL_GROUP)EL_CORE_GROUP_NULL) return EH_REGISTER_ACK_ILLEGAL_GROUP;
  if (settings->event.err_level < 0)                         return EH_REGISTER_ACK_ILLEGAL_ERROR_LEVEL;
  if (settings->event.err_level >= EL_ERROR_LEVEL_MAX)       return EH_REGISTER_ACK_ILLEGAL_ERROR_LEVEL;
  if (settings->should_match_err_level != 0 && settings->should_match_err_level != 1)
  {
    return EH_REGISTER_ACK_ILLEGAL_MATCH_FLAG;
  }
  if (settings->condition.type >= EH_RESPONSE_CONDITION_TYPE_MAX) return EH_REGISTER_ACK_ILLEGAL_CONDITION_TYPE;
  if (settings->condition.type != EH_RESPONSE_CONDITION_SINGLE)
  {
    if (settings->condition.count_threshold == 0) return EH_REGISTER_ACK_ILLEGAL_COUNT_THRESHOLD;
  }
  if (settings->deploy_bct_id >= BCT_MAX_BLOCKS) return EH_REGISTER_ACK_ILLEGAL_BCT_ID;
  if (settings->is_active != 0 && settings->is_active != 1)
  {
    return EH_REGISTER_ACK_ILLEGAL_ACTIVE_FLAG;
  }
  if (settings->event.err_level == EL_ERROR_LEVEL_EH)
  {
    // 多段対応以外で EL_ERROR_LEVEL_EH の設定は不可
    if (settings->event.group != (EL_GROUP)EL_CORE_GROUP_EH_MATCH_RULE) return EH_REGISTER_ACK_ILLEGAL_MULTI_LEVEL;
  }
  if (settings->event.group == (EL_GROUP)EL_CORE_GROUP_EH_MATCH_RULE)
  {
    // 多段の時は EL_ERROR_LEVEL_EH が必須
    if (settings->event.err_level != EL_ERROR_LEVEL_EH) return EH_REGISTER_ACK_ILLEGAL_MULTI_LEVEL;
    if (settings->should_match_err_level != 1) return EH_REGISTER_ACK_ILLEGAL_MULTI_LEVEL;
  }
  if (settings->event.group == (EL_GROUP)EL_CORE_GROUP_EH_MATCH_RULE)
  {
    // 多段設定の最大値を超えてないかチェック
    uint8_t multi_level_num;
    EH_RULE_ID lower_level_rule = (EH_RULE_ID)(settings->event.local);
 
    // 1段以下なら，そもそも多段が組めない
    if (event_handler_.exec_settings.max_multi_level_num <= 1) return EH_REGISTER_ACK_ILLEGAL_MULTI_LEVEL;
 
    // 無限ループ回避のために EH_RULE_MAX で抑える
    for (multi_level_num = 0; multi_level_num < EH_RULE_MAX; ++multi_level_num)
    {
      EH_RuleSettings* rule_settings;
      EH_CHECK_RULE_ACK ack;
 
      ack = EH_check_rule_id_(lower_level_rule);
      if (ack == EH_CHECK_RULE_ACK_INVALID_RULE_ID) return EH_REGISTER_ACK_ILLEGAL_MULTI_LEVEL;
      if (ack == EH_CHECK_RULE_ACK_UNREGISTERED) break;
 
      rule_settings = &event_handler_.rule_table.rules[lower_level_rule].settings;
 
      if (rule_settings->event.group != (EL_GROUP)EL_CORE_GROUP_EH_MATCH_RULE) break;
 
      // 更に多段になっている
      lower_level_rule = (EH_RULE_ID)rule_settings->event.local;
 
      if (multi_level_num >= (event_handler_.exec_settings.max_multi_level_num - 2)) return EH_REGISTER_ACK_ILLEGAL_MULTI_LEVEL;
    }
  }
 
  rule.settings = *settings;
  rule.counter = 0;
  OBCT_clear(&rule.last_event_time);
 
  ack = EH_insert_rule_table_(id, &rule);
 
  switch (ack)
  {
  case EH_RULE_SORTED_INDEX_ACK_OK:
    return EH_REGISTER_ACK_OK;
  case EH_RULE_SORTED_INDEX_ACK_ILLEGAL_RULE_ID:
    return EH_REGISTER_ACK_ILLEGAL_RULE_ID;
  case EH_RULE_SORTED_INDEX_ACK_FULL:
    return EH_REGISTER_ACK_ERR_FULL;
  case EH_RULE_SORTED_INDEX_ACK_RULE_OVERWRITE:
    return EH_REGISTER_ACK_ERR_RULE_OVERWRITE;
  case EH_RULE_SORTED_INDEX_ACK_DUPLICATE_FULL:
    return EH_REGISTER_ACK_ERR_DUPLICATE_FULL;
  default:
    return EH_REGISTER_ACK_UNKNOWN_ERR;
  }
}
 
 
static EH_CHECK_RULE_ACK EH_check_rule_id_(EH_RULE_ID id)
{
  if (id < 0) return EH_CHECK_RULE_ACK_INVALID_RULE_ID;
  if (id >= EH_RULE_MAX) return EH_CHECK_RULE_ACK_INVALID_RULE_ID;
  if (event_handler_.rule_table.rules[id].settings.event.group == (EL_GROUP)EL_CORE_GROUP_NULL)
  {
    return EH_CHECK_RULE_ACK_UNREGISTERED;
  }
  return EH_CHECK_RULE_ACK_OK;
}
 
 
static void EH_exec_func_by_event_group_(EL_GROUP group,
                                         EH_CHECK_RULE_ACK (*func)(EH_RULE_ID))
{
  uint16_t least_found_sorted_idx = 0;
  uint16_t found_sorted_idx_num = 0;
  EH_RULE_SORTED_INDEX_ACK search_ack;
  uint16_t i;
 
  search_ack = EH_search_rule_table_index_by_event_group_(group,
                                                          &least_found_sorted_idx,
                                                          &found_sorted_idx_num);
  if (search_ack == EH_RULE_SORTED_INDEX_ACK_NOT_FOUND)
  {
    // 操作すべき EH_Rule はなし
    return;
  }
  if (search_ack != EH_RULE_SORTED_INDEX_ACK_OK || found_sorted_idx_num == 0)
  {
    // 何かがおかしい（ありえないが，安全のため入れている．問題なさそうなら消してよし）
    EL_record_event((EL_GROUP)EL_CORE_GROUP_EVENT_HANDLER,
                    EH_EL_LOCAL_ID_UNKNOWN_ERR,
                    EL_ERROR_LEVEL_HIGH,
                    (uint32_t)group);
    return;
  }
 
  for (i = 0; i < found_sorted_idx_num; ++i)
  {
    func(event_handler_.sorted_idxes[least_found_sorted_idx + i].rule_id);
  }
}
 
 
EH_CHECK_RULE_ACK EH_init_rule(EH_RULE_ID id)
{
  EH_CHECK_RULE_ACK ack = EH_check_rule_id_(id);
  if (ack != EH_CHECK_RULE_ACK_OK) return ack;
 
  EH_activate_rule(id);
  EH_clear_rule_counter(id);
  return EH_CHECK_RULE_ACK_OK;
}
 
 
EH_CHECK_RULE_ACK EH_init_rule_for_multi_level(EH_RULE_ID id)
{
  int i;
  EH_RULE_ID next_rule_id = id;
  EH_CHECK_RULE_ACK ack = EH_check_rule_id_(id);
  if (ack != EH_CHECK_RULE_ACK_OK) return ack;
 
  // 無限ループ回避のため for で
  for (i = 0; i < (int)EH_RULE_MAX; ++i)
  {
    if (EH_activate_rule(next_rule_id) != EH_CHECK_RULE_ACK_OK) break;
    EH_clear_rule_counter(next_rule_id);
    if (event_handler_.rule_table.rules[next_rule_id].settings.event.group != (EL_GROUP)EL_CORE_GROUP_EH_MATCH_RULE)
    {
      break;
    }
    next_rule_id = (EH_RULE_ID)event_handler_.rule_table.rules[next_rule_id].settings.event.local;
  }
 
  return EH_CHECK_RULE_ACK_OK;
}
 
 
void EH_init_rule_by_event_group(EL_GROUP group)
{
  EH_exec_func_by_event_group_(group, EH_init_rule);
}
 
 
void EH_init_rule_by_event_group_for_multi_level(EL_GROUP group)
{
  EH_exec_func_by_event_group_(group, EH_init_rule_for_multi_level);
}
 
 
EH_CHECK_RULE_ACK EH_activate_rule(EH_RULE_ID id)
{
  EH_CHECK_RULE_ACK ack = EH_check_rule_id_(id);
  if (ack != EH_CHECK_RULE_ACK_OK) return ack;
 
  event_handler_.rule_table.rules[id].settings.is_active = 1;
  return EH_CHECK_RULE_ACK_OK;
}
 
 
EH_CHECK_RULE_ACK EH_inactivate_rule(EH_RULE_ID id)
{
  EH_CHECK_RULE_ACK ack = EH_check_rule_id_(id);
  if (ack != EH_CHECK_RULE_ACK_OK) return ack;
 
  event_handler_.rule_table.rules[id].settings.is_active = 0;
  return EH_CHECK_RULE_ACK_OK;
}
 
 
EH_CHECK_RULE_ACK EH_activate_rule_for_multi_level(EH_RULE_ID id)
{
  int i;
  EH_RULE_ID next_rule_id = id;
  EH_CHECK_RULE_ACK ack = EH_check_rule_id_(id);
  if (ack != EH_CHECK_RULE_ACK_OK) return ack;
 
  // 無限ループ回避のため for
  for (i = 0; i < (int)EH_RULE_MAX; ++i)
  {
    if (EH_activate_rule(next_rule_id) != EH_CHECK_RULE_ACK_OK) break;
    if (event_handler_.rule_table.rules[next_rule_id].settings.event.group != (EL_GROUP)EL_CORE_GROUP_EH_MATCH_RULE)
    {
      break;
    }
    next_rule_id = (EH_RULE_ID)event_handler_.rule_table.rules[next_rule_id].settings.event.local;
  }
 
  return EH_CHECK_RULE_ACK_OK;
}
 
 
EH_CHECK_RULE_ACK EH_inactivate_rule_for_multi_level(EH_RULE_ID id)
{
  int i;
  EH_RULE_ID next_rule_id = id;
  EH_CHECK_RULE_ACK ack = EH_check_rule_id_(id);
  if (ack != EH_CHECK_RULE_ACK_OK) return ack;
 
  // 無限ループ回避のため for
  for (i = 0; i < (int)EH_RULE_MAX; ++i)
  {
    if (EH_inactivate_rule(next_rule_id) != EH_CHECK_RULE_ACK_OK) break;
    if (event_handler_.rule_table.rules[next_rule_id].settings.event.group != (EL_GROUP)EL_CORE_GROUP_EH_MATCH_RULE)
    {
      break;
    }
    next_rule_id = (EH_RULE_ID)event_handler_.rule_table.rules[next_rule_id].settings.event.local;
  }
 
  return EH_CHECK_RULE_ACK_OK;
}
 
 
void EH_activate_rule_by_event_group(EL_GROUP group)
{
  EH_exec_func_by_event_group_(group, EH_activate_rule);
}
 
 
void EH_inactivate_rule_by_event_group(EL_GROUP group)
{
  EH_exec_func_by_event_group_(group, EH_inactivate_rule);
}
 
 
void EH_activate_rule_by_event_group_for_multi_level(EL_GROUP group)
{
  EH_exec_func_by_event_group_(group, EH_activate_rule_for_multi_level);
}
 
 
void EH_inactivate_rule_by_event_group_for_multi_level(EL_GROUP group)
{
  EH_exec_func_by_event_group_(group, EH_inactivate_rule_for_multi_level);
}
 
 
uint8_t EH_get_rule_is_active(EH_RULE_ID id)
{
  EH_CHECK_RULE_ACK ack = EH_check_rule_id_(id);
  if (ack != EH_CHECK_RULE_ACK_OK) return 0;
 
  return event_handler_.rule_table.rules[id].settings.is_active;
}
 
EH_CHECK_RULE_ACK EH_set_rule_counter(EH_RULE_ID id, uint16_t counter)
{
  EH_CHECK_RULE_ACK ack = EH_check_rule_id_(id);
  if (ack != EH_CHECK_RULE_ACK_OK) return ack;
 
  event_handler_.rule_table.rules[id].counter = counter;
  return EH_CHECK_RULE_ACK_OK;
}
 
 
EH_CHECK_RULE_ACK EH_clear_rule_counter(EH_RULE_ID id)
{
  return EH_set_rule_counter(id, 0);
}
 
 
void EH_clear_rule_counter_by_event(EL_GROUP group, uint32_t local, EL_ERROR_LEVEL err_level)
{
  EH_RULE_SORTED_INDEX_ACK search_ack;
  EH_RULE_ID found_ids[EH_MAX_RULE_NUM_OF_EL_ID_DUPLICATES];
  uint16_t found_sorted_idxes[EH_MAX_RULE_NUM_OF_EL_ID_DUPLICATES];
  uint8_t found_id_num;
  uint8_t i;
 
  search_ack = EH_search_rule_table_index_(group,
                                           local,
                                           found_ids,
                                           found_sorted_idxes,
                                           &found_id_num);
 
  if (search_ack == EH_RULE_SORTED_INDEX_ACK_NOT_FOUND)
  {
    // 対応する EH_Rule なし
    return;
  }
  if (search_ack != EH_RULE_SORTED_INDEX_ACK_OK)
  {
    EL_record_event((EL_GROUP)EL_CORE_GROUP_EVENT_HANDLER,
                    EH_EL_LOCAL_ID_SEARCH_ERR,
                    EL_ERROR_LEVEL_HIGH,
                    (uint32_t)search_ack);
    return;
  }
 
  // 見つかったルールに対して処理
  for (i = 0; i < found_id_num; ++i)
  {
    EH_RULE_ID id = found_ids[i];
    EH_RuleSettings* rule_settings = &event_handler_.rule_table.rules[id].settings;
 
    if (rule_settings->should_match_err_level)
    {
      if (rule_settings->event.err_level != err_level) continue;
    }
    EH_clear_rule_counter(id);
  }
}
 
 
void EH_match_event_counter_to_el(void)
{
  uint8_t err_level;
  event_handler_.el_event_counter.counter_total = event_logger->statistics.record_counter_total;
  for (err_level = 0; err_level < EL_ERROR_LEVEL_MAX; ++err_level)
  {
    event_handler_.el_event_counter.counters[err_level] = event_logger->statistics.record_counters[err_level];
  }
}
 
 
const EH_Log* EH_get_the_nth_log_from_the_latest(uint16_t n)
{
  uint16_t idx;
 
  if (n >= EH_LOG_MAX)
  {
    // 仕方がないので，最新のものを
    idx = 0;
  }
  else
  {
    idx = (uint16_t)((event_handler->log_table.log_wp - 1 - n + EH_LOG_MAX) % EH_LOG_MAX);
  }
 
  return &event_handler->log_table.logs[idx];
}
 
 
CCP_CmdRet Cmd_EH_INIT(const CommonCmdPacket* packet)
{
  (void)packet;
  EH_initialize();
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_CLEAR_ALL_RULE(const CommonCmdPacket* packet)
{
  (void)packet;
  EH_clear_rules_();
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_LOAD_DEFAULT_RULE(const CommonCmdPacket* packet)
{
  (void)packet;
  EH_load_default_rules();
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_SET_REGISTER_RULE_EVENT_PARAM(const CommonCmdPacket* packet)
{
  // 登録する瞬間にしかわからないので，ここでは値のアサーションはせず，
  // Cmd_EH_REGISTER_RULE でアサーションする
  event_handler_.reg_from_cmd.rule_id = (EH_RULE_ID)CCP_get_param_from_packet(packet, 0, uint16_t);
  event_handler_.reg_from_cmd.settings.event.group = (EL_GROUP)CCP_get_param_from_packet(packet, 1, uint32_t);
  event_handler_.reg_from_cmd.settings.event.local = CCP_get_param_from_packet(packet, 2, uint32_t);
  event_handler_.reg_from_cmd.settings.event.err_level = (EL_ERROR_LEVEL)CCP_get_param_from_packet(packet, 3, uint8_t);
  event_handler_.reg_from_cmd.settings.should_match_err_level = CCP_get_param_from_packet(packet, 4, uint8_t);
  event_handler_.reg_from_cmd.settings.deploy_bct_id = CCP_get_param_from_packet(packet, 5, bct_id_t);
 
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_SET_REGISTER_RULE_CONDITION_PARAM(const CommonCmdPacket* packet)
{
  // 登録する瞬間にしかわからないので，ここでは値のアサーションはせず，
  // Cmd_EH_REGISTER_RULE でアサーションする
  event_handler_.reg_from_cmd.settings.condition.type = (EH_RESPONSE_CONDITION_TYPE)CCP_get_param_from_packet(packet, 0, uint8_t);
  event_handler_.reg_from_cmd.settings.condition.count_threshold = CCP_get_param_from_packet(packet, 1, uint16_t);
  event_handler_.reg_from_cmd.settings.condition.time_threshold_ms = CCP_get_param_from_packet(packet, 2, uint32_t);
  event_handler_.reg_from_cmd.settings.is_active = CCP_get_param_from_packet(packet, 3, uint8_t);
 
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_REGISTER_RULE(const CommonCmdPacket* packet)
{
  (void)packet;
  event_handler_.reg_from_cmd.register_ack =
      EH_register_rule(event_handler_.reg_from_cmd.rule_id, &event_handler_.reg_from_cmd.settings);
 
  switch (event_handler_.reg_from_cmd.register_ack)
  {
  case EH_REGISTER_ACK_OK:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
  case EH_REGISTER_ACK_ILLEGAL_RULE_ID:
  case EH_REGISTER_ACK_ILLEGAL_GROUP:
  case EH_REGISTER_ACK_ILLEGAL_ERROR_LEVEL:
  case EH_REGISTER_ACK_ILLEGAL_MATCH_FLAG:
  case EH_REGISTER_ACK_ILLEGAL_CONDITION_TYPE:
  case EH_REGISTER_ACK_ILLEGAL_COUNT_THRESHOLD:
  case EH_REGISTER_ACK_ILLEGAL_BCT_ID:
  case EH_REGISTER_ACK_ILLEGAL_ACTIVE_FLAG:
  case EH_REGISTER_ACK_ILLEGAL_MULTI_LEVEL:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_PARAMETER);    // 正確にはこのコマンドのパラメタではないが．．．
  case EH_REGISTER_ACK_ERR_FULL:
  case EH_REGISTER_ACK_ERR_RULE_OVERWRITE:
  case EH_REGISTER_ACK_ERR_DUPLICATE_FULL:
  case EH_REGISTER_ACK_UNKNOWN_ERR:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  default:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  }
}
 
 
CCP_CmdRet Cmd_EH_DELETE_RULE(const CommonCmdPacket* packet)
{
  EH_RULE_ID rule_id = (EH_RULE_ID)CCP_get_param_from_packet(packet, 0, uint16_t);
  EH_RULE_SORTED_INDEX_ACK ack = EH_delete_rule_table_(rule_id);
 
  switch (ack)
  {
  case EH_RULE_SORTED_INDEX_ACK_OK:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
  case EH_RULE_SORTED_INDEX_ACK_ILLEGAL_RULE_ID:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_PARAMETER);
  case EH_RULE_SORTED_INDEX_ACK_NOT_FOUND:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  default:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  }
}
 
 
CCP_CmdRet Cmd_EH_INIT_RULE(const CommonCmdPacket* packet)
{
  EH_RULE_ID rule_id = (EH_RULE_ID)CCP_get_param_from_packet(packet, 0, uint16_t);
  EH_CHECK_RULE_ACK ack = EH_init_rule(rule_id);
 
  switch (ack)
  {
  case EH_CHECK_RULE_ACK_OK:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
  case EH_CHECK_RULE_ACK_INVALID_RULE_ID:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_PARAMETER);
  case EH_CHECK_RULE_ACK_UNREGISTERED:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  default:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  }
}
 
 
CCP_CmdRet Cmd_EH_INIT_RULE_FOR_MULTI_LEVEL(const CommonCmdPacket* packet)
{
  EH_RULE_ID rule_id = (EH_RULE_ID)CCP_get_param_from_packet(packet, 0, uint16_t);
  EH_CHECK_RULE_ACK ack = EH_init_rule_for_multi_level(rule_id);
 
  switch (ack)
  {
  case EH_CHECK_RULE_ACK_OK:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
  case EH_CHECK_RULE_ACK_INVALID_RULE_ID:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_PARAMETER);
  case EH_CHECK_RULE_ACK_UNREGISTERED:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  default:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  }
}
 
 
CCP_CmdRet Cmd_EH_ACTIVATE_RULE(const CommonCmdPacket* packet)
{
  EH_RULE_ID rule_id = (EH_RULE_ID)CCP_get_param_from_packet(packet, 0, uint16_t);
  EH_CHECK_RULE_ACK ack = EH_activate_rule(rule_id);
 
  switch (ack)
  {
  case EH_CHECK_RULE_ACK_OK:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
  case EH_CHECK_RULE_ACK_INVALID_RULE_ID:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_PARAMETER);
  case EH_CHECK_RULE_ACK_UNREGISTERED:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  default:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  }
}
 
 
CCP_CmdRet Cmd_EH_INACTIVATE_RULE(const CommonCmdPacket* packet)
{
  EH_RULE_ID rule_id = (EH_RULE_ID)CCP_get_param_from_packet(packet, 0, uint16_t);
  EH_CHECK_RULE_ACK ack = EH_inactivate_rule(rule_id);
 
  switch (ack)
  {
  case EH_CHECK_RULE_ACK_OK:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
  case EH_CHECK_RULE_ACK_INVALID_RULE_ID:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_PARAMETER);
  case EH_CHECK_RULE_ACK_UNREGISTERED:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  default:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  }
}
 
 
CCP_CmdRet Cmd_EH_ACTIVATE_RULE_FOR_MULTI_LEVEL(const CommonCmdPacket* packet)
{
  EH_RULE_ID rule_id = (EH_RULE_ID)CCP_get_param_from_packet(packet, 0, uint16_t);
  EH_CHECK_RULE_ACK ack = EH_activate_rule_for_multi_level(rule_id);
 
  switch (ack)
  {
  case EH_CHECK_RULE_ACK_OK:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
  case EH_CHECK_RULE_ACK_INVALID_RULE_ID:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_PARAMETER);
  case EH_CHECK_RULE_ACK_UNREGISTERED:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  default:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  }
}
 
 
CCP_CmdRet Cmd_EH_INACTIVATE_RULE_FOR_MULTI_LEVEL(const CommonCmdPacket* packet)
{
  EH_RULE_ID rule_id = (EH_RULE_ID)CCP_get_param_from_packet(packet, 0, uint16_t);
  EH_CHECK_RULE_ACK ack = EH_inactivate_rule_for_multi_level(rule_id);
 
  switch (ack)
  {
  case EH_CHECK_RULE_ACK_OK:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
  case EH_CHECK_RULE_ACK_INVALID_RULE_ID:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_PARAMETER);
  case EH_CHECK_RULE_ACK_UNREGISTERED:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  default:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  }
}
 
 
CCP_CmdRet Cmd_EH_SET_RULE_COUNTER(const CommonCmdPacket* packet)
{
  EH_RULE_ID rule_id = (EH_RULE_ID)CCP_get_param_from_packet(packet, 0, uint16_t);
  uint16_t counter = CCP_get_param_from_packet(packet, 1, uint16_t);
  EH_CHECK_RULE_ACK ack = EH_set_rule_counter(rule_id, counter);
 
  switch (ack)
  {
  case EH_CHECK_RULE_ACK_OK:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
  case EH_CHECK_RULE_ACK_INVALID_RULE_ID:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_PARAMETER);
  case EH_CHECK_RULE_ACK_UNREGISTERED:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  default:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  }
}
 
 
CCP_CmdRet Cmd_EH_CLEAR_RULE_COUNTER(const CommonCmdPacket* packet)
{
  EH_RULE_ID rule_id = (EH_RULE_ID)CCP_get_param_from_packet(packet, 0, uint16_t);
  EH_CHECK_RULE_ACK ack = EH_clear_rule_counter(rule_id);
 
  switch (ack)
  {
  case EH_CHECK_RULE_ACK_OK:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
  case EH_CHECK_RULE_ACK_INVALID_RULE_ID:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_PARAMETER);
  case EH_CHECK_RULE_ACK_UNREGISTERED:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  default:
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_CONTEXT);
  }
}
 
 
CCP_CmdRet Cmd_EH_CLEAR_RULE_COUNTER_BY_EVENT(const CommonCmdPacket* packet)
{
  EL_GROUP group = (EL_GROUP)CCP_get_param_from_packet(packet, 0, uint32_t);
  uint32_t local = (EL_GROUP)CCP_get_param_from_packet(packet, 1, uint32_t);
  EL_ERROR_LEVEL err_level = (EL_ERROR_LEVEL)CCP_get_param_from_packet(packet, 2, uint8_t);
 
  EH_clear_rule_counter_by_event(group, local, err_level);
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_CLEAR_LOG(const CommonCmdPacket* packet)
{
  (void)packet;
  EH_clear_log_();
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_SET_MAX_RESPONSE_NUM(const CommonCmdPacket* packet)
{
  event_handler_.exec_settings.max_response_num = CCP_get_param_from_packet(packet, 0, uint8_t);
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_SET_MAX_CHECK_EVENT_NUM(const CommonCmdPacket* packet)
{
  event_handler_.exec_settings.max_check_event_num = CCP_get_param_from_packet(packet, 0, uint16_t);
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_SET_MAX_MULTI_LEVEL_NUM(const CommonCmdPacket* packet)
{
  event_handler_.exec_settings.max_multi_level_num = CCP_get_param_from_packet(packet, 0, uint8_t);
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_SET_PAGE_OF_RULE_TABLE_FOR_TLM(const CommonCmdPacket* packet)
{
  uint8_t page = CCP_get_param_from_packet(packet, 0, uint8_t);
  if (page >= EH_RULE_TLM_PAGE_MAX) return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_PARAMETER);
  event_handler_.tlm_info.rule.page_no = page;
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_SET_PAGE_OF_RULE_SORTED_IDX_FOR_TLM(const CommonCmdPacket* packet)
{
  uint8_t page = CCP_get_param_from_packet(packet, 0, uint8_t);
  if (page >= EH_RULE_TLM_PAGE_MAX) return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_PARAMETER);
  event_handler_.tlm_info.rule_sorted_index.page_no = page;
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_SET_PAGE_OF_LOG_TABLE_FOR_TLM(const CommonCmdPacket* packet)
{
  uint8_t page = CCP_get_param_from_packet(packet, 0, uint8_t);
  if (page >= EH_LOG_TLM_PAGE_MAX) return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_PARAMETER);
  event_handler_.tlm_info.log.page_no = page;
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_SET_TARGET_ID_OF_RULE_TABLE_FOR_TLM(const CommonCmdPacket* packet)
{
  EH_RULE_ID rule_id = (EH_RULE_ID)CCP_get_param_from_packet(packet, 0, uint16_t);
 
  if (EH_check_rule_id_(rule_id) == EH_CHECK_RULE_ACK_INVALID_RULE_ID)
  {
    return CCP_make_cmd_ret_without_err_code(CCP_EXEC_ILLEGAL_PARAMETER);
  }
 
  event_handler_.tlm_info.rule.target_rule_id = rule_id;
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_MATCH_EVENT_COUNTER_TO_EL(const CommonCmdPacket* packet)
{
  (void)packet;
  EH_match_event_counter_to_el();
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_INIT_RULE_BY_EVENT_GROUP(const CommonCmdPacket* packet)
{
  EL_GROUP group = (EL_GROUP)CCP_get_param_from_packet(packet, 0, uint32_t);
  EH_init_rule_by_event_group(group);
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_INIT_RULE_BY_EVENT_GROUP_FOR_MULTI_LEVEL(const CommonCmdPacket* packet)
{
  EL_GROUP group = (EL_GROUP)CCP_get_param_from_packet(packet, 0, uint32_t);
  EH_init_rule_by_event_group_for_multi_level(group);
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_ACTIVATE_RULE_BY_EVENT_GROUP(const CommonCmdPacket* packet)
{
  EL_GROUP group = (EL_GROUP)CCP_get_param_from_packet(packet, 0, uint32_t);
  EH_activate_rule_by_event_group(group);
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_INACTIVATE_RULE_BY_EVENT_GROUP(const CommonCmdPacket* packet)
{
  EL_GROUP group = (EL_GROUP)CCP_get_param_from_packet(packet, 0, uint32_t);
  EH_inactivate_rule_by_event_group(group);
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_ACTIVATE_RULE_BY_EVENT_GROUP_FOR_MULTI_LEVEL(const CommonCmdPacket* packet)
{
  EL_GROUP group = (EL_GROUP)CCP_get_param_from_packet(packet, 0, uint32_t);
  EH_activate_rule_by_event_group_for_multi_level(group);
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
 
CCP_CmdRet Cmd_EH_INACTIVATE_RULE_BY_EVENT_GROUP_FOR_MULTI_LEVEL(const CommonCmdPacket* packet)
{
  EL_GROUP group = (EL_GROUP)CCP_get_param_from_packet(packet, 0, uint32_t);
  EH_inactivate_rule_by_event_group_for_multi_level(group);
  return CCP_make_cmd_ret_without_err_code(CCP_EXEC_SUCCESS);
}
 
#endif  // EL_IS_ENABLE_TLOG
 
#pragma section