여유있으신분 좀 도와주세요*급*

프로젝트 소스인데요
버그가 뜨는걸 처리해야하는데 도통 모르겠군요..-_-
버그 내용은
---------------------------------------------------------------
< set up btrace 7 7 >
Version info
Kmalloc checktool : Ver.2.0.0
Custom info
Check mode : full-check
Number of backtrace steps : 7
Number of backtrace steps when alloc : 7
Minimum size for alloc : 0x00000000
Maximum size for alloc : 0x00020000
Check on all alloc area of API call : off
Underrun check mode : magic
Magic number of underrun guard area : 0x57
Overrun check mode : magic
Magic number of overrrun guard area : 0x59
Poisoning mode when alloc : magic
Magic number of poisoning when alloc : 0xb9
Poisoning mode when free : magic
Magic number of poisoning when free : 0xb7
MMU use mode : off
Minimum size for MMU use : 0x00000000
Maximum size for MMU use : 0x00000000
Status info
Leak status : stop
Jan 1 09:05:06 (none) kernel: [KC][MAJ][KMA] invalid flags (api:kmalloc, pc:00002988(kmatest_drv) <- 000004c4(kmatest_drv) <- d837c690(kernel) <- d8358f34(kernel) <- d82f3100(kernel) <- 0
0000000(kernel) <- 00000000(kernel))
Jan 1 09:05:06 (none) kernel: kfree call start
Jan 1 09:05:06 (none) kernel: kfree call end

Jan 1 09:05:06 (none) kernel: [KC][IGN][KMA] leak
Jan 1 09:05:06 (none) kernel: [KC][IGN][KMA] leak
Jan 1 09:05:06 (none) kernel: [KC][IGN][KMA] leak
------------------------------------------------------------
여기서 보면
Jan 1 09:05:06 (none) kernel: [KC][IGN][KMA] leak

5번째 부터는 00000000으로 표기 되는데.. 왜그럴까요???
kckma_cmd_stop(kc_cmd_t *cmd_p)함수를 불렀을때 일어납니다!
혹시 다른 파일도 필요하시다면 올리겠습니다.

잘아시는분 도와주세요 --

소스는 파일첨부가 안되는 관계로 좀 길지만 올려볼께요

/*
* linux/mm/ct_kmalloc_k.c
*
* Copyright (C) 2006 Matsushita Electric Industrial Co., Ltd.
*/

/* kmalloc check tool start */
/********************************************************************* @#@KC */

#if defined(__KERNEL_CHECK__) && defined(__KC_KMALLOC__)

/*****************************************************************************
* インクルード定義
*****************************************************************************/
#include
#include <../init/ct_misc_k.h>

/*****************************************************************************
* 定数定義
*****************************************************************************/
/* バージョン */
#define KCKMA_VER "Ver.2.0.0"

/* procファイル名 */
#define KCKMA_PROC "checktool/kmalloc"

/* コマンドID */
#define KCKMA_CMD_ID_START 0
#define KCKMA_CMD_ID_STOP (KCKMA_CMD_ID_START + 1)
#define KCKMA_CMD_ID_CHECK (KCKMA_CMD_ID_STOP + 1)
#define KCKMA_CMD_ID_HIST (KCKMA_CMD_ID_CHECK + 1)
#define KCKMA_CMD_ID_OFF_HIST (KCKMA_CMD_ID_HIST + 1)
#define KCKMA_CMD_ID_ON_HIST (KCKMA_CMD_ID_OFF_HIST + 1)
#define KCKMA_CMD_ID_BTRACE (KCKMA_CMD_ID_ON_HIST + 1)
#define KCKMA_CMD_ID_MINSIZE (KCKMA_CMD_ID_BTRACE + 1)
#define KCKMA_CMD_ID_MAXSIZE (KCKMA_CMD_ID_MINSIZE + 1)
#define KCKMA_CMD_ID_OFF_ALLALLOC (KCKMA_CMD_ID_MAXSIZE + 1)
#define KCKMA_CMD_ID_ON_ALLALLOC (KCKMA_CMD_ID_OFF_ALLALLOC + 1)
#define KCKMA_CMD_ID_OFF_URUN (KCKMA_CMD_ID_ON_ALLALLOC + 1)
#define KCKMA_CMD_ID_MAGIC_URUN (KCKMA_CMD_ID_OFF_URUN + 1)
#define KCKMA_CMD_ID_ADDR_URUN (KCKMA_CMD_ID_MAGIC_URUN + 1)
#define KCKMA_CMD_ID_OFF_ORUN (KCKMA_CMD_ID_ADDR_URUN + 1)
#define KCKMA_CMD_ID_MAGIC_ORUN (KCKMA_CMD_ID_OFF_ORUN + 1)
#define KCKMA_CMD_ID_ADDR_ORUN (KCKMA_CMD_ID_MAGIC_ORUN + 1)
#define KCKMA_CMD_ID_OFF_APOISON (KCKMA_CMD_ID_ADDR_ORUN + 1)
#define KCKMA_CMD_ID_MAGIC_APOISON (KCKMA_CMD_ID_OFF_APOISON + 1)
#define KCKMA_CMD_ID_ADDR_APOISON (KCKMA_CMD_ID_MAGIC_APOISON + 1)
#define KCKMA_CMD_ID_OFF_FPOISON (KCKMA_CMD_ID_ADDR_APOISON + 1)
#define KCKMA_CMD_ID_MAGIC_FPOISON (KCKMA_CMD_ID_OFF_FPOISON + 1)
#define KCKMA_CMD_ID_ADDR_FPOISON (KCKMA_CMD_ID_MAGIC_FPOISON + 1)
#define KCKMA_CMD_ID_OFF_MMU (KCKMA_CMD_ID_ADDR_FPOISON + 1)
#define KCKMA_CMD_ID_ON_MMU (KCKMA_CMD_ID_OFF_MMU + 1)
#define KCKMA_CMD_ID_CB_MMU (KCKMA_CMD_ID_ON_MMU + 1)
#ifdef KCKMA_DEBUG
#define KCKMA_DEBUG_CMD_ID_ALL_CALL (KCKMA_CMD_ID_CB_MMU + 1)
#endif /* KCKMA_DEBUG */

/* チェックモード */
#define KCKMA_CHECK_MODE_OFF 0
#define KCKMA_CHECK_MODE_HIST 1
#define KCKMA_CHECK_MODE_FULL 2

/* API種別 */
#define KCKMA_API_KMALLOC 0
#define KCKMA_API_KFREE 1

/* アライメントサイズ */
#define KCKMA_ALIGN_MEM 4
#define KCKMA_ALIGN_PTR 4

/* ハッシュサイズ */
#define KCKMA_HASH_SIZE 257

/* 呼出履歴保存数（2のべき乗であること） */
#define KCKMA_HIST_SIZE 1024

/* IN/OUT種別 */
#define KCKMA_IO_IN 0x1
#define KCKMA_IO_OUT 0x2

/* 呼出履歴属性 */
#define KCKMA_HIST_IRQ_MASK 0x0001
#define KCKMA_HIST_API_MASK 0x0010
#define KCKMA_HIST_IO_MASK 0x0300
#define KCKMA_HIST_IRQ_SHIFT 0
#define KCKMA_HIST_API_SHIFT 4
#define KCKMA_HIST_IO_SHIFT 8

/* kmalloc獲得可能最大サイズ */
#define KCKMA_KMALLOC_MAXSIZE 0x00020000

/* コンフィグレーション（チェックモード） */
#if defined(__KCKMA_CUSTOM_CHECK_MODE_OFF__)
#define __KCKMA_CUSTOM_CHECK_MODE__ KCKMA_CHECK_MODE_OFF
#endif /* __KCKMA_CUSTOM_CHECK_MODE_OFF__ */
#if defined(__KCKMA_CUSTOM_CHECK_MODE_HIST__)
#define __KCKMA_CUSTOM_CHECK_MODE__ KCKMA_CHECK_MODE_HIST
#endif /* __KCKMA_CUSTOM_CHECK_MODE_HIST__ */
#if defined(__KCKMA_CUSTOM_CHECK_MODE_FULL__)
#define __KCKMA_CUSTOM_CHECK_MODE__ KCKMA_CHECK_MODE_FULL
#endif /* __KCKMA_CUSTOM_CHECK_MODE_CHECK__ */

/* コンフィグレーション（全獲得領域チェック実施フラグ） */
#if defined(__KCKMA_CUSTOM_ALL_ALLOC_FLAG_OFF__)
#define __KCKMA_CUSTOM_ALL_ALLOC_FLAG__ 0
#endif /* __KCKMA_CUSTOM_ALL_ALLOC_FLAG_OFF__ */
#if defined(__KCKMA_CUSTOM_ALL_ALLOC_FLAG_ON__)
#define __KCKMA_CUSTOM_ALL_ALLOC_FLAG__ 1
#endif /* __KCKMA_CUSTOM_ALL_ALLOC_FLAG_ON__ */

/* コンフィグレーション（アンダーランチェック実施モード） */
#if defined(__KCKMA_CUSTOM_URUN_MODE_OFF__)
#define __KCKMA_CUSTOM_URUN_MODE__ KCUC_FILL_MODE_OFF
#endif /* __KCKMA_CUSTOM_URUN_MODE_OFF__ */
#if defined(__KCKMA_CUSTOM_URUN_MODE_MAGIC__)
#define __KCKMA_CUSTOM_URUN_MODE__ KCUC_FILL_MODE_MAGIC
#endif /* __KCKMA_CUSTOM_URUN_MODE_MAGIC__ */
#if defined(__KCKMA_CUSTOM_URUN_MODE_ADDR__)
#define __KCKMA_CUSTOM_URUN_MODE__ KCUC_FILL_MODE_ADDR
#endif /* __KCKMA_CUSTOM_URUN_MODE_ADDR__ */

/* コンフィグレーション（オーバーランチェック実施モード） */
#if defined(__KCKMA_CUSTOM_ORUN_MODE_OFF__)
#define __KCKMA_CUSTOM_ORUN_MODE__ KCUC_FILL_MODE_OFF
#endif /* __KCKMA_CUSTOM_ORUN_MODE_OFF__ */
#if defined(__KCKMA_CUSTOM_ORUN_MODE_MAGIC__)
#define __KCKMA_CUSTOM_ORUN_MODE__ KCUC_FILL_MODE_MAGIC
#endif /* __KCKMA_CUSTOM_ORUN_MODE_MAGIC__ */
#if defined(__KCKMA_CUSTOM_ORUN_MODE_ADDR__)
#define __KCKMA_CUSTOM_ORUN_MODE__ KCUC_FILL_MODE_ADDR
#endif /* __KCKMA_CUSTOM_ORUN_MODE_ADDR__ */

/* コンフィグレーション（獲得時ポイズニング実施モード） */
#if defined(__KCKMA_CUSTOM_A_POISON_MODE_OFF__)
#define __KCKMA_CUSTOM_A_POISON_MODE__ KCUC_FILL_MODE_OFF
#endif /* __KCKMA_CUSTOM_A_POISON_MODE_OFF__ */
#if defined(__KCKMA_CUSTOM_A_POISON_MODE_MAGIC__)
#define __KCKMA_CUSTOM_A_POISON_MODE__ KCUC_FILL_MODE_MAGIC
#endif /* __KCKMA_CUSTOM_A_POISON_MODE_MAGIC__ */
#if defined(__KCKMA_CUSTOM_A_POISON_MODE_ADDR__)
#define __KCKMA_CUSTOM_A_POISON_MODE__ KCUC_FILL_MODE_ADDR
#endif /* __KCKMA_CUSTOM_A_POISON_MODE_ADDR__ */

/* コンフィグレーション（解放時ポイズニング実施モード） */
#if defined(__KCKMA_CUSTOM_F_POISON_MODE_OFF__)
#define __KCKMA_CUSTOM_F_POISON_MODE__ KCUC_FILL_MODE_OFF
#endif /* __KCKMA_CUSTOM_F_POISON_MODE_OFF__ */
#if defined(__KCKMA_CUSTOM_F_POISON_MODE_MAGIC__)
#define __KCKMA_CUSTOM_F_POISON_MODE__ KCUC_FILL_MODE_MAGIC
#endif /* __KCKMA_CUSTOM_F_POISON_MODE_MAGIC__ */
#if defined(__KCKMA_CUSTOM_F_POISON_MODE_ADDR__)
#define __KCKMA_CUSTOM_F_POISON_MODE__ KCUC_FILL_MODE_ADDR
#endif /* __KCKMA_CUSTOM_F_POISON_MODE_ADDR__ */

/* コンフィグレーション（MMU利用モード） */
#if defined(__KCKMA_CUSTOM_MMU_MODE_OFF__)
#define __KCKMA_CUSTOM_MMU_MODE__ KCUC_MMU_MODE_OFF
#endif /* __KCKMA_CUSTOM_MMU_MODE_OFF__ */
#if defined(__KCKMA_CUSTOM_MMU_MODE_ON__)
#define __KCKMA_CUSTOM_MMU_MODE__ KCUC_MMU_MODE_ON
#endif /* __KCKMA_CUSTOM_MMU_MODE_ON__ */
#if defined(__KCKMA_CUSTOM_MMU_MODE_CB__)
#define __KCKMA_CUSTOM_MMU_MODE__ KCUC_MMU_MODE_CB
#endif /* __KCKMA_CUSTOM_MMU_MODE_CB__ */

/*****************************************************************************
* 型定義
*****************************************************************************/
/* カスタム情報 */
typedef struct kckma_custom {
kcuc_custom_mode_t check_mode; /* チェックモード */
kcuc_custom_btrace2_t btrace; /* バックトレース関連 */
kcuc_custom_size_t minsize; /* 正常時獲得最小サイズ関連 */
kcuc_custom_size_t maxsize; /* 正常時獲得最大サイズ関連 */
kcuc_custom_flag_t all_alloc; /* 全獲得領域チェック関連 */
kcuc_custom_fill_t urun; /* アンダーラン関連 */
kcuc_custom_fill_t orun; /* オーバーラン関連 */
kcuc_custom_fill_t a_poison; /* 獲得時ポイズニング関連 */
kcuc_custom_fill_t f_poison; /* 解放時ポイズニング関連 */
kcuc_custom_mmu_t mmu; /* MMU関連 */
} kckma_custom_t;

/* チェック情報 */
typedef struct kckma_check {
unsigned long usize:20; /* ユーザー獲得サイズ */
unsigned long a_btrace_num:3; /* 獲得時保持バックトレース数 */
unsigned long leak_flag:1; /* リーク対象フラグ */
unsigned long urun_mode:2; /* アンダーランチェック実施モード */
unsigned long orun_mode:2; /* オーバーランチェック実施モード */
unsigned long mmu_flag:1; /* MMU対象フラグ */
unsigned long reserve:3; /* 予約 */
} kckma_check_t;

/* ハッシュリスト */
typedef struct kckma_hash {
struct kckma_hash *next_p;
} kckma_hash_t;

/* 呼出履歴情報 */
typedef struct kckma_hist {
pid_t pid; /* PID */
unsigned long in_jiffies; /* in時jiffies */
unsigned long out_jiffies; /* out時jiffies */
unsigned long attr; /* 0bit:割り込みハンドラ呼出フラグ */
/* 4-5bit:API種別 */
/* 8-9bit:IN/OUT種別 */
size_t size; /* 獲得要求サイズ */
int flags; /* 獲得要求フラグ */
void *umem_p; /* 獲得／解放領域アドレス */
const void *caller_p; /* 呼出元アドレス */
} kckma_hist_t;

/* 領域アドレス情報 */
typedef struct kckma_memarea {
volatile unsigned char *urun_p; /* アンダーランガード領域 */
void *umem_p; /* ユーザー獲得領域 */
volatile unsigned char *orun_p; /* オーバーランガード領域 */
kcuc_btrace_addr_t *a_btrace_p; /* 獲得時バックトレース領域 */
kckma_hash_t *hash_p; /* ハッシュリスト領域 */
kckma_check_t *check_p; /* チェック情報領域 */
} kckma_memarea_t;

/* API情報 */
typedef struct kckma_api {
kcuc_btrace_t btrace; /* バックトレース */
int api_id; /* API種別 */
void *cmem_p; /* チェックツール獲得領域アドレス */
size_t csize; /* チェックツール獲得領域サイズ */
size_t usize; /* ユーザー獲得領域サイズ */
kckma_check_t check; /* チェック情報 */
kckma_memarea_t area; /* 獲得メモリ上各領域アドレス */
int flags; /* kmallocパラメータ */
} kckma_api_t;

#ifdef KCKMA_DEBUG
/* 呼出統計情報 */
typedef struct kckma_debug_call_status {
unsigned long kmalloc; /* kmalloc呼出回数 */
unsigned long kmalloc_a; /* kmalloc呼出回数（獲得時） */
unsigned long kfree; /* kfree呼出回数 */
unsigned long kfree_f; /* kfree呼出回数（解放時） */
} kckma_debug_call_status_t;
#endif /* KCKMA_DEBUG */

/*****************************************************************************
* インライン関数プロトタイプ定義
*****************************************************************************/
/* ストレートマップアドレスの取得 */
KCUC_INLINE static void *kckma_get_straight_map_addr(void *);

/* 領域アドレス情報の取得 */
KCUC_INLINE static void kckma_get_memarea(kckma_memarea_t *, void *,
kckma_check_t);

/* ハッシュリストから領域アドレス情報の取得 */
KCUC_INLINE static void kckma_hash2memarea(kckma_hash_t *, kckma_memarea_t *);

/* ハッシュリストのチェック */
KCUC_INLINE static int kckma_check_hash(kckma_api_t *, kckma_hash_t *, /*<1100193>*/
kckma_memarea_t *); /*<1100193>*/
/*<1100193>*//* KCUC_INLINE static int kckma_check_hash(kckma_api_t *, kckma_hash_t *); */

/* ハッシュへの追加 */
KCUC_INLINE static void kckma_add_hash(kckma_api_t *);

/* ハッシュからの削除と領域アドレス情報の取得 */
KCUC_INLINE static int kckma_del_hash_and_get_memarea(kckma_api_t *);

/* 獲得時チェック情報の設定 */
KCUC_INLINE static void kckma_set_a_check(kckma_api_t *);

/* 獲得要求サイズのチェック */
KCUC_INLINE static void kckma_check_invalid_size(kckma_api_t *);

/* 獲得要求フラグのチェック */
KCUC_INLINE static void kckma_check_invalid_flags(kckma_api_t *);

/* ガード領域の設定 */
KCUC_INLINE static void kckma_set_guard(unsigned long, unsigned char *,
unsigned char);

/* ガード領域のチェック */
KCUC_INLINE static int kckma_check_guard(unsigned long, unsigned char *,
unsigned char);

/* アンダーランガード領域の設定 */
KCUC_INLINE static void kckma_set_urun(kckma_api_t *);

/* オーバーランガード領域の設定 */
KCUC_INLINE static void kckma_set_orun(kckma_api_t *);

/* アンダーラン書き込みアクセスのチェック */
KCUC_INLINE static int kckma_check_urun(kckma_api_t *, kckma_memarea_t *);

/* オーバーラン書き込みアクセスのチェック */
KCUC_INLINE static int kckma_check_orun(kckma_api_t *, kckma_memarea_t *);

/* 獲得時のポイズニング */
KCUC_INLINE static void kckma_set_a_poison(kckma_api_t *);

/* 開放時のポイズニング */
KCUC_INLINE static void kckma_set_f_poison(kckma_api_t *);

/* MMU利用対象の判定 */
KCUC_INLINE static void kckma_check_mmu_use(kckma_api_t *api_p);

/* MMU対象のメモリ獲得 */
KCUC_INLINE static void kckma_mmu_alloc(kckma_api_t *);

/* MMU対象のメモリ開放 */
KCUC_INLINE static void kckma_mmu_free(kckma_api_t *);

/* kmalloc事前処理 */
KCUC_INLINE static int kckma_pre_kmalloc(kckma_api_t *);

/* kmalloc事後処理 */
KCUC_INLINE static void kckma_post_kmalloc(kckma_api_t *);

/* kfree事前処理 */
KCUC_INLINE static int kckma_pre_kfree(kckma_api_t *);

/* 呼出履歴（入口）の設定 */
KCUC_INLINE static void kckma_set_hist_kmalloc_in(pid_t, unsigned long,
unsigned long, int,
const void *);

/* 呼出履歴（入口）の設定 */
KCUC_INLINE static void kckma_set_hist_kfree_in(pid_t, unsigned long,
const void *, void *);

/* 呼出履歴（出口）の設定 */
KCUC_INLINE static void kckma_set_hist_kmalloc_out(pid_t, unsigned long,
unsigned long, int,
const void *, void *);

/* 呼出履歴（出口）の設定 */
KCUC_INLINE static void kckma_set_hist_kfree_out(pid_t, unsigned long,
const void *, void *);

/*****************************************************************************
* 関数プロトタイプ定義
*****************************************************************************/
/* 全獲得領域の不正アクセスのチェック */
static void kckma_check_all_alloc(kckma_api_t *api_p);

/* procファイル読み込み時処理 */
static int kckma_proc_r(char *, char **, off_t, int, int *,void *);

/* procファイル書き込み時処理 */
static int kckma_proc_w(struct file *, const char *, unsigned long, void *);

/* startコマンド処理 */
static int kckma_cmd_start(kc_cmd_t *);

/* stopコマンド処理 */
static int kckma_cmd_stop(kc_cmd_t *);

/* checkコマンド処理 */
static int kckma_cmd_check(kc_cmd_t *);

/* histコマンド処理 */
static int kckma_cmd_hist(kc_cmd_t *);

/* off-hist / on-histコマンド処理 */
static int kckma_cmd_hist2(kc_cmd_t *);

/* btraceコマンド処理 */
static int kckma_cmd_btrace(kc_cmd_t *);

/* off-urun / magic-urun / addr-urunコマンド処理 */
static int kckma_cmd_urun(kc_cmd_t *);

/* off-orun / magic-orun / addr-orunコマンド処理 */
static int kckma_cmd_orun(kc_cmd_t *);

/* minsizeコマンド処理 */
static int kckma_cmd_minsize(kc_cmd_t *);

/* maxsizeコマンド処理 */
static int kckma_cmd_maxsize(kc_cmd_t *);

/* off-allalloc / on-allallocコマンド処理 */
static int kckma_cmd_allalloc(kc_cmd_t *);

/* off-apoison / magic-apoison / addr-apoisonコマンド処理 */
static int kckma_cmd_apoison(kc_cmd_t *);

/* off-fpoison / magic-fpoison / addr-fpoisonコマンド処理 */
static int kckma_cmd_fpoison(kc_cmd_t *);

/* off-mmu / on-mmu / cb-mmuコマンド処理 */
static int kckma_cmd_mmu(kc_cmd_t *);

#ifdef KCKMA_DEBUG
/* debug-all-callコマンド処理 */
static int kckma_debug_cmd_call(kc_cmd_t *);
#endif /* KCKMA_DEBUG */

/* メモリ破壊チェックとメモリリーク検出 */
static int kckma_check_and_leak(kc_leak_info_t *); /*<1100192>*/
/*<1100192>*//* static void kckma_check_and_leak(int); */

/*****************************************************************************
* 静的変数定義
*****************************************************************************/
/* カスタム情報 */
static kckma_custom_t kckma_custom;

/* リーク検出期間フラグ */
static int kckma_leak_flag;

/* ハッシュテーブル */
static kckma_hash_t kckma_hash_tbl[KCKMA_HASH_SIZE];

/* API名 */
static const char *kckma_api_name_p[] = {
"kmalloc", "kfree"
};

/* procファイルコマンドテーブル */
static const kc_cmd_tbl_t kckma_cmd_tbl[] = {
{"start", kckma_cmd_start, {KC_PARA_N}},
{"stop", kckma_cmd_stop, {KC_PARA_N}},
{"check", kckma_cmd_check, {KC_PARA_N}},
{"hist", kckma_cmd_hist, {KC_PARA_N}},
{"off-hist", kckma_cmd_hist2, {KC_PARA_N}},
{"on-hist", kckma_cmd_hist2, {KC_PARA_N}},
{"btrace", kckma_cmd_btrace, {KC_PARA_I, KC_PARA_I,
KC_PARA_N}},
{"minsize", kckma_cmd_minsize, {KC_PARA_I, KC_PARA_N}},
{"maxsize", kckma_cmd_maxsize, {KC_PARA_I, KC_PARA_N}},
{"off-allalloc", kckma_cmd_allalloc, {KC_PARA_N}},
{"on-allalloc", kckma_cmd_allalloc, {KC_PARA_N}},
{"off-urun", kckma_cmd_urun, {KC_PARA_N}},
{"magic-urun", kckma_cmd_urun, {KC_PARA_N}},
{"addr-urun", kckma_cmd_urun, {KC_PARA_N}},
{"off-orun", kckma_cmd_orun, {KC_PARA_N}},
{"magic-orun", kckma_cmd_orun, {KC_PARA_N}},
{"addr-orun", kckma_cmd_orun, {KC_PARA_N}},
{"off-apoison", kckma_cmd_apoison, {KC_PARA_N}},
{"magic-apoison", kckma_cmd_apoison, {KC_PARA_I, KC_PARA_N}},
{"addr-apoison", kckma_cmd_apoison, {KC_PARA_N}},
{"off-fpoison", kckma_cmd_fpoison, {KC_PARA_N}},
{"magic-fpoison", kckma_cmd_fpoison, {KC_PARA_I, KC_PARA_N}},
{"addr-fpoison", kckma_cmd_fpoison, {KC_PARA_N}},
{"off-mmu", kckma_cmd_mmu, {KC_PARA_N}},
{"on-mmu", kckma_cmd_mmu, {KC_PARA_I, KC_PARA_I,
KC_PARA_N}},
{"cb-mmu", kckma_cmd_mmu, {KC_PARA_I, KC_PARA_I,
KC_PARA_N}},
#ifdef KCKMA_DEBUG
{"debug-all-call", kckma_debug_cmd_call, {KC_PARA_N}},
#endif /* KCKMA_DEBUG */
{NULL, NULL, {KC_PARA_N}} /* 終端 */
};

/* MMU利用処理中フラグ */
static int kckma_mmu_flag;

/* 呼出履歴 */
static kckma_hist_t kckma_hist_rbuf[KCKMA_HIST_SIZE];
/* 呼出履歴リングバッファ */
static int kckma_hist_index;
/* 呼出履歴インデックス */

/* MMU利用判定コールバック関数 */
static int (*kckma_mmu_cb_p)(void) = NULL;

#ifdef KCKMA_DEBUG
/* 呼出統計情報 */
kckma_debug_call_status_t kckma_debug_call_status;
#endif /* KCKMA_DEBUG */

/*****************************************************************************
* マクロ関数定義
*****************************************************************************/
/* アンダーランガード領域サイズの取得 */
#define kckma_get_size_urun(__check) \
((((__check).urun_mode) == KCUC_FILL_MODE_OFF) \
? 0 : (sizeof(unsigned char) * 4))

/* オーバーランガード領域サイズの取得 */
#define kckma_get_size_orun(__check) \
((((__check).orun_mode) == KCUC_FILL_MODE_OFF) \
? 0 : (sizeof(unsigned char) * 4))

/* 獲得時バックトレース領域サイズの取得 */
#define kckma_get_size_a_btrace(__check) \
(sizeof(void *) * (__check).a_btrace_num)

/* ハッシュリスト領域サイズの取得 */
#define kckma_get_size_hash() \
(sizeof(kckma_hash_t))

/* チェック情報領域サイズの取得 */
#define kckma_get_size_check() \
(sizeof(kckma_check_t))

/* チェックツール情報全領域サイズの取得 */
#define kckma_get_size_check_all(__check) \
( kckma_get_size_urun(__check) \
+ kckma_get_size_orun(__check) \
+ kckma_get_size_a_btrace((__check)) \
+ kckma_get_size_hash() \
+ kckma_get_size_check())

/* ユーザー獲得領域アドレス ⇒ チェックツール獲得領域アドレス */
#define kckma_umem2cmem(__umem_p, __check) \
((__umem_p) - kckma_get_size_urun(__check))

/* ユーザー獲得領域サイズ ⇒ チェックツール獲得領域サイズ */
#define kckma_usize2csize(__check) \
(((__check).usize + kckma_get_size_check_all((__check)) \
+ (KCKMA_ALIGN_MEM - 1)) & ~(KCKMA_ALIGN_MEM - 1))

/* ハッシュの取得 */
#define kckma_get_hash(__umem_p) \
(&kckma_hash_tbl[((((unsigned long)(__umem_p)) >> 2) % KCKMA_HASH_SIZE)]);

/* 呼出履歴属性の結合 */
#define kckma_join_hist_attr(__irq_flag, __api_id, __io_type) \
((__irq_flag) << KCKMA_HIST_IRQ_SHIFT | \
(__api_id) << KCKMA_HIST_API_SHIFT | \
(__io_type) << KCKMA_HIST_IO_SHIFT)

/* 呼出履歴属性の分離 */
#define kckma_sepa_hist_attr(__attr, __irq_flag_p, __api_id_p, __io_type_p) \
do { \
(*(__irq_flag_p)) \
= ((__attr) & KCKMA_HIST_IRQ_MASK) >> KCKMA_HIST_IRQ_SHIFT; \
(*(__api_id_p)) \
= ((__attr) & KCKMA_HIST_API_MASK) >> KCKMA_HIST_API_SHIFT; \
(*(__io_type_p)) \
= ((__attr) & KCKMA_HIST_IO_MASK) >> KCKMA_HIST_IO_SHIFT; \
} while (0);

/* API呼出情報の取得 */
#define kckma_get_api_call_info(__api_p, __api_name_pp, __btrace_num_p, \
__btrace_addr_pp) \
do { \
if (__api_p) { \
*(__api_name_pp) = kckma_api_name_p[(__api_p)->api_id]; \
*(__btrace_num_p) = (__api_p)->btrace.num; \
*(__btrace_addr_pp) = (__api_p)->btrace.addr; \
} \
else { \
*(__api_name_pp) = (const char *)NULL; \
*(__btrace_num_p) = 0; \
*(__btrace_addr_pp) = (kcuc_btrace_addr_t *)NULL; \
} \
} while (0);

/*****************************************************************************
* 機能概要 ：ストレートマップアドレスの取得
* 呼出形式 ：KCUC_INLINE static void *
* ：kckma_get_straight_map_addr(void *)
* 引数 ：void *mem_p メモリアドレス
* 戻り値 ：すべて ストレートマップアドレス
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void *
kckma_get_straight_map_addr(void *mem_p)
{
unsigned long page_offset;
unsigned long page_addr;
unsigned long save_flags;

if ((unsigned long)mem_p >= VMALLOC_START &&
(unsigned long)mem_p < VMALLOC_END) {
local_irq_save(save_flags);
page_offset = kc_get_page_offset(mem_p);
page_addr = kc_get_page_addr(mem_p);
mem_p = page_address(vmalloc_to_page((void *)page_addr)) + page_offset;
local_irq_restore(save_flags);
}
return mem_p;
}

/*****************************************************************************
* 機能概要 ：領域アドレス情報の取得
* 呼出形式 ：KCUC_INLINE static void
* ：kckma_get_memarea(kckma_memarea_t *, void *, kckma_check_t)
* 引数 ：kckma_memarea_t *area_p 領域アドレス情報
* ：void *cmem_p チェックツール獲得領域アドレス
* ：kckma_check_t check チェック情報
* 戻り値 ：なし
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_get_memarea(kckma_memarea_t *area_p, void *cmem_p, kckma_check_t check)
{
void *e_cmem_p;
size_t mem_size;
void *straight_map_p;
kmem_cache_t *cache_p;

straight_map_p = kckma_get_straight_map_addr(cmem_p);
cache_p = GET_PAGE_CACHE(virt_to_page(straight_map_p));
mem_size = cache_p->objsize;
e_cmem_p = cmem_p + mem_size;

area_p->urun_p
= (void *)cmem_p;
area_p->umem_p
= (void *)area_p->urun_p + kckma_get_size_urun(check);
area_p->orun_p
= (void *)area_p->umem_p + check.usize;

area_p->check_p
= (void *)e_cmem_p - kckma_get_size_check();
area_p->hash_p
= (void *)area_p->check_p - kckma_get_size_hash();
area_p->a_btrace_p
= (void *)area_p->hash_p - kckma_get_size_a_btrace(check);
}

/*****************************************************************************
* 機能概要 ：ハッシュリストから領域アドレス情報の取得
* 呼出形式 ：KCUC_INLINE static void
* ：kckma_hash2memarea(kckma_hash_t *, kckma_memarea_t *)
* 引数 ：kckma_hash_t *hash_p ハッシュリスト領域アドレス
* ：kckma_memarea_t *area_p 領域アドレス情報
* 戻り値 ：なし
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_hash2memarea(kckma_hash_t *hash_p, kckma_memarea_t *area_p)
{
void *cmem_p;
kckma_check_t check;
void *e_cmem_p;
size_t mem_size;
void *straight_map_p;
kmem_cache_t *cache_p;

check = *((kckma_check_t *)( (void *)hash_p
+ kckma_get_size_hash()));

e_cmem_p = ( (void *)hash_p
+ kckma_get_size_hash()
+ kckma_get_size_check());
straight_map_p = kckma_get_straight_map_addr((void *)hash_p);
cache_p = GET_PAGE_CACHE(virt_to_page(straight_map_p));
mem_size = cache_p->objsize;
cmem_p = e_cmem_p - mem_size;

kckma_get_memarea(area_p, cmem_p, check);
}

/*****************************************************************************
* 機能概要 ：チェックツール情報（ハッシュリストポインタ）のチェック
* 呼出形式 ：KCUC_INLINE static int
* ：kckma_check_hash(kckma_api_t *, kckma_hash_t *,
* ： kckma_memarea_t *)
* 引数 ：kckma_api_t *api_p API情報
* ：kckma_hash_t *hash_p
* ：kckma_memarea_t *area_p 領域アドレス情報
* 戻り値 ：== 0 正常
* ：== -1 異常
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static int
kckma_check_hash(kckma_api_t *api_p, kckma_hash_t *hash_p, /*<1100193>*/
kckma_memarea_t *area_p) /*<1100193>*/
/*<1100193>*//* kckma_check_hash(kckma_api_t *api_p, kckma_hash_t *hash_p) */
{
const char *api_name_p;
int btrace_num;
kcuc_btrace_addr_t *btrace_addr_p;

if (!(kcuc_check_align(hash_p, KCKMA_ALIGN_PTR))) {
kckma_get_api_call_info(api_p, &api_name_p, &btrace_num,
&btrace_addr_p);
if (area_p) { /*<1100193>*/
kc_log_0ae(1, api_name_p, btrace_num, btrace_addr_p, /*<1100193>*/
area_p->check_p->a_btrace_num, area_p->a_btrace_p, /*<1100193>*/
"[KC][MAJ][KMA] checktool info broken */
area_p->umem_p, area_p->check_p->usize); /*<1100193>*/
}
else { /*<1100193>*/
kc_log_0a0(1, api_name_p, btrace_num, btrace_addr_p, /*<1100193>*/
"[KC][MAJ][KMA] checktool info broken {internal-hash_p:%p}", /*<1100193>*/
hash_p); /*<1100193>*/
} /*<1100193>*/
/*<1100193>*//* kc_log_0a0(1, api_name_p, btrace_num, btrace_addr_p, */
/*<1100193>*//* "[KC][MAJ][KMA] checktool info broken ", */
/*<1100193>*//* hash_p); */
return -1;
}
return 0;
}

/*****************************************************************************
* 機能概要 ：ハッシュリストへの追加
* 呼出形式 ：KCUC_INLINE static void
* ：kckma_add_hash(kckma_api_t *)
* 引数 ：kckma_api_t *api_p API情報
* 戻り値 ：なし
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_add_hash(kckma_api_t *api_p)
{
kckma_hash_t *hash_p;
kckma_hash_t **prev_hash_next_pp;

hash_p = kckma_get_hash(api_p->area.umem_p);
prev_hash_next_pp = &(hash_p->next_p);

api_p->area.hash_p->next_p = *prev_hash_next_pp;
*prev_hash_next_pp = api_p->area.hash_p;
}

/*****************************************************************************
* 機能概要 ：ハッシュリストからの削除と領域アドレス情報の取得
* 呼出形式 ：KCUC_INLINE static int
* ：kckma_del_hash_and_get_memarea(kckma_api_t *)
* 引数 ：kckma_api_t *api_p API情報
* 戻り値 ：== 0 正常
* ：== -1 異常
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static int
kckma_del_hash_and_get_memarea(kckma_api_t *api_p)
{
kckma_hash_t *hash_p;
kckma_hash_t **prev_hash_next_pp;
kckma_memarea_t area;
const char *api_name_p;
int btrace_num;
kcuc_btrace_addr_t *btrace_addr_p;
unsigned long save_flags;
kckma_memarea_t *area_p; /*<1100193>*/

if (kcuc_check_align(api_p->area.umem_p, KCKMA_ALIGN_MEM)) {
hash_p = kckma_get_hash(api_p->area.umem_p);
prev_hash_next_pp = &(hash_p->next_p);

local_irq_save(save_flags);

area_p = NULL; /*<1100193>*/
for (hash_p = hash_p->next_p; hash_p; hash_p = hash_p->next_p) {
if (kckma_check_hash(api_p, hash_p, area_p) < 0) { /*<1100193>*/
/*<1100193>*//* if (kckma_check_hash(api_p, hash_p) < 0) { */
local_irq_restore(save_flags);
return -1;
}

kckma_hash2memarea(hash_p, &area);
area_p = &area; /*<1100193>*/

if (area.umem_p == api_p->area.umem_p) {
*prev_hash_next_pp = area.hash_p->next_p;
memcpy(&api_p->area, &area, sizeof(kckma_memarea_t));
local_irq_restore(save_flags);
return 0;
}
prev_hash_next_pp = &(hash_p->next_p);
}

local_irq_restore(save_flags);
}

kckma_get_api_call_info(api_p, &api_name_p, &btrace_num, &btrace_addr_p);
kc_log_0a0(1, api_name_p, btrace_num, btrace_addr_p,
"[KC][MAJ][KMA] invalid pointer ", api_p->area.umem_p);
return -1;
}

/*****************************************************************************
* 機能概要 ：獲得時チェック情報の設定
* 呼出形式 ：KCUC_INLINE static void
* ：kckma_set_a_check(kckma_api_t *)
* 引数 ：kckma_api_t *api_p API情報
* 戻り値 ：なし
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_set_a_check(kckma_api_t *api_p)
{
const char *api_name_p;
int btrace_num;
kcuc_btrace_addr_t *btrace_addr_p;

api_p->check.leak_flag = kckma_leak_flag;
api_p->check.urun_mode = kckma_custom.urun.mode;
api_p->check.orun_mode = kckma_custom.orun.mode;

if (api_p->usize > ((1 << 20) - 1)) {
kckma_get_api_call_info(api_p, &api_name_p, &btrace_num, &btrace_addr_p);
kc_log_0a0(1, api_name_p, btrace_num, btrace_addr_p,
"[KC][MIN][KMA] invalid size ", api_p->usize);
}
api_p->check.usize = api_p->usize;

if (!kckma_mmu_flag) {
kckma_check_mmu_use(api_p);
}
else {
api_p->check.mmu_flag = 0;
}
}

/*****************************************************************************
* 機能概要 ：獲得要求サイズのチェック
* 呼出形式 ：KCUC_INLINE static void
* ：kckma_check_invalid_size(kckma_api_t *)
* 引数 ：kckma_api_t *api_p API情報
* 戻り値 ：なし
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_check_invalid_size(kckma_api_t *api_p)
{
const char *api_name_p;
int btrace_num;
kcuc_btrace_addr_t *btrace_addr_p;

if (api_p->usize < kckma_custom.minsize.size ||
api_p->usize > kckma_custom.maxsize.size ||
api_p->csize > KCKMA_KMALLOC_MAXSIZE) {
kckma_get_api_call_info(api_p, &api_name_p, &btrace_num, &btrace_addr_p);
kc_log_0a0(1, api_name_p, btrace_num, btrace_addr_p,
"[KC][WAR][KMA] invalid size ", api_p->usize);
}
}

/*****************************************************************************
* 機能概要 ：獲得要求フラグのチェック
* 呼出形式 ：KCUC_INLINE static void
* ：kckma_check_invalid_flags(kckma_api_t *)
* 引数 ：kckma_api_t *api_p API情報
* 戻り値 ：なし
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_check_invalid_flags(kckma_api_t *api_p)
{
const char *api_name_p;
int btrace_num;
kcuc_btrace_addr_t *btrace_addr_p;
int flags;

/* 獲得属性チェック */
flags = api_p->flags & ~GFP_DMA;
if (in_interrupt()) {
if (flags != GFP_ATOMIC) {
kckma_get_api_call_info(api_p, &api_name_p, &btrace_num, &btrace_addr_p);
kc_log_0a0(1, api_name_p, btrace_num, btrace_addr_p,
"[KC][MAJ][KMA] invalid flags in interrupt ",
api_p->flags);
}
}
else {
if (flags != GFP_NOHIGHIO && flags != GFP_NOIO &&
flags != GFP_NOFS && flags != GFP_ATOMIC &&
flags != GFP_USER && flags != GFP_HIGHUSER &&
flags != GFP_KERNEL && flags != GFP_NFS &&
flags != GFP_KSWAPD) {
kckma_get_api_call_info(api_p, &api_name_p, &btrace_num,
&btrace_addr_p);
kc_log_0a0(1, api_name_p, btrace_num, btrace_addr_p,
"[KC][MAJ][KMA] invalid flags ",
api_p->flags);
}
}
}

/*****************************************************************************
* 機能概要 ：ガード領域の設定
* 呼出形式 ：KCUC_INLINE static void
* ：kckma_set_guard(unsigned long, unsigned char *,
* ： unsigned char)
* 引数 ：unsigned long mode チェック実施モード
* ：unsigned char *guard_p ガード領域アドレス
* ：unsigned char magic マジックナンバ
* 戻り値 ：なし
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_set_guard(unsigned long mode, unsigned char *guard_p,
unsigned char magic)
{
unsigned long check_val;

if (mode == KCUC_FILL_MODE_MAGIC) {
*(guard_p + 0) = magic;
*(guard_p + 1) = magic;
*(guard_p + 2) = magic;
*(guard_p + 3) = magic;
}
else if (mode == KCUC_FILL_MODE_ADDR) {
check_val = (unsigned long)(guard_p) + 3;
*(guard_p + 0) = (unsigned char)((check_val >> 0) & 0xFF);
*(guard_p + 1) = (unsigned char)((check_val >> 8) & 0xFF);
*(guard_p + 2) = (unsigned char)((check_val >> 16) & 0xFF);
*(guard_p + 3) = (unsigned char)((check_val >> 24) & 0xFF);
}
}

/*****************************************************************************
* 機能概要 ：ガード領域のチェック
* 呼出形式 ：KCUC_INLINE static int
* ：kckma_check_guard(unsigned long, unsigned char *, unsigned char)
* 引数 ：unsigned long mode チェック実施モード
* ：unsigned char *guard_p ガード領域アドレス
* ：unsigned char magic マジックナンバ
* 戻り値 ：== 0 正常
* ：== -1 異常
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static int
kckma_check_guard(unsigned long mode, unsigned char *guard_p,
unsigned char magic)
{
unsigned long guard_val;
unsigned long check_val;

if (mode == KCUC_FILL_MODE_OFF) {
return 0;
}

guard_val = ((*(guard_p + 0)) << 0) + ((*(guard_p + 1)) << 8)
+ ((*(guard_p + 2)) << 16) + ((*(guard_p + 3)) << 24);

if (mode == KCUC_FILL_MODE_MAGIC) {
check_val = (magic << 0) + (magic << 8) + (magic << 16) + (magic << 24);
}
else {
check_val = (unsigned long)(guard_p) + 3;
}

return (guard_val == check_val) ? 0 : -1;
}

/*****************************************************************************
* 機能概要 ：アンダーランガード領域の設定
* 呼出形式 ：KCUC_INLINE static void
* ：kckma_set_urun(kckma_api_t *)
* 引数 ：kckma_api_t *api_p API情報
* 戻り値 ：なし
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_set_urun(kckma_api_t *api_p)
{
kckma_set_guard(api_p->check.urun_mode, (unsigned char *)api_p->area.urun_p,
(unsigned char)kckma_custom.urun.magic);
}

/*****************************************************************************
* 機能概要 ：オーバーランガード領域の設定
* 呼出形式 ：KCUC_INLINE static int
* ：kckma_set_orun(kckma_api_t *)
* 引数 ：kckma_api_t *api_p API情報
* 戻り値 ：なし
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_set_orun(kckma_api_t *api_p)
{
kckma_set_guard(api_p->check.orun_mode, (unsigned char *)api_p->area.orun_p,
(unsigned char)kckma_custom.orun.magic);
}

/*****************************************************************************
* 機能概要 ：アンダーラン書き込みアクセスのチェック
* 呼出形式 ：KCUC_INLINE static int
* ：kckma_check_urun(kckma_api_t *, kckma_memarea_t *)
* 引数 ：kckma_api_t *api_p API情報
* ：kckma_memarea_t *area_p
* 戻り値 ：== 0 正常
* ：== -1 異常
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static int
kckma_check_urun(kckma_api_t *api_p, kckma_memarea_t *area_p)
{
const char *api_name_p;
int btrace_num;
kcuc_btrace_addr_t *btrace_addr_p;

if (kckma_check_guard(area_p->check_p->urun_mode,
(unsigned char *)area_p->urun_p,
(unsigned char)kckma_custom.urun.magic) < 0) {
kckma_get_api_call_info(api_p, &api_name_p, &btrace_num, &btrace_addr_p);
kc_log_0ae(1, api_name_p, btrace_num, btrace_addr_p,
area_p->check_p->a_btrace_num, area_p->a_btrace_p,
"[KC][MAJ][KMA] buffer underrun area_p->umem_p, area_p->check_p->usize);
return -1;
}
return 0;
}

/*****************************************************************************
* 機能概要 ：オーバーラン書き込みアクセスのチェック
* 呼出形式 ：KCUC_INLINE static int
* ：kckma_check_orun(kckma_api_t *, kckma_memarea_t *)
* 引数 ：kckma_api_t *api_p API情報
* ：kckma_memarea_t *area_p
* 戻り値 ：== 0 正常
* ：== -1 異常
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static int
kckma_check_orun(kckma_api_t *api_p, kckma_memarea_t *area_p)
{
const char *api_name_p;
int btrace_num;
kcuc_btrace_addr_t *btrace_addr_p;

if (kckma_check_guard(area_p->check_p->orun_mode,
(unsigned char *)area_p->orun_p,
(unsigned char)kckma_custom.orun.magic) < 0) {
kckma_get_api_call_info(api_p, &api_name_p, &btrace_num, &btrace_addr_p);
kc_log_0ae(1, api_name_p, btrace_num, btrace_addr_p,
area_p->check_p->a_btrace_num, area_p->a_btrace_p,
"[KC][MAJ][KMA] buffer overrun area_p->umem_p, area_p->check_p->usize);
return -1;
}
return 0;
}

/*****************************************************************************
* 機能概要 ：獲得時のポイズニング
* 呼出形式 ：KCUC_INLINE static void
* ：kckma_set_a_poison(kckma_api_t *)
* 引数 ：kckma_api_t *api_p API情報
* 戻り値 ：なし
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_set_a_poison(kckma_api_t *api_p)
{
void *poison_p;
size_t poison_size;
unsigned long *current_p;
unsigned long *start_p;
unsigned long *end_p;

if (kckma_custom.a_poison.mode == KCUC_FILL_MODE_OFF) {
return;
}

poison_p = api_p->area.umem_p;
poison_size = api_p->check.usize;
if (kckma_custom.a_poison.mode == KCUC_FILL_MODE_MAGIC) {
memset(poison_p, kckma_custom.a_poison.magic, poison_size);
}
else {
start_p = (unsigned long *)kcuc_up_align(poison_p, KCKMA_ALIGN_PTR);
end_p = (unsigned long *)kcuc_down_align(poison_p + poison_size,
KCKMA_ALIGN_PTR);
for (current_p = start_p; current_p < end_p; current_p++) {
*current_p = ((unsigned long)current_p) + 1;
}
}
}

/*****************************************************************************
* 機能概要 ：解放時のポイズニング
* 呼出形式 ：KCUC_INLINE static void
* ：kckma_set_f_poison(kckma_api_t *)
* 引数 ：kckma_api_t *api_p API情報
* 戻り値 ：なし
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_set_f_poison(kckma_api_t *api_p)
{
void *poison_p;
size_t poison_size;
unsigned long *current_p;
unsigned long *start_p;
unsigned long *end_p;

if (kckma_custom.f_poison.mode == KCUC_FILL_MODE_OFF) {
return;
}

poison_p = api_p->area.umem_p;
poison_size = api_p->check.usize;
if (kckma_custom.f_poison.mode == KCUC_FILL_MODE_MAGIC) {
memset(poison_p, kckma_custom.f_poison.magic, poison_size);
}
else {
start_p = (unsigned long *)kcuc_up_align(poison_p, KCKMA_ALIGN_PTR);
end_p = (unsigned long *)kcuc_down_align(poison_p + poison_size,
KCKMA_ALIGN_PTR);
for (current_p = start_p; current_p < end_p; current_p++) {
*current_p = ((unsigned long)current_p) + 1;
}
}
}

/*****************************************************************************
* 機能概要 ：MMU利用判定コールバック関数の登録
* 呼出形式 ：void
* ：kckma_reg_mmu_cb(kckma_mmu_cb_t)
* 引数 ：kckma_mmu_cb_t func コールバック関数
* 戻り値 ：なし
* 機能詳細 ：
*****************************************************************************/
void
kckma_reg_mmu_cb(kckma_mmu_cb_t func)
{
kckma_mmu_cb_p = func;
}

/*****************************************************************************
* 機能概要 ：MMU利用対象の判定
* 呼出形式 ：KCUC_INLINE static void
* ：kckma_check_mmu_use(kckma_api_t *)
* 引数 ：kckma_api_t *api_p API情報
* 戻り値 ：なし
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_check_mmu_use(kckma_api_t *api_p)
{
kcuc_custom_mmu_t custom_mmu;
unsigned long mmu_minsize;
unsigned long mmu_maxsize;
int status;

custom_mmu = kckma_custom.mmu;

api_p->check.mmu_flag = 0;
if (custom_mmu.mode != KCUC_MMU_MODE_OFF && !(in_interrupt())) {/*<1100136>*/
/*<1100136>*/ /* if (custom_mmu.mode != KCUC_MMU_MODE_OFF) { */
mmu_minsize = kcuc_get_mmu_size(custom_mmu.minsize, custom_mmu.minattr);
mmu_maxsize = kcuc_get_mmu_size(custom_mmu.maxsize, custom_mmu.maxattr);
if (api_p->check.usize >= mmu_minsize && api_p->check.usize <= mmu_maxsize) {
if (custom_mmu.mode == KCUC_MMU_MODE_CB) {
if (kckma_mmu_cb_p) {
status = (*kckma_mmu_cb_p)();
if (status > 0) {
api_p->check.mmu_flag = 1;
}
}
}
else {
api_p->check.mmu_flag = 1;
}
}
}
}

/*****************************************************************************
* 機能概要 ：MMU対象のメモリ獲得
* 呼出形式 ：KCUC_INLINE static void
* ：kckma_mmu_alloc(kckma_api_t *)
* 引数 ：kckma_api_t *api_p API情報
* 戻り値 ：なし
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_mmu_alloc(kckma_api_t *api_p)
{
unsigned long page_offset;
unsigned long page_addr;
unsigned long page_size;
unsigned long save_flags;
kmem_cache_t *cache_p;

local_irq_save(save_flags);
kckma_mmu_flag = 1;

api_p->cmem_p = kckma_org_kmalloc(api_p->csize, api_p->flags);

if (api_p->cmem_p) {
page_offset = kc_get_page_offset(api_p->cmem_p);
page_addr = kc_get_page_addr(api_p->cmem_p);
cache_p = GET_PAGE_CACHE(virt_to_page(api_p->cmem_p));
page_size = kc_get_page_size(api_p->cmem_p, cache_p->objsize);
api_p->cmem_p = ioremap(__pa(page_addr), page_size);
if (!api_p->cmem_p) {
BUG();
}
api_p->cmem_p += page_offset;
}
kckma_mmu_flag = 0;
local_irq_restore(save_flags);
}

/*****************************************************************************
* 機能概要 ：MMU対象のメモリ開放
* 呼出形式 ：KCUC_INLINE static void
* ：kckma_mmu_free(kckma_api_t *)
* 引数 ：kckma_api_t *api_p API情報
* 戻り値 ：なし
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_mmu_free(kckma_api_t *api_p)
{
pgd_t *pgd_p;
pmd_t *pmd_p;
pte_t *pte_p;
unsigned long c_page_addr;
unsigned long page_offset;
unsigned long page_addr;
unsigned long page_size;

page_offset = kc_get_page_offset(api_p->cmem_p);
page_addr = kc_get_page_addr(api_p->cmem_p);
page_size = kc_get_page_size(api_p->cmem_p, api_p->csize);
for (c_page_addr = page_addr; c_page_addr < page_addr + page_size;
c_page_addr += PAGE_SIZE) {
pgd_p = pgd_offset_k(c_page_addr);
if (pgd_none(*pgd_p)) {
BUG();
}
pmd_p = pmd_offset(pgd_p, c_page_addr);
if (pmd_none(*pmd_p)) {
BUG();
}
pte_p = pte_offset(pmd_p, c_page_addr);
if (pte_none(*pte_p)) {
BUG();
}
set_pte(pte_p, pte_mkold(*pte_p));
}
flush_tlb_all();
api_p->cmem_p
= page_address(vmalloc_to_page((void *)page_addr)) + page_offset;

kckma_org_kfree(api_p->cmem_p);
}

/*****************************************************************************
* 機能概要 ：kmalloc事前処理
* 呼出形式 ：KCUC_INLINE static int
* ：kckma_pre_kmalloc(kckma_api_t *)
* 引数 ：kckma_api_t *api_p API情報
* 戻り値 ：== 1 メモリ獲得処理不要
* ：== 0 メモリ獲得処理必要
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static int
kckma_pre_kmalloc(kckma_api_t *api_p)
{
if (kckma_custom.all_alloc.flag) {
kckma_check_all_alloc(api_p);
}

kckma_set_a_check(api_p);
api_p->csize = kckma_usize2csize(api_p->check);
kckma_check_invalid_size(api_p);
kckma_check_invalid_flags(api_p);

return (api_p->check.mmu_flag) ? 1 : 0;
}

/*****************************************************************************
* 機能概要 ：kmalloc事後処理
* 呼出形式 ：KCUC_INLINE static void
* ：kckma_post_kmalloc(kckma_api_t *)
* 引数 ：kckma_api_t *api_p API情報
* 戻り値 ：なし
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_post_kmalloc(kckma_api_t *api_p)
{
if (api_p->check.mmu_flag) {
kckma_mmu_alloc(api_p);
}

if (!(api_p->cmem_p)) {
api_p->area.umem_p = NULL;
return;
}

kckma_get_memarea(&api_p->area, api_p->cmem_p, api_p->check);

*api_p->area.check_p = api_p->check;

memcpy(api_p->area.a_btrace_p, api_p->btrace.addr,
kckma_get_size_a_btrace(api_p->check));

kckma_set_urun(api_p);
kckma_set_orun(api_p);
kckma_add_hash(api_p);

kckma_set_a_poison(api_p);
}

/*****************************************************************************
* 機能概要 ：kfree事前処理
* 呼出形式 ：KCUC_INLINE static int
* ：kckma_pre_kfree(kckma_api_t *)
* 引数 ：kckma_api_t *api_p API情報
* 戻り値 ：== 1 メモリ解放処理不要
* ：== 0 メモリ解放処理必要
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static int
kckma_pre_kfree(kckma_api_t *api_p)
{
int status;

if (kckma_custom.all_alloc.flag) {
kckma_check_all_alloc(api_p);
}

if (!(api_p->area.umem_p)) {
api_p->cmem_p = NULL;
return 0;
}

status = kckma_del_hash_and_get_memarea(api_p);
if (status < 0) {
api_p->cmem_p = api_p->area.umem_p;
return 0;
}

api_p->check = *api_p->area.check_p;
api_p->cmem_p = kckma_umem2cmem(api_p->area.umem_p, api_p->check);
api_p->csize = kckma_usize2csize(api_p->check);

kckma_check_urun(api_p, &(api_p->area));
kckma_check_orun(api_p, &(api_p->area));
kckma_set_f_poison(api_p);

if (api_p->check.mmu_flag) {
kckma_mmu_free(api_p);
}

return (api_p->check.mmu_flag) ? 1 : 0;
}

/*****************************************************************************
* 機能概要 ：呼出履歴（入口）の設定
* 呼出形式 ：inline static void
* ：kckma_set_hist_kmalloc_in(pid_t, unsigned long, unsigned long, int,
* ： const void *)
* 引数 ：
* 戻り値 ：
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_set_hist_kmalloc_in(pid_t pid, unsigned long irq_flag,
unsigned long size, int flags, const void *caller_p)
{
kckma_hist_t *hist_rbuf_p;
unsigned long save_flags;

local_irq_save(save_flags);
kckma_hist_index = (kckma_hist_index + 1) & (KCKMA_HIST_SIZE - 1);
hist_rbuf_p = kckma_hist_rbuf + kckma_hist_index;
hist_rbuf_p->attr = kckma_join_hist_attr(irq_flag, KCKMA_API_KMALLOC,
KCKMA_IO_IN);
hist_rbuf_p->pid = pid;
hist_rbuf_p->size = size;
hist_rbuf_p->flags = flags;
hist_rbuf_p->caller_p = caller_p;
hist_rbuf_p->in_jiffies = jiffies;
local_irq_restore(save_flags);
}

/*****************************************************************************
* 機能概要 ：呼出履歴（入口）の設定
* 呼出形式 ：inline static void
* ：kckma_set_hist_in(pid_t, unsigned long, const void *,
* ： void *)
* 引数 ：
* 戻り値 ：
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_set_hist_kfree_in(pid_t pid, unsigned long irq_flag,
const void *caller_p, void *umem_p)
{
kckma_hist_t *hist_rbuf_p;
unsigned long save_flags;

local_irq_save(save_flags);
kckma_hist_index = (kckma_hist_index + 1) & (KCKMA_HIST_SIZE - 1);
hist_rbuf_p = kckma_hist_rbuf + kckma_hist_index;
hist_rbuf_p->attr = kckma_join_hist_attr(irq_flag, KCKMA_API_KFREE,
KCKMA_IO_IN);
hist_rbuf_p->pid = pid;
hist_rbuf_p->caller_p = caller_p;
hist_rbuf_p->umem_p = umem_p;
hist_rbuf_p->in_jiffies = jiffies;
local_irq_restore(save_flags);
}

/*****************************************************************************
* 機能概要 ：呼出履歴（出口）の設定
* 呼出形式 ：inline static void
* ：kckma_set_hist_kmalloc_out(pid_t, unsigned long, unsigned long,
* ： int, const void *, void *)
* 引数 ：
* 戻り値 ：
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_set_hist_kmalloc_out(pid_t pid, unsigned long irq_flag,
unsigned long size, int flags, const void *caller_p,
void *umem_p)
{
kckma_hist_t *hist_rbuf_p;
unsigned long save_flags;

local_irq_save(save_flags);
hist_rbuf_p = kckma_hist_rbuf + kckma_hist_index;
if (hist_rbuf_p->pid == pid) {
hist_rbuf_p->attr = kckma_join_hist_attr(irq_flag, KCKMA_API_KMALLOC,
KCKMA_IO_IN | KCKMA_IO_OUT);
}
else {
kckma_hist_index = (kckma_hist_index + 1) & (KCKMA_HIST_SIZE - 1);
hist_rbuf_p = kckma_hist_rbuf + kckma_hist_index;
hist_rbuf_p->attr = kckma_join_hist_attr(irq_flag, KCKMA_API_KMALLOC,
KCKMA_IO_OUT);
hist_rbuf_p->pid = pid;
hist_rbuf_p->size = size;
hist_rbuf_p->flags = flags;
hist_rbuf_p->caller_p = caller_p;
}
hist_rbuf_p->umem_p = umem_p;
hist_rbuf_p->out_jiffies = jiffies;
local_irq_restore(save_flags);
}

/*****************************************************************************
* 機能概要 ：呼出履歴（出口）の設定
* 呼出形式 ：inline static void
* ：kckma_set_hist_kfree_out(pid_t, unsigned long, unsigned long,
* ： int, const void *, void *)
* 引数 ：
* 戻り値 ：
* 機能詳細 ：
*****************************************************************************/
KCUC_INLINE static void
kckma_set_hist_kfree_out(pid_t pid, unsigned long irq_flag,
const void *caller_p, void *umem_p)
{
kckma_hist_t *hist_rbuf_p;
unsigned long save_flags;

local_irq_save(save_flags);
hist_rbuf_p = kckma_hist_rbuf + kckma_hist_index;
if (hist_rbuf_p->pid == pid) {
hist_rbuf_p->attr = kckma_join_hist_attr(irq_flag, KCKMA_API_KFREE,
KCKMA_IO_IN | KCKMA_IO_OUT);
}
else {
kckma_hist_index = (kckma_hist_index + 1) & (KCKMA_HIST_SIZE - 1);
hist_rbuf_p = kckma_hist_rbuf + kckma_hist_index;
hist_rbuf_p->attr = kckma_join_hist_attr(irq_flag, KCKMA_API_KFREE,
KCKMA_IO_OUT);
hist_rbuf_p->pid = pid;
hist_rbuf_p->caller_p = caller_p;
}
hist_rbuf_p->umem_p = umem_p;
hist_rbuf_p->out_jiffies = jiffies;
local_irq_restore(save_flags);
}

/*****************************************************************************
* 機能概要 ：全獲得領域の不正アクセスのチェック
* 呼出形式 ：void
* ：
* 引数 ：
* 戻り値 ：
* 機能詳細 ：
*****************************************************************************/
static void
kckma_check_all_alloc(kckma_api_t *api_p)
{
kckma_hash_t *hash_p;
kckma_memarea_t area;
const char *api_name_p;
int btrace_num;
kcuc_btrace_addr_t *btrace_addr_p;
int i;
static int check_disable_flag = 0;
static kcuc_btrace_t ok_btrace = {0};
unsigned long save_flags;
kckma_memarea_t *area_p; /*<1100193>*/

if (check_disable_flag) {
return;
}

local_irq_save(save_flags);

area_p = NULL; /*<1100193>*/
for (i = 0; i < KCKMA_HASH_SIZE; i++) {
for (hash_p = kckma_hash_tbl[i].next_p; hash_p; hash_p = hash_p->next_p) {
if (kckma_check_hash(api_p, hash_p, area_p) < 0) { /*<1100193>*/
/*<1100193>*//* if (kckma_check_hash(api_p, hash_p) < 0) { */
break;
}

kckma_hash2memarea(hash_p, &area);
area_p = &area; /*<1100193>*/

if (kckma_check_urun(api_p, &area) < 0) {
break;
}

if (kckma_check_orun(api_p, &area) < 0) {
break;
}
}
if (hash_p) {
break;
}
}
if (i < KCKMA_HASH_SIZE) {
check_disable_flag = 1;
}

if (api_p) {
if (check_disable_flag && ok_btrace.num) {
kckma_get_api_call_info(api_p, &api_name_p, &btrace_num, &btrace_addr_p);
kc_log_0ae(1, api_name_p, btrace_num, btrace_addr_p, ok_btrace.num,
ok_btrace.addr,
"[KC][IGN][KMA] API call that succeeded at the end }
else {
memcpy(ok_btrace.addr, api_p->btrace.addr,
sizeof(kcuc_btrace_addr_t) * api_p->btrace.num);
ok_btrace.num = api_p->btrace.num;
}
}
local_irq_restore(save_flags);
}

/*****************************************************************************
* 機能概要 ：Kmallocチェックツールの初期化
* 呼出形式 ：int
* ：kckma_init(void)
* 引数 ：なし
* 戻り値 ：== 0 正常
* ：== -1 異常
* 機能詳細 ：
*****************************************************************************/
int
kckma_init(void)
{
if (!kc_custom_check_btrace2(__KCKMA_CUSTOM_BTRACE_NUM__,
__KCKMA_CUSTOM_A_BTRACE_NUM__)) {
return -1;
}
if (!kc_custom_check_urun_magic(__KCKMA_CUSTOM_URUN_MAGIC__)) {
return -1;
}
if (!kc_custom_check_orun_magic(__KCKMA_CUSTOM_ORUN_MAGIC__)) {
return -1;
}
if (!kc_custom_check_a_poison_magic(__KCKMA_CUSTOM_A_POISON_MAGIC__)) {
return -1;
}
if (!kc_custom_check_f_poison_magic(__KCKMA_CUSTOM_F_POISON_MAGIC__)) {
return -1;
}
if (!kc_custom_check_mmu_size(__KCKMA_CUSTOM_MMU_MINSIZE__,
__KCKMA_CUSTOM_MMU_MAXSIZE__)) {
return -1;
}

kckma_custom.check_mode.mode = __KCKMA_CUSTOM_CHECK_MODE__;
kckma_custom.btrace.num = __KCKMA_CUSTOM_BTRACE_NUM__;
kckma_custom.btrace.a_num = __KCKMA_CUSTOM_A_BTRACE_NUM__;
kckma_custom.minsize.size = __KCKMA_CUSTOM_MINSIZE__;
kckma_custom.maxsize.size = __KCKMA_CUSTOM_MAXSIZE__;
kckma_custom.urun.mode = __KCKMA_CUSTOM_URUN_MODE__;
kckma_custom.urun.magic = __KCKMA_CUSTOM_URUN_MAGIC__;
kckma_custom.orun.mode = __KCKMA_CUSTOM_ORUN_MODE__;
kckma_custom.orun.magic = __KCKMA_CUSTOM_ORUN_MAGIC__;
kckma_custom.a_poison.mode = __KCKMA_CUSTOM_A_POISON_MODE__;
kckma_custom.a_poison.magic = __KCKMA_CUSTOM_A_POISON_MAGIC__;
kckma_custom.f_poison.mode = __KCKMA_CUSTOM_F_POISON_MODE__;
kckma_custom.f_poison.magic = __KCKMA_CUSTOM_F_POISON_MAGIC__;
kckma_custom.mmu.mode = __KCKMA_CUSTOM_MMU_MODE__;
kc_custom_mmu_minsize(__KCKMA_CUSTOM_MMU_MINSIZE__, kckma_custom.mmu);
kc_custom_mmu_maxsize(__KCKMA_CUSTOM_MMU_MAXSIZE__, kckma_custom.mmu);

kckma_leak_flag = 0;
kckma_mmu_flag = 0;
memset(kckma_hash_tbl, 0, sizeof(kckma_hash_tbl));

#ifdef KCKMA_DEBUG
kckma_debug_call_status.kmalloc = 0;
kckma_debug_call_status.kmalloc_a = 0;
kckma_debug_call_status.kfree = 0;
kckma_debug_call_status.kfree_f = 0;
#endif /* KCKMA_DEBUG */

return 0;
}

/*****************************************************************************
* 機能概要 ：Kmallocチェックツールのprocファイル生成
* 呼出形式 ：int
* ：kckma_cre_proc(void)
* 引数 ：なし
* 戻り値 ：== 0 正常
* ：== -1 異常
* 機能詳細 ：
*****************************************************************************/
int
kckma_cre_proc(void)
{
return kc_create_proc(KCKMA_PROC, kckma_proc_r, kckma_proc_w);
}

/*****************************************************************************
* 機能概要 ：procファイルの読み込み時処理
* 呼出形式 ：static int
* ：kckma_proc_r(char *, char **, off_t, int, int *, void *)
* 引数 ：char *buff_p
* ：char **start_pp
* ：off_t offset
* ：int buff_len
* ：int *eof_p
* ：void *data_p
* 戻り値 ：> 0 読み込み文字数（'\0'を含む）
* 機能詳細 ：
*****************************************************************************/
static int
kckma_proc_r(char *buff_p, char **start_pp, off_t offset, int buff_len,
int *eof_p, void *data_p)
{
int cnt;
size_t mmu_minsize;
size_t mmu_maxsize;

mmu_minsize = kcuc_get_mmu_size(kckma_custom.mmu.minsize,
kckma_custom.mmu.minattr);
mmu_maxsize = kcuc_get_mmu_size(kckma_custom.mmu.maxsize,
kckma_custom.mmu.maxattr);

cnt = 0;
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, "Version info\n");
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : %s\n",
"Kmalloc checktool",
KCKMA_VER);

cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, "Custom info\n");
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : %s\n", /*<1100190>*/
"Check mode", /*<1100190>*/
kc_str_check_mode_p[kckma_custom.check_mode.mode]); /*<1100190>*/
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : %1u\n",
"Number of backtrace steps",
kckma_custom.btrace.num);
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : %1u\n",
"Number of backtrace steps when alloc",
kckma_custom.btrace.a_num);
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : 0x%08x\n",
"Minimum size for alloc",
kckma_custom.minsize.size);
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : 0x%08x\n",
"Maximum size for alloc",
kckma_custom.maxsize.size);
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : %s\n",
"Check on all alloc area of API call",
kc_str_flag_p[kckma_custom.all_alloc.flag]);
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : %s\n",
"Underrun check mode",
kc_str_fill_mode_p[kckma_custom.urun.mode]);
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : 0x%02x\n",
"Magic number of underrun guard area",
kckma_custom.urun.magic);
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : %s\n",
"Overrun check mode",
kc_str_fill_mode_p[kckma_custom.orun.mode]);
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : 0x%02x\n",
"Magic number of overrrun guard area",
kckma_custom.orun.magic);
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : %s\n",
"Poisoning mode when alloc",
kc_str_fill_mode_p[kckma_custom.a_poison.mode]);
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : 0x%02x\n",
"Magic number of poisoning when alloc",
kckma_custom.a_poison.magic);
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : %s\n",
"Poisoning mode when free",
kc_str_fill_mode_p[kckma_custom.f_poison.mode]);
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : 0x%02x\n",
"Magic number of poisoning when free",
kckma_custom.f_poison.magic);
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : %s\n",
"MMU use mode",
kc_str_mmu_mode_p[kckma_custom.mmu.mode]);
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : 0x%08x\n",
"Minimum size for MMU use",
mmu_minsize);
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : 0x%08x\n",
"Maximum size for MMU use",
mmu_maxsize);

cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, "Status info\n");
cnt += kc_snprintf(buff_p + cnt, buff_len - cnt, " %-40s : %s\n",
"Leak status",
kc_str_leak_flag_p[kckma_leak_flag]);

*eof_p = 1; /*<1100135>*/
return cnt + 1;
}

/*****************************************************************************
* 機能概要 ：procファイルの書き込み時処理
* 呼出形式 ：static int
* ：kckma_proc_w(struct file *, const char *, unsigned long, void *)
* 引数 ：struct file *file_p
* ：const char *buff_p
* ：unsigned long count
* ：void *data_p
* 戻り値 ：>= 0 書き込み要求文字数
* 機能詳細 ：
*****************************************************************************/
static int
kckma_proc_w(struct file *file_p, const char *buff_p, unsigned long count,
void *data_p)
{
kc_cmd_t cmd;
int status;

status = kc_proc_cmd(buff_p, count, kckma_cmd_tbl, &cmd);
if (status == -1) {
kc_log_000("[KC][IGN][KMA] proc file operation error");
}
return count;
}

/*****************************************************************************
* 機能概要 ：startコマンド処理
* 呼出形式 ：static int
* ：kckma_cmd_start(kc_cmd_t *)
* 引数 ：kc_cmd_t *cmd_p コマンド解析結果
* 戻り値 ：== 0 正常
* 機能詳細 ：
*****************************************************************************/
static int
kckma_cmd_start(kc_cmd_t *cmd_p)
{
/*<1100168>*//* unsigned long save_flags; */

/*<1100168>*//* local_irq_save(save_flags); */
kckma_leak_flag = 1;
/*<1100168>*//* local_irq_restore(save_flags); */
return 0;
}

/*****************************************************************************
* 機能概要 ：stopコマンド処理
* 呼出形式 ：static int
* ：kckma_cmd_stop(kc_cmd_t *)
* 引数 ：kc_cmd_t *cmd_p コマンド解析結果
* 戻り値 ：== 0 正常
* 機能詳細 ：
*****************************************************************************/
static int
kckma_cmd_stop(kc_cmd_t *cmd_p)
{
unsigned long save_flags;
int leak_cnt; /*<1100192>*/
int leak_dsp_cnt; /*<1100192>*/
kc_leak_info_t *p; /*<1100192>*/

local_irq_save(save_flags);
if (kckma_leak_flag) {
kckma_leak_flag = 0;
leak_cnt = kckma_check_and_leak(kc_leak_buff); /*<1100192>*/
/*<1100192>*//* kckma_check_and_leak(1); */
local_irq_restore(save_flags); /*<1100192>*/
if (leak_cnt == 0) { /*<1100192>*/
kc_log_000("[KC][IGN][KMA] no leak"); /*<1100192>*/
} /*<1100192>*/
else if (leak_cnt > 0) { /*<1100192>*/
leak_dsp_cnt = (leak_cnt < KC_LEAK_BUFF_NUM) ? leak_cnt : KC_LEAK_BUFF_NUM; /*<1100192>*/
for (p = kc_leak_buff; p < kc_leak_buff + leak_dsp_cnt; p++) { /*<1100192>*/
kc_log_00e(1, p->a_btrace_num, p->a_btrace_p, /*<1100192>*/
"[KC][IGN][KMA] leak */
p->umem_p, p->usize); /*<1100192>*/
yield(); /*<1100191>*/
} /*<1100192>*/
if (leak_cnt > KC_LEAK_BUFF_NUM) { /*<1100192>*/
kc_log_000("[KC][IGN][KMA] leak continue"); /*<1100192>*/
} /*<1100192>*/
} /*<1100192>*/
}
else { /*<1100192>*/
local_irq_restore(save_flags); /*<1100192>*/
} /*<1100192>*/
/*<1100192>*//* local_irq_restore(save_flags); */
return 0;
}

/*****************************************************************************
* 機能概要 ：checkコマンド処理
* 呼出形式 ：static int
* ：kckma_cmd_check(kc_cmd_t *)
* 引数 ：kc_cmd_t *cmd_p コマンド解析結果
* 戻り値 ：== 0 正常
* 機能詳細 ：
*****************************************************************************/
static int
kckma_cmd_check(kc_cmd_t *cmd_p)
{
unsigned long save_flags;
int leak_cnt; /*<1100192>*/

local_irq_save(save_flags);
leak_cnt = kckma_check_and_leak(NULL); /*<1100192>*/
/*<1100192>*//* kckma_check_and_leak(0); */
local_irq_restore(save_flags);
if (leak_cnt >= 0) { /*<1100192>*/
kc_log_000("[KC][IGN][KMA] no illegal access"); /*<1100192>*/
} /*<1100192>*/
return 0;
}

/*****************************************************************************
* 機能概要 ：histコマンド処理
* 呼出形式 ：static int
* ：kckma_cmd_hist(kc_cmd_t *)
* 引数 ：kc_cmd_t *cmd_p コマンド解析結果
* 戻り値 ：== 0 正常
* 機能詳細 ：
*****************************************************************************/
static int
kckma_cmd_hist(kc_cmd_t *cmd_p)
{
kckma_hist_t *current_hist_rbuf_p;
static kckma_hist_t hist_rbuf[KCKMA_HIST_SIZE]; /*<1100169>*/
/*<1100169>*//* kckma_hist_t *hist_rbuf_p; */
int hist_index;
unsigned long api_id;
unsigned long save_flags;
int i;
unsigned long irq_flag;
unsigned long io_type;

/*<1100169>*//* hist_rbuf_p = kmalloc(sizeof(kckma_hist_rbuf), GFP_KERNEL); */
/*<1100169>*//* if (!hist_rbuf_p) { */
/*<1100169>*//* return -2; */
/*<1100169>*//* } */
local_irq_save(save_flags);
memcpy(hist_rbuf, kckma_hist_rbuf, sizeof(kckma_hist_rbuf)); /*<1100169>*/
/*<1100169>*//* memcpy(hist_rbuf_p, kckma_hist_rbuf, sizeof(kckma_hist_rbuf)); */
hist_index = kckma_hist_index;
local_irq_restore(save_flags);

for (i = 0; i < KCKMA_HIST_SIZE; i++) {
hist_index = (hist_index + 1) & (KCKMA_HIST_SIZE - 1);
current_hist_rbuf_p = hist_rbuf + hist_index; /*<1100169>*/
/*<1100169>*//* current_hist_rbuf_p = hist_rbuf_p + hist_index; */
kckma_sepa_hist_attr(current_hist_rbuf_p->attr, &irq_flag, &api_id, &io_type);
if (io_type & KCKMA_IO_IN) {
kc_log_000("[KC][IGN][KMA] hist ",
current_hist_rbuf_p->pid,
current_hist_rbuf_p->in_jiffies,
kckma_api_name_p[api_id],
kc_io_name_p[0],
irq_flag,
((api_id != KCKMA_API_KFREE) ? current_hist_rbuf_p->size : 0),
((api_id != KCKMA_API_KFREE) ? current_hist_rbuf_p->flags : 0),
((api_id == KCKMA_API_KFREE) ? current_hist_rbuf_p->umem_p : NULL),
current_hist_rbuf_p->caller_p);
}
if (io_type & KCKMA_IO_OUT) {
kc_log_000("[KC][IGN][KMA] hist ",
current_hist_rbuf_p->pid,
current_hist_rbuf_p->out_jiffies,
kckma_api_name_p[api_id],
kc_io_name_p[1],
irq_flag,
((api_id != KCKMA_API_KFREE) ? current_hist_rbuf_p->size : 0),
((api_id != KCKMA_API_KFREE) ? current_hist_rbuf_p->flags : 0),
((api_id != KCKMA_API_KFREE) ? current_hist_rbuf_p->umem_p : NULL),
current_hist_rbuf_p->caller_p);
}
yield(); /*<1100191>*/
}
/*<1100169>*//* kfree(hist_rbuf_p); */
return 0;
}

/*****************************************************************************
* 機能概要 ：off-hist / on-histコマンド処理
* 呼出形式 ：static int
* ：kckma_cmd_hist2(kc_cmd_t *)
* 引数 ：kc_cmd_t *cmd_p コマンド解析結果
* 戻り値 ：== 0 正常
* 機能詳細 ：
*****************************************************************************/
static int
kckma_cmd_hist2(kc_cmd_t *cmd_p)
{
kcuc_custom_mode_t custom_check_mode;

custom_check_mode = kckma_custom.check_mode;

switch (cmd_p->cmd_id) {
case KCKMA_CMD_ID_OFF_HIST:
if (custom_check_mode.mode != KCKMA_CHECK_MODE_HIST) {
return -1;
}
custom_check_mode.mode = KCKMA_CHECK_MODE_OFF;
break;
case KCKMA_CMD_ID_ON_HIST:
if (custom_check_mode.mode != KCKMA_CHECK_MODE_OFF) {
return -1;
}
custom_check_mode.mode = KCKMA_CHECK_MODE_HIST;
break;
default:
return -2;
}

kckma_custom.check_mode = custom_check_mode;
return 0;
}

/*****************************************************************************
* 機能概要 ：btraceコマンド処理
* 呼出形式 ：static int
* ：kckma_cmd_btrace(kc_cmd_t *)
* 引数 ：kc_cmd_t *cmd_p コマンド解析結果
* 戻り値 ：== 0 正常
* ：== -1 異常
* 機能詳細 ：
*****************************************************************************/
static int
kckma_cmd_btrace(kc_cmd_t *cmd_p)
{
kcuc_custom_btrace2_t custom_btrace;

custom_btrace = kckma_custom.btrace;

custom_btrace.num = cmd_p->para[0].i;
custom_btrace.a_num = cmd_p->para[1].i;
if (!kc_custom_check_btrace2(custom_btrace.num, custom_btrace.a_num)) {
return -1;
}

kckma_custom.btrace = custom_btrace;
return 0;
}

/*****************************************************************************
* 機能概要 ：minsizeコマンド処理
* 呼出形式 ：static int
* ：kckma_cmd_minsize(kc_cmd_t *)
* 引数 ：kc_cmd_t *cmd_p コマンド解析結果
* 戻り値 ：== 0 正常
* 機能詳細 ：
*****************************************************************************/
static int
kckma_cmd_minsize(kc_cmd_t *cmd_p)
{
kckma_custom.minsize.size = cmd_p->para[0].i;
return 0;
}

/*****************************************************************************
* 機能概要 ：maxsizeコマンド処理
* 呼出形式 ：static int
* ：kckma_cmd_maxsize(kc_cmd_t *)
* 引数 ：kc_cmd_t *cmd_p コマンド解析結果
* 戻り値 ：== 0 正常
* 機能詳細 ：
*****************************************************************************/
static int
kckma_cmd_maxsize(kc_cmd_t *cmd_p)
{
kckma_custom.maxsize.size = cmd_p->para[0].i;
return 0;
}

/*****************************************************************************
* 機能概要 ：off-allalloc / on-allallocコマンド処理
* 呼出形式 ：static int
* ：kckma_cmd_allalloc(kc_cmd_t *)
* 引数 ：kc_cmd_t *cmd_p コマンド解析結果
* 戻り値 ：== 0 正常
* ：== -2 異常 内部エラー
* 機能詳細 ：
*****************************************************************************/
static int
kckma_cmd_allalloc(kc_cmd_t *cmd_p)
{
switch (cmd_p->cmd_id) {
case KCKMA_CMD_ID_OFF_ALLALLOC:
kckma_custom.all_alloc.flag = 0;
break;
case KCKMA_CMD_ID_ON_ALLALLOC:
kckma_custom.all_alloc.flag = 1;
break;
default:
return -2;
}
return 0;
}

/*****************************************************************************
* 機能概要 ：off-urun / magic-urun / addr-urunコマンド処理
* 呼出形式 ：static int
* ：kckma_cmd_urun(kc_cmd_t *)
* 引数 ：kc_cmd_t *cmd_p コマンド解析結果
* 戻り値 ：== 0 正常
* ：== -2 異常 内部エラー
* 機能詳細 ：
*****************************************************************************/
static int
kckma_cmd_urun(kc_cmd_t *cmd_p)
{
kcuc_custom_fill_t custom_urun;

custom_urun = kckma_custom.urun;

switch (cmd_p->cmd_id) {
case KCKMA_CMD_ID_OFF_URUN:
custom_urun.mode = KCUC_FILL_MODE_OFF;
break;
case KCKMA_CMD_ID_MAGIC_URUN:
custom_urun.mode = KCUC_FILL_MODE_MAGIC;
break;
case KCKMA_CMD_ID_ADDR_URUN:
custom_urun.mode = KCUC_FILL_MODE_ADDR;
break;
default:
return -2;
break;
}

kckma_custom.urun = custom_urun;
return 0;
}

/*****************************************************************************
* 機能概要 ：off-orun / magic-orun / addr-orunコマンド処理
* 呼出形式 ：static int
* ：kckma_cmd_orun(kc_cmd_t *)
* 引数 ：kc_cmd_t *cmd_p コマンド解析結果
* 戻り値 ：== 0 正常
* ：== -2 異常 内部エラー
* 機能詳細 ：
*****************************************************************************/
static int
kckma_cmd_orun(kc_cmd_t *cmd_p)
{
kcuc_custom_fill_t custom_orun;

custom_orun = kckma_custom.orun;

switch (cmd_p->cmd_id) {
case KCKMA_CMD_ID_OFF_ORUN:
custom_orun.mode = KCUC_FILL_MODE_OFF;
break;
case KCKMA_CMD_ID_MAGIC_ORUN:
custom_orun.mode = KCUC_FILL_MODE_MAGIC;
break;
case KCKMA_CMD_ID_ADDR_ORUN:
custom_orun.mode = KCUC_FILL_MODE_ADDR;
break;
default:
return -2;
break;
}

kckma_custom.orun = custom_orun;
return 0;
}

/*****************************************************************************
* 機能概要 ：off-apoison / magic-apoison / addr-apoisonコマンド処理
* 呼出形式 ：static int
* ：kckma_cmd_apoison(kc_cmd_t *)
* 引数 ：kc_cmd_t *cmd_p コマンド解析結果
* 戻り値 ：== 0 正常
* ：== -1 異常 procファイル操作エラー
* ：== -2 異常 内部エラー
* 機能詳細 ：
*****************************************************************************/
static int
kckma_cmd_apoison(kc_cmd_t *cmd_p)
{
kcuc_custom_fill_t custom_a_poison;

custom_a_poison = kckma_custom.a_poison;

switch (cmd_p->cmd_id) {
case KCKMA_CMD_ID_OFF_APOISON:
custom_a_poison.mode = KCUC_FILL_MODE_OFF;
break;
case KCKMA_CMD_ID_MAGIC_APOISON:
custom_a_poison.mode = KCUC_FILL_MODE_MAGIC;
custom_a_poison.magic = cmd_p->para[0].i;
if (!kc_custom_check_a_poison_magic(custom_a_poison.magic)) {
return -1;
}
break;
case KCKMA_CMD_ID_ADDR_APOISON:
custom_a_poison.mode = KCUC_FILL_MODE_ADDR;
break;
default:
return -2;
break;
}

kckma_custom.a_poison = custom_a_poison;
return 0;
}

/*****************************************************************************
* 機能概要 ：off-fpoison / magic-fpoison / addr-fpoisonコマンド処理
* 呼出形式 ：static int
* ：kckma_cmd_fpoison(kc_cmd_t *)
* 引数 ：kc_cmd_t *cmd_p コマンド解析結果
* 戻り値 ：== 0 正常
* ：== -1 異常 procファイル操作エラー
* ：== -2 異常 内部エラー
* 機能詳細 ：
*****************************************************************************/
static int
kckma_cmd_fpoison(kc_cmd_t *cmd_p)
{
kcuc_custom_fill_t custom_f_poison;

custom_f_poison = kckma_custom.f_poison;

switch (cmd_p->cmd_id) {
case KCKMA_CMD_ID_OFF_FPOISON:
custom_f_poison.mode = KCUC_FILL_MODE_OFF;
break;
case KCKMA_CMD_ID_MAGIC_FPOISON:
custom_f_poison.mode = KCUC_FILL_MODE_MAGIC;
custom_f_poison.magic = cmd_p->para[0].i;
if (!kc_custom_check_f_poison_magic(custom_f_poison.magic)) {
return -1;
}
break;
case KCKMA_CMD_ID_ADDR_FPOISON:
custom_f_poison.mode = KCUC_FILL_MODE_ADDR;
break;
default:
return -2;
break;
}

kckma_custom.f_poison = custom_f_poison;
return 0;
}

/*****************************************************************************
* 機能概要 ：off-mmu / on-mmu / cb-mmuコマンド処理
* 呼出形式 ：static int
* ：kckma_cmd_on_mmu(kc_cmd_t *)
* 引数 ：kc_cmd_t *cmd_p コマンド解析結果
* 戻り値 ：== 0 正常
* ：== -1 異常 procファイル操作エラー
* ：== -2 異常 内部エラー
* 機能詳細 ：
*****************************************************************************/
static int
kckma_cmd_mmu(kc_cmd_t *cmd_p)
{
kcuc_custom_mmu_t custom_mmu;
size_t mmu_minsize;
size_t mmu_maxsize;

custom_mmu = kckma_custom.mmu;

switch (cmd_p->cmd_id) {
case KCKMA_CMD_ID_OFF_MMU:
custom_mmu.mode = KCUC_MMU_MODE_OFF;
break;
case KCKMA_CMD_ID_ON_MMU:
case KCKMA_CMD_ID_CB_MMU:
custom_mmu.mode = ((cmd_p->cmd_id == KCKMA_CMD_ID_ON_MMU)
? KCUC_MMU_MODE_ON : KCUC_MMU_MODE_CB);
mmu_minsize = cmd_p->para[0].i;
mmu_maxsize = cmd_p->para[1].i;
if (!kc_custom_check_mmu_size(mmu_minsize, mmu_maxsize)) {
return -1;
}
kc_custom_mmu_minsize(mmu_minsize, custom_mmu);
kc_custom_mmu_maxsize(mmu_maxsize, custom_mmu);
break;
default:
return -2;
break;
}

kckma_custom.mmu = custom_mmu;
return 0;
}

#ifdef KCKMA_DEBUG
/*****************************************************************************
* 機能概要 ：debug-all-callコマンド処理
* 呼出形式 ：static int
* ：kckma_debug_cmd_call(kc_cmd_t *)
* 引数 ：kc_cmd_t *cmd_p コマンド解析結果
* 戻り値 ：== 0 正常
* ：== -1 異常
* 機能詳細 ：
*****************************************************************************/
static int
kckma_debug_cmd_call(kc_cmd_t *cmd_p)
{
unsigned long save_flags;

local_irq_save(save_flags);
kc_log_000("[KC][IGN][KMA] debug call status ",
kckma_debug_call_status.kmalloc,
kckma_debug_call_status.kmalloc_a,
kckma_debug_call_status.kfree,
kckma_debug_call_status.kfree_f);
local_irq_restore(save_flags);

return 0;
}
#endif /* KCKMA_DEBUG */

/*****************************************************************************
* 機能概要 ：メモリ破壊チェックとメモリリーク検出
* 呼出形式 ：static void
* ：kckma_check_and_leak(kc_leak_info_t *)
* 引数 ：kc_leak_info_t *leak_buff_p リーク情報格納領域アドレス
* 戻り値 ：リーク検出数
* 機能詳細 ：
*****************************************************************************/
static int /*<1100192>*/
kckma_check_and_leak(kc_leak_info_t *leak_buff_p) /*<1100192>*/
/*<1100192>*//* static void */
/*<1100192>*//* kckma_check_and_leak(int leak_flag) */
{
kckma_hash_t *hash_p;
kckma_memarea_t area;
int leak_cnt; /*<1100192>*/
/*<1100192>*//* int leak_find_flag; */
int i;
kckma_memarea_t *area_p; /*<1100193>*/

leak_cnt = 0; /*<1100192>*/
/*<1100192>*//* leak_find_flag = 0; */
for (i = 0; i < KCKMA_HASH_SIZE; i++) {
area_p = NULL; /*<1100193>*/
hash_p = &kckma_hash_tbl[i];
for (hash_p = hash_p->next_p; hash_p; hash_p = hash_p->next_p) {
if (!(kcuc_check_align(hash_p, KCKMA_ALIGN_PTR))) {
if (area_p) { /*<1100193>*/
kc_log_00e(1, area.check_p->a_btrace_num, area.a_btrace_p, /*<1100193>*/
"[KC][MAJ][KMA] checktool info broken */
area.umem_p, area.check_p->usize); /*<1100193>*/
} /*<1100193>*/
else { /*<1100193>*/
kc_log_000("[KC][MAJ][KMA] checktool info broken {internal-hash_p:%p}", /*<1100193>*/
hash_p); /*<1100193>*/
} /*<1100193>*/
/*<1100193>*//* kc_log_000("[KC][MAJ][KMA] checktool info broken ", */
/*<1100193>*//* hash_p); */
return -1; /*<1100192>*/
/*<1100192>*//* return; */
}

kckma_hash2memarea(hash_p, &area);
area_p = &area; /*<1100193>*/

if (kckma_check_guard(area.check_p->urun_mode,
(unsigned char *)area.urun_p,
(unsigned char)kckma_custom.urun.magic) < 0) {
kc_log_00e(1, area.check_p->a_btrace_num, area.a_btrace_p,
"[KC][MAJ][KMA] buffer underrun area.umem_p, area.check_p->usize);
return -1; /*<1100192>*/
/*<1100192>*//* return; */
}
if (kckma_check_guard(area.check_p->orun_mode,
(unsigned char *)area.orun_p,
(unsigned char)kckma_custom.orun.magic) < 0) {
kc_log_00e(1, area.check_p->a_btrace_num, area.a_btrace_p,
"[KC][MAJ][KMA] buffer overrun area.umem_p, area.check_p->usize);
return -1; /*<1100192>*/
/*<1100192>*//* return; */
}

if (leak_buff_p && area.check_p->leak_flag) { /*<1100192>*/
/*<1100192>*//* if (leak_flag && area.check_p->leak_flag) { */
if (leak_cnt < KC_LEAK_BUFF_NUM) { /*<1100192>*/
(leak_buff_p + leak_cnt)->umem_p = area.umem_p; /*<1100192>*/
(leak_buff_p + leak_cnt)->usize = area.check_p->usize; /*<1100192>*/
(leak_buff_p + leak_cnt)->a_btrace_num = area.check_p->a_btrace_num; /*<1100192>*/
memcpy((leak_buff_p + leak_cnt)->a_btrace_p, area.a_btrace_p, /*<1100192>*/
sizeof(void *) * sizeof(KCUC_MAX_BTRACE_NUM)); /*<1100192>*/
} /*<1100192>*/
leak_cnt++; /*<1100192>*/
/*<1100192>*//* leak_find_flag = 1; */
area.check_p->leak_flag = 0;
/*<1100192>*//* kc_log_00e(1, area.check_p->a_btrace_num, area.a_btrace_p, */
/*<1100192>*//* "[KC][IGN][KMA] leak /*<1100192>*//* area.umem_p, area.check_p->usize); */
}
}
}
/*<1100192>*//* if (leak_flag) { */
/*<1100192>*//* if (!leak_find_flag) { */
/*<1100192>*//* kc_log_000("[KC][IGN][KMA] no leak"); */
/*<1100192>*//* } */
/*<1100192>*//* } */
/*<1100192>*//* else { */
/*<1100192>*//* kc_log_000("[KC][IGN][KMA] no illegal access"); */
/*<1100192>*//* } */
return leak_cnt; /*<1100192>*/
}

/*****************************************************************************
* 機能概要 ：kmallocラッパ関数
* 呼出形式 ：void *
* ：kmalloc(size_t, int)
* 引数 ：size_t usize
* ：int flags
* 戻り値 ：!= NULL 正常 獲得領域アドレス
* ：== NULL 異常
* 機能詳細 ：
*****************************************************************************/
void *
kmalloc(size_t usize, int flags)
{
kcuc_custom_btrace2_t custom_btrace;
kckma_api_t api;
const void *caller_p;
void *umem_p;
pid_t pid;
unsigned long irq_flag;

if (kckma_custom.check_mode.mode == KCKMA_CHECK_MODE_OFF) {
umem_p = kckma_org_kmalloc(usize, flags);
}
else {
caller_p = __builtin_return_address(0);
pid = current->pid;
irq_flag = (in_interrupt()) ? 1 : 0;
kckma_set_hist_kmalloc_in(pid, irq_flag, usize, flags, caller_p);
if (kckma_custom.check_mode.mode != KCKMA_CHECK_MODE_FULL) {
umem_p = kckma_org_kmalloc(usize, flags);
}
else {
custom_btrace = kckma_custom.btrace;
kc_get_btrace(&(api.btrace), custom_btrace.num, caller_p);
api.api_id = KCKMA_API_KMALLOC;
api.usize = usize;
api.check.a_btrace_num = custom_btrace.a_num;
api.flags = flags;
if (kckma_pre_kmalloc(&api) == 0) {
api.cmem_p = kckma_org_kmalloc(api.csize, flags);
}
kckma_post_kmalloc(&api);
umem_p = api.area.umem_p;
}
kckma_set_hist_kmalloc_out(pid, irq_flag, usize, flags, caller_p, umem_p);
}

#ifdef KCKMA_DEBUG
kckma_debug_call_status.kmalloc++;
if (umem_p) {
kckma_debug_call_status.kmalloc_a++;
}
#endif /* KCKMA_DEBUG */

return umem_p;
}

/*****************************************************************************
* 機能概要 ：kfreeラッパ関数
* 呼出形式 ：void
* ：kfree(void *)
* 引数 ：void *umem_p
* 戻り値 ：なし
* 機能詳細 ：
*****************************************************************************/
void
kfree(const void *umem_p)
{
kcuc_custom_btrace2_t custom_btrace;
kckma_api_t api;
const void *caller_p;
pid_t pid;
int irq_flag;

if (kckma_custom.check_mode.mode == KCKMA_CHECK_MODE_OFF) {
kckma_org_kfree(umem_p);
}
else {
caller_p = __builtin_return_address(0);
pid = current->pid;
irq_flag = (in_interrupt()) ? 1 : 0;
kckma_set_hist_kfree_in(pid, irq_flag, caller_p, (void *)umem_p);
if (kckma_custom.check_mode.mode != KCKMA_CHECK_MODE_FULL) {
kckma_org_kfree(umem_p);
}
else {
custom_btrace = kckma_custom.btrace;
kc_get_btrace(&(api.btrace), custom_btrace.num, caller_p);
api.api_id = KCKMA_API_KFREE;
api.area.umem_p = (void *)umem_p;
if (kckma_pre_kfree(&api) == 0) {
kckma_org_kfree(api.cmem_p);
}
}
kckma_set_hist_kfree_out(pid, irq_flag, caller_p, (void *)umem_p);
}

#ifdef KCKMA_DEBUG
kckma_debug_call_status.kfree++;
if (umem_p) {
kckma_debug_call_status.kfree_f++;
}
#endif /* KCKMA_DEBUG */
}

/*****************************************************************************
* 機能概要 ：全獲得領域の不正アクセスのチェック（チェック用API関数）
* 呼出形式 ：void
* ：kckma_check_all(void)
* 引数 ：なし
* 戻り値 ：なし
* 機能詳細 ：
*****************************************************************************/
void
kckma_check_all(void)
{
kckma_check_all_alloc(NULL);
}

#endif /* __KERNEL_CHECK__ && __KC_KMALLOC__ */
/* kmalloc check tool end */