Test "fix: Bug for getrusage" on arm64

The following test set:
  fix: Bug for getrusage return incorrect ru_maxrss
  fix: Bug for getrusage(RUSAGE_CHILDREN) return parent info (POSTK_DEBUG_TEMP_FIX_72)
  fix: Bug for getrusage often return incorrect ru_stime

Change-Id: I6734b1e34565d5d2715f9901a04ba5b6f0278032
Refs: #1032
Refs: #1033
Refs: #1034

test/mng_mod/issues/1032-34/arm64/Makefile

@@ -0,0 +1,53 @@
+# Makefile COPYRIGHT FUJITSU LIMITED 2018
+CC = gcc
+obj-m += test_driver.o
+
+KERN_DIR=/usr/src/kernels/`uname -r`/
+
+TARGET=modules CT_001 CT_002 CT_003 CT_004 CT_005 CT_006 CT_007 CT_008 CT_009 CT_010
+
+CPPFLAGS = 
+LDFLAGS = 
+
+
+all: $(TARGET)
+
+modules:
+	$(MAKE) -C $(KERN_DIR) M=$(PWD) modules
+
+CT_001: CT_001.c
+	$(CC) -o $@ $^ $(LDFLAGS)
+
+CT_002: CT_002.c
+	$(CC) -o $@ $^ $(LDFLAGS)
+
+CT_003: CT_003.c
+	$(CC) -o $@ $^ $(LDFLAGS) -pthread
+
+CT_004: CT_004.c
+	$(CC) -o $@ $^ $(LDFLAGS) -pthread
+
+CT_005: CT_005.c
+	$(CC) -o $@ $^ $(LDFLAGS)
+
+CT_006: CT_006.c
+	$(CC) -o $@ $^ $(LDFLAGS)
+
+CT_007: CT_007.c
+	$(CC) -o $@ $^ $(LDFLAGS)
+
+CT_008: CT_008.c
+	$(CC) -o $@ $^ $(LDFLAGS)
+
+CT_009: CT_009.c
+	$(CC) -o $@ $^ $(LDFLAGS) -pthread
+
+CT_010: CT_010.c
+	$(CC) -o $@ $^ $(LDFLAGS) -pthread
+
+test: all
+	./run.sh
+
+clean:
+	rm -f $(TARGET) *.o 
+	$(MAKE) -C $(KERN_DIR) M=$(PWD) clean

test/mng_mod/issues/1032-34/arm64/README

@@ -0,0 +1,229 @@
+/* README COPYRIGHT FUJITSU LIMITED 2018 */
+
+getrusage()の最大メモリ消費量および時間計測機能テストセットREADME
+
+(1) テストの実行方法
+ 以下の手順でテストを実行する
+	1. $HOME/.mck_test_configを用意する
+	   当該ファイルは、McKernelをビルドした際に生成されるmck_test_config.sample ファイルを
+	   $HOMEにコピーし、適宜編集する
+
+	2. Makefileの変数KERN_DIRの内容を、必要に応じてカーネルソースのあるディレクトリに変更する
+	   デフォルトでは/usr/src/kernels/`uname -r`/を設定
+
+	3. make test を実行する
+
+(2) テスト項目詳細
+1. 下記Issueで報告されたテストプログラムによる確認
+	Issue#1032 (https://postpeta.pccluster.org/redmine/issues/1032)
+	Issue#1033 (https://postpeta.pccluster.org/redmine/issues/1033)
+	Issue#1034 (https://postpeta.pccluster.org/redmine/issues/1034)
+
+ISSUE01
+	getrusage(RUSAGE_SELF)で正しい情報が取得できること
+	ru_utime,ru_stime,ru_maxrssについて、それぞれ以下の近似値が
+	取得出来る事を確認する
+		ru_utime ：2秒 程度
+		ru_stime ：2秒 程度
+		ru_maxrss：22MiB 程度
+
+ISSUE02
+	getrusage(RUSAGE_CHILDREN)で正しい情報が取得できること
+	ru_utime,ru_stime,ru_maxrssについて、それぞれ以下の近似値が
+	取得出来る事を確認する
+		ru_utime ：2秒 程度
+		ru_stime ：2秒 程度
+		ru_maxrss：22MiB 程度
+
+ISSUE03
+	getrusage(RUSAGE_THREAD)で正しい情報が取得できること
+	ru_utime,ru_stime,ru_maxrssについて、それぞれ以下の近似値が
+	取得出来る事を確認する
+		ru_utime ：2秒 程度
+		ru_stime ：4秒 程度
+		ru_maxrss：30MiB 程度
+
+
+2. McKernelでのgetrusage()の基本動作確認
+
+CT_001: 単一プロセスでのRUSAGE_SELFの utime, stime計測動作
+  観点：自プロセスのutime, stime計測を確認する
+	1. getrusage(RUSAGE_SELF) を実行し、以下を確認
+	  - utimeの値が  0 < utime < 0.1 (秒)
+	  - stimeの値が  0 < stime < 0.1 (秒)
+	2. 2秒程度かかる処理をユーザモードで実行 
+	3. getrusage(RUSAGE_SELF) を実行し、以下を確認
+	  - utimeの増分が  2秒程度
+	  - stimeの増分が  0.1秒未満
+	4. 1秒程度かかる処理をカーネルモードで実行 
+	  - utimeの増分が  0.1秒未満
+	  - stimeの増分が  1秒程度
+
+CT_002: 単一プロセスでのRUSAGE_SELF のmaxrss計測
+  観点：自プロセスのmaxrss計測を確認する
+	1. getrusage(RUSAGE_SELF) を実行し、以下を確認
+	  - maxrssの値が 0より大きい
+	2. mmap()で12Mバイトの領域を確保し、全体に書き込み処理を実施
+	3. getrusage(RUSAGE_SELF) を実行し、以下を確認
+	  - maxrssの値が  12Mバイト以上
+	4. 確保した領域(12Mバイト)をmunmap()で解放
+	5. getrusage(RUSAGE_SELF) を実行し、以下を確認
+	  - maxrssの値が  前回と同じ
+	6. mmap()で16Mバイトの領域を確保し、全体に書き込み処理を実施
+	7. getrusage(RUSAGE_SELF) を実行し、以下を確認
+	  - maxrssの増分が  4Mバイト程度
+	8. 確保した領域(16Mバイト)をmunmap()で解放
+
+CT_003: サブスレッド作成時のRUSAGE_SELF のutime, stime計測
+  観点：サブスレッドの動作がutime, stimeに加算されることを確認する
+	1. getrusage(RUSAGE_SELF) を実行し、以下を確認
+	  - utimeの値が  0 < utime < 0.1 (秒)
+	  - stimeの値が  0 < stime < 0.1 (秒)
+	2. pthread_create()でサブスレッドを作成する
+	3. メインスレッドが、pthread_join()でサブスレッドの終了を待つ
+	  3.1. サブスレッドが、2秒程度かかる処理をユーザモードで実行 
+	  3.2. サブスレッドが、1秒程度かかる処理をカーネルモードで実行 
+	  3.3. サブスレッドが、終了する
+	4. メインスレッドがgetrusage(RUSAGE_SELF) を実行し、以下を確認
+	  - utimeの増分が  2秒程度 (サブスレッド増分2秒)
+	  - stimeの増分が  4秒程度 (サブスレッド増分1秒、メインスレッドjoin待ち3秒)
+   ※ Linuxではjoin待ち中は他タスクへとスイッチされてシステム時間が加算されないため、
+     Linuxでの実行時、本項目はFAILとなる
+    
+CT_004: サブスレッド作成時のRUSAGE_SELF のmaxrss計測
+  観点：サブスレッドの動作がmaxrssに加算されることを確認する
+	1. getrusage(RUSAGE_SELF) を実行し、以下を確認
+	  - maxrssの値が 0より大きい
+	2. pthread_create()でサブスレッドを作成する
+	3. メインスレッドが、pthread_join()でサブスレッドの終了を待つ
+	  3.1. サブスレッドが、mmap()で16Mバイトの領域を確保し、全体に書き込み処理を実施
+	  3.2. サブスレッドが、確保した領域(16Mバイト)をmunmap()で解放
+	  3.3. サブスレッドが、終了する
+	4. メインスレッドがgetrusage(RUSAGE_SELF) を実行し、以下を確認
+	  - maxrssの値が  16Mバイト以上
+
+CT_005: 子プロセス作成時のRUSAGE_SELF のutime, stime, maxrss計測
+  観点：子プロセスのutime, stime, maxrssが加算されないことを確認する
+	1. getrusage(RUSAGE_SELF) を実行し、以下を確認
+	  - utimeの値が  0 < utime < 0.1 (秒)
+	  - stimeの値が  0 < stime < 0.1 (秒)
+	  - maxrssの値が 0より大きい
+	2. fork()で子プロセスを作成する
+	3. 親プロセスが、3秒程度かかる処理をユーザモードで実行
+	  3.1. 子プロセスが、1秒程度かかる処理をユーザモードで実行
+	  3.2. 子プロセスが、1秒程度かかる処理をカーネルモードで実行
+	  3.3. 子プロセスが、16Mバイトの領域の確保、書き込み、解放処理を実施
+	  3.4. 子プロセスが終了する
+	4. 親プロセスがwaitpid()で子プロセスの終了を回収する
+	5. getrusage(RUSAGE_SELF) を実行し、以下を確認
+	  - utimeの増分が  3秒程度
+	  - stimeの増分が  0.1秒未満
+	  - maxrssの値が 16Mバイト未満
+
+CT_006: 子プロセス作成時のRUSAGE_CHILDREN のutime, stime計測
+  観点：子プロセスのutime, stimeのみが計測されていることを確認する
+	1. getrusage(RUSAGE_CHILDREN) を実行し、以下を確認
+	  - utimeの値が  0 
+	  - stimeの値が  0 
+	2. fork()で子プロセスを作成する
+	3. 親プロセスが、1秒程度かかる処理をユーザモードで実行
+	  3.1. 子プロセスが、2秒程度かかる処理をユーザモードで実行
+	4. 親プロセスがgetrusage(RUSAGE_CHILDREN)を実行し、以下を確認
+	  - utimeの値が  0 (子プロセスがまだ終了していないため)
+	  - stimeの値が  0 
+	5. 親プロセスがwaitpid()で子プロセスの終了を待つ
+	  5.1. 子プロセスが、1秒程度かかる処理をカーネルモードで実行
+	  5.2. 子プロセスが終了する
+	6. 親プロセスがgetrusage(RUSAGE_CHILDREN)を実行し、以下を確認
+	  - utimeの増分が  2秒程度
+	  - stimeの増分が  1秒程度
+
+CT_007: 子プロセス作成時のRUSAGE_CHILDREN のmaxrss計測
+  観点：子プロセスのmaxrssのみが計測されていることを確認する
+	1. getrusage(RUSAGE_CHILDREN) を実行し、以下を確認
+	  - maxrssの値が 0
+	2. fork()で子プロセスを作成する
+	3. 親プロセスが、32Mバイトの領域の確保、書き込み、解放処理を実施
+	4. 親プロセスがwaitpid()で子プロセスの終了を待つ
+	  4.1. 子プロセスが、1秒程度かかる処理をユーザモードで実行
+	  4.2. 子プロセスが、16Mバイトの領域の確保、書き込み、解放処理を実施
+	  4.3. 子プロセスが終了する
+	5. 親プロセスがgetrusage(RUSAGE_CHILDREN)を実行し、以下を確認
+	  - maxrssの値が 16 < maxrss < 32 (MB)
+
+CT_008: 孫プロセス作成時のRUSAGE_CHILDREN のutime, stime, maxrss計測
+  観点：子プロセス、孫プロセスの使用資源が計測されることを確認する
+	1. getrusage(RUSAGE_SELF) を実行し、以下を確認
+	  - utimeの値が  0
+	  - stimeの値が  0
+	  - maxrssの値が 0
+	2. fork()で子プロセスを作成し、waitpidで子プロセスの終了を待つ
+	  2.1. 子プロセスが、fork()で孫プロセスを作成する
+	  2.2. 子プロセスが、ユーザモード処理2秒、カーネルモード処理1秒 を実施
+	  2.3. 子プロセスが、8Mバイトの領域の確保、書き込み、開放処理を実施
+	  2.4. 子プロセスが、waitpid()で孫プロセスの終了を待つ
+	    2.4.1. 孫プロセスが、ユーザモード処理1秒、カーネルモード処理1秒 を実施
+	    2.4.2. 孫プロセスが、32Mバイトの領域の確保、書き込み、開放処理を実施
+	    2.4.3. 孫プロセスが終了する
+	  2.5. 子プロセスが終了する
+	3. 親プロセスがgetrusage(RUSAGE_CHILDREN)を実行し、以下を確認
+	  - utimeの値が 3秒程度 (子2秒、孫1秒の和)
+	  - stimeの値が 2秒程度 (子1秒、孫1秒の和)
+	  - maxrssの値が 32 < maxrss < 40 (MB) (子、孫のmaxrssの最大値)
+
+CT_009: サブスレッド作成時のRUSAGE_THREAD のutime, stime計測
+  観点：複数のスレッドでそれぞれのutime, stimeが計測されることを確認する
+	1. getrusage(RUSAGE_THREAD) を実行し、以下を確認
+	  - utimeの値が  0 < utime < 0.1 (秒)
+	  - stimeの値が  0 < stime < 0.1 (秒)
+	2. 1秒程度かかる処理をユーザモードで実行 
+	3. pthread_create()でサブスレッドを作成する
+	4. メインスレッドが、pthread_join()でサブスレッドの終了を待つ
+	  4.1. サブスレッドがgetrusage(RUSAGE_THREAD) を実行し、以下を確認
+         - utimeの値が 0 < utime 0.1 (秒)
+         - stimeの値が 0 < stime 0.1 (秒)
+	  4.2. サブスレッドが、2秒程度かかる処理をユーザモードで実行 
+	  4.3. サブスレッドが、1秒程度かかる処理をカーネルモードで実行 
+	  4.4. サブスレッドがgetrusage(RUSAGE_THREAD) を実行し、以下を確認
+         - utimeの増分が 2秒程度
+         - stimeの増分が 1秒程度
+	  4.4. サブスレッドが、終了する
+	5. メインスレッドがgetrusage(RUSAGE_THREAD) を実行し、以下を確認
+	  - utimeの増分が  1秒程度
+	  - stimeの増分が  3秒程度 (join待ち3秒)
+   ※ Linuxではjoin待ち中は他タスクへとスイッチされてシステム時間が加算されないため、
+     Linuxでの実行時、本項目はFAILとなる
+
+CT_010: サブスレッド作成時のRUSAGE_THREAD のmaxrss計測
+  観点：複数のスレッドで、プロセス全体のmaxrssが取得されることを確認する
+	1. getrusage(RUSAGE_THREAD) を実行し、以下を確認
+      - maxrssの値が 0より大きい
+	2. 8Mバイトの領域の確保、書き込み、解放処理を実施
+	3. pthread_create()でサブスレッドを作成し、pthread_join()でサブスレッドの終了を待つ
+	  3.1. サブスレッドがgetrusage(RUSAGE_THREAD) を実行し、以下を確認
+         - maxrssの値が 8MB 以上
+	  3.2. サブスレッドが16Mバイトの領域の確保、書き込み、解放処理を実施
+	  3.3. サブスレッドが終了する
+	4. メインスレッドがgetrusage(RUSAGE_THREAD) を実行し、以下を確認
+         - maxrssの値が 16MB 以上
+
+(3) 実行結果ログ
+	result.logファイル内に実行時のログを記載する。
+	実行に利用したIHK/McKernelは、IA版における下記の版数相当の
+	arm64版移植IHK/McKernelである。
+
+	IHK
+		commit d6fcbee8cb91f9ec4b49f97c918e696ac0335aaf
+		Author: Shiratori, Takehiro <fj0300es@aa.jp.fujitsu.com>
+		Date:   Tue Oct 16 16:25:33 2018 +0900
+
+	McKernel
+		commit 6f9fef2b13447c74c36d15cf5ebd186f8395ccca
+		Author: Ken Sato <ken.sato.ty@hitachi-solutions.com>
+		Date:   Tue Sep 25 10:05:41 2018 +0900
+
+(4) 備考
+	特になし。
+
+
+以上。

test/mng_mod/issues/1032-34/arm64/result.log

@@ -0,0 +1,47 @@
+make -C /root/ihk_mckernel/kernel M=/opt/repo/mckernel/test/mng_mod/issues/1032-34/arm64 modules
+make[1]: ディレクトリ `/root/ihk_mckernel/kernel' に入ります
+  CC [M]  /opt/repo/mckernel/test/mng_mod/issues/1032-34/arm64/test_driver.o
+  Building modules, stage 2.
+  MODPOST 1 modules
+  CC      /opt/repo/mckernel/test/mng_mod/issues/1032-34/arm64/test_driver.mod.o
+  LD [M]  /opt/repo/mckernel/test/mng_mod/issues/1032-34/arm64/test_driver.ko
+make[1]: ディレクトリ `/root/ihk_mckernel/kernel' から出ます
+gcc -o CT_001 CT_001.c 
+gcc -o CT_002 CT_002.c 
+gcc -o CT_003 CT_003.c  -pthread
+gcc -o CT_004 CT_004.c  -pthread
+gcc -o CT_005 CT_005.c 
+gcc -o CT_006 CT_006.c 
+gcc -o CT_007 CT_007.c 
+gcc -o CT_008 CT_008.c 
+gcc -o CT_009 CT_009.c  -pthread
+gcc -o CT_010 CT_010.c  -pthread
+./run.sh
+mcstop+release.sh ... done
+mcreboot.sh -c 4-15 -m 1G@0,1G@1,1G@2,1G@3 -O ... done
+ISSUE01 n=100/100 ok.
+ISSUE01: OK
+ISSUE02 n=100/100 ok.
+ISSUE02: OK
+ISSUE03 n=100/100 ok.
+ISSUE03: OK
+CT_001 n=100/100 ok.
+CT_001: OK
+CT_002 n=100/100 ok.
+CT_002: OK
+CT_003 n=100/100 ok.
+CT_003: OK
+CT_004 n=100/100 ok.
+CT_004: OK
+CT_005 n=100/100 ok.
+CT_005: OK
+CT_006 n=100/100 ok.
+CT_006: OK
+CT_007 n=100/100 ok.
+CT_007: OK
+CT_008 n=100/100 ok.
+CT_008: OK
+CT_009 n=100/100 ok.
+CT_009: OK
+CT_010 n=100/100 ok.
+CT_010: OK

test/mng_mod/issues/1032-34/arm64/run.sh

@@ -0,0 +1,109 @@
+#!/bin/sh
+## run.sh COPYRIGHT FUJITSU LIMITED 2018 ##
+
+USELTP=0
+USEOSTEST=1
+
+. ../../../../common.sh
+
+result=0
+loop_count=100
+
+#######################
+## get_rusgae() test ##
+#######################
+
+exp_min_utime=(1900000 1900000 1900000)
+exp_max_utime=(2100000 2100000 2100000)
+exp_min_stime=(1900000 1900000 3900000)
+exp_max_stime=(2100000 2100000 4100000)
+utime_line=("5p" "5p" "12p")
+exp_min_maxrss=(16896 18944 25088)
+exp_max_maxrss=(18944 20992 27136)
+
+for tp_num in `seq 0 2`
+do
+	p_tp_num=`expr ${tp_num} + 1`
+	tp_result=0
+	for i in `seq -f %03g 1 ${loop_count}`
+	do
+		output=`${MCEXEC} ${TESTMCK} -s getrusage -n ${tp_num}`
+		utime=`echo "${output}" | tac | sed -n ${utime_line[${tp_num}]} | cut -c 12-`
+		utime_s=`echo "${utime}" | cut -d ' ' -f 1 | sed -e 's/[^0-9]//g'`
+		utime_us=`echo "${utime}" | cut -d ' ' -f 3 | sed -e 's/[^0-9]//g'`
+		utime_us=`expr ${utime_s} \* 1000000 + ${utime_us}`
+		if [ ${utime_us} -lt ${exp_min_utime[${tp_num}]} \
+			-o ${exp_max_utime[${tp_num}]} -lt ${utime_us} ]; then
+			tp_result=-1
+			echo ""
+			echo "ISSUE0${p_tp_num} n=${i}/${loop_count} utime ng."
+			echo "${output}"
+		fi
+
+		stime=`echo "${output}" | tac | sed -n 4p | cut -c 12-`
+		stime_s=`echo "${stime}" | cut -d ' ' -f 1 | sed -e 's/[^0-9]//g'`
+		stime_us=`echo "${stime}" | cut -d ' ' -f 3 | sed -e 's/[^0-9]//g'`
+		stime_us=`expr ${stime_s} \* 1000000 + ${stime_us}`
+		if [ ${stime_us} -lt ${exp_min_stime[${tp_num}]} \
+			-o ${exp_max_stime[${tp_num}]} -lt ${stime_us} ]; then
+			tp_result=-1
+			echo ""
+			echo "ISSUE0${p_tp_num} n=${i}/${loop_count} stime ng."
+			echo "${output}"
+		fi
+
+		maxrss=`echo "${output}" | tac | sed -n 3p | cut -c 13-`
+		if [ ${maxrss} -lt ${exp_min_maxrss[${tp_num}]} \
+			-o ${exp_max_maxrss[${tp_num}]} -lt ${maxrss} ]; then
+			tp_result=-1
+			echo ""
+			echo "ISSUE0${p_tp_num} n=${i}/${loop_count} maxrss ng."
+		fi
+
+		if [ ${tp_result} != 0 ]; then
+			echo "${output}"
+			break
+		fi
+
+		echo -en "ISSUE0${p_tp_num} n=${i}/${loop_count} ok.\r"
+	done
+
+	echo ""
+	if [ ${tp_result} == 0 ]; then
+		echo "ISSUE0${p_tp_num}: OK"
+	else
+		echo "ISSUE0${p_tp_num}: NG"
+		result=-1
+	fi
+done
+
+./ins_test_driver.sh
+
+for tp_num in `seq -f %03g 001 010`
+do
+	tp_result=0
+	for i in `seq -f %03g 1 ${loop_count}`
+	do
+		output=`${MCEXEC} ./CT_${tp_num} 2>&1`
+		if [ $? != 0 ]; then
+			tp_result=-1
+			echo ""
+			echo "CT_${tp_num} n=${i}/${loop_count} ng."
+			echo "${output}"
+			break
+		fi
+		echo -en "CT_${tp_num} n=${i}/${loop_count} ok.\r"
+	done
+
+	echo ""
+	if [ ${tp_result} == 0 ]; then
+		echo "CT_${tp_num}: OK"
+	else
+		echo "CT_${tp_num}: NG"
+		result=-1
+	fi
+done
+
+./rm_test_driver.sh
+
+exit ${result}

test/mng_mod/issues/1032-34/arm64/test_rusage.h

@@ -0,0 +1,92 @@
+#ifndef __TEST_RUSAGE_H__
+#define __TEST_RUSAGE_H__
+
+#include <stdio.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/resource.h>
+#include <errno.h>
+#include <signal.h>
+
+#define ONE_SEC 1000000
+#define M_BYTE 1024 * 1024
+
+#ifdef __x86_64__
+#define cpu_pause()                     \
+	({                          \
+		__asm__ __volatile__("pause" ::: "memory"); \
+	})
+#elif defined(__aarch64__)
+#define cpu_pause()						\
+	({							\
+		__asm__ __volatile__("yield" ::: "memory");	\
+	})
+#else
+#error "cpu_pause() not implemented."
+#endif
+
+int sig_count;
+
+long get_rusage_utime(struct rusage *usage)
+{
+	if (!usage) {
+		return -1;
+	}
+
+	return (usage->ru_utime.tv_sec * ONE_SEC) + usage->ru_utime.tv_usec;
+}
+
+long get_rusage_stime(struct rusage *usage)
+{
+	if (!usage) {
+		return -1;
+	}
+
+	return (usage->ru_stime.tv_sec * ONE_SEC) + usage->ru_stime.tv_usec;
+}
+
+long get_rusage_maxrss(struct rusage *usage)
+{
+	if (!usage) {
+		return -1;
+	}
+
+	return usage->ru_maxrss;
+}
+
+void alrm_handler(int sig)
+{
+	sig_count = 1;
+}
+
+void add_utime(int sec)
+{
+	int rc;
+	struct sigaction sa;
+
+	/* flag clear */
+	sig_count = 0;
+	
+	/* set sighandler */
+	sa.sa_handler = alrm_handler;
+	rc = sigaction(SIGALRM, &sa, NULL);
+
+	alarm(sec);
+
+	while (!sig_count) {
+		cpu_pause();
+	}
+}
+
+void add_stime(int sec)
+{
+	int fd;
+
+	fd = open("/dev/test_rusage", O_RDWR);
+	ioctl(fd, sec, NULL);
+	close(fd);
+}
+
+#endif /*__TEST_RUSAGE_H__*/

test/mng_mod/issues/1032-34/x86_64/CT_001.c

@@ -0,0 +1,97 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "./test_chk.h"
+#include "./test_rusage.h"
+
+#define TEST_NAME "CT_001"
+
+int main(int argc, char* argv[])
+{
+	int rc;
+	struct rusage cur_rusage;
+	long cur_utime, cur_stime;
+	long delta_utime, delta_stime;
+	long prev_utime = 0, prev_stime = 0;
+
+	printf("----  just started ----\n");
+	/* check rusage 1st */
+	rc = getrusage(RUSAGE_SELF, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 1st");
+
+	cur_utime = get_rusage_utime(&cur_rusage);
+	cur_stime = get_rusage_stime(&cur_rusage);
+	delta_utime = cur_utime - prev_utime;
+	delta_stime = cur_stime - prev_stime; 
+
+	printf("[ RUSAGE_SELF ]\n");
+	OKNG(cur_utime < 0 || cur_utime > (0.1 * ONE_SEC),
+			"  utime: %d.%06d s (+ %d.%06d s)",
+			(cur_utime / ONE_SEC), (cur_utime % ONE_SEC),
+			(delta_utime / ONE_SEC), (delta_utime % ONE_SEC));
+	OKNG(cur_stime < 0 || cur_stime > (0.1 * ONE_SEC),
+			"  stime: %d.%06d s (+ %d.%06d s)",
+			(cur_stime / ONE_SEC), (cur_stime % ONE_SEC),
+			(delta_stime / ONE_SEC), (delta_stime % ONE_SEC));
+
+	prev_utime = cur_utime;
+	prev_stime = cur_stime;
+
+	/* add utime 2sec */
+	printf("----  add utime 2sec ----\n");
+	add_utime(2);
+
+	/* check rusage 2nd */
+	rc = getrusage(RUSAGE_SELF, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 2nd");
+
+	cur_utime = get_rusage_utime(&cur_rusage);
+	cur_stime = get_rusage_stime(&cur_rusage);
+	delta_utime = cur_utime - prev_utime;
+	delta_stime = cur_stime - prev_stime; 
+
+	printf("[ RUSAGE_SELF ]\n");
+	OKNG(delta_utime < (1.9 * ONE_SEC) || delta_utime > (2.1 * ONE_SEC),
+			"  utime: %d.%06d s (+ %d.%06d s)",
+			(cur_utime / ONE_SEC), (cur_utime % ONE_SEC),
+			(delta_utime / ONE_SEC), (delta_utime % ONE_SEC));
+	OKNG(delta_stime < 0 || delta_stime > (0.1 * ONE_SEC),
+			"  stime: %d.%06d s (+ %d.%06d s)",
+			(cur_stime / ONE_SEC), (cur_stime % ONE_SEC),
+			(delta_stime / ONE_SEC), (delta_stime % ONE_SEC));
+
+	prev_utime = cur_utime;
+	prev_stime = cur_stime;
+
+	/* add stime 1sec */
+	printf("----  add stime 1sec ----\n");
+	add_stime(1);
+
+	/* check rusage 3rd */
+	rc = getrusage(RUSAGE_SELF, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 3rd");
+
+	cur_utime = get_rusage_utime(&cur_rusage);
+	cur_stime = get_rusage_stime(&cur_rusage);
+	delta_utime = cur_utime - prev_utime;
+	delta_stime = cur_stime - prev_stime; 
+
+	printf("[ RUSAGE_SELF ]\n");
+	OKNG(delta_utime < 0 || delta_utime > (0.1 * ONE_SEC),
+			"  utime: %d.%06d s (+ %d.%06d s)",
+			(cur_utime / ONE_SEC), (cur_utime % ONE_SEC),
+			(delta_utime / ONE_SEC), (delta_utime % ONE_SEC));
+	OKNG(delta_stime < (0.9 * ONE_SEC) || delta_stime > (1.1 * ONE_SEC),
+			"  stime: %d.%06d s (+ %d.%06d s)",
+			(cur_stime / ONE_SEC), (cur_stime % ONE_SEC),
+			(delta_stime / ONE_SEC), (delta_stime % ONE_SEC));
+
+	printf("*** %s PASS\n\n", TEST_NAME);
+	return 0;
+fn_fail:
+
+	printf("*** %s FAILED\n\n", TEST_NAME);
+	return -1;
+}

test/mng_mod/issues/1032-34/x86_64/CT_002.c

@@ -0,0 +1,92 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#include "./test_chk.h"
+#include "./test_rusage.h"
+
+#define TEST_NAME "CT_002"
+
+int main(int argc, char* argv[])
+{
+	int rc;
+	char *buf1 = NULL, *buf2 = NULL;
+	struct rusage cur_rusage;
+	long cur_maxrss, prev_maxrss = 0, delta_maxrss;
+
+	printf("----  just started ----\n");
+	/* check rusage 1st */
+	rc = getrusage(RUSAGE_SELF, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 1st");
+
+	cur_maxrss = get_rusage_maxrss(&cur_rusage);
+	delta_maxrss = cur_maxrss - prev_maxrss;
+	printf("[ RUSAGE_SELF ]\n");
+	OKNG(cur_maxrss < 0,
+			"  maxrss: %d KB (+ %d KB)", cur_maxrss, delta_maxrss);
+
+	prev_maxrss = cur_maxrss;
+
+	/* mmap 12MB */
+	printf("----  mmap and access 12MB (%d KB)  ----\n", 12 * 1024);
+	buf1 = mmap(0, 12 * M_BYTE, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+	CHKANDJUMP(!buf1, "mmap 1st");
+	memset(buf1, 0xff, 12 * M_BYTE);
+
+	/* check rusage 2nd */
+	rc = getrusage(RUSAGE_SELF, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 2nd");
+
+	cur_maxrss = get_rusage_maxrss(&cur_rusage);
+	delta_maxrss = cur_maxrss - prev_maxrss;
+	printf("[ RUSAGE_SELF ]\n");
+	OKNG(cur_maxrss < (12 * 1024),
+			"  maxrss: %d KB (+ %d KB)", cur_maxrss, delta_maxrss);
+
+	prev_maxrss = cur_maxrss;
+
+	/* munmap 12MB */
+	printf("----  munmap 12MB (%d KB)  ----\n", 12 * 1024);
+	munmap(buf1, 12 * M_BYTE);
+
+	/* check rusage 3rd */
+	rc = getrusage(RUSAGE_SELF, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 3rd");
+
+	cur_maxrss = get_rusage_maxrss(&cur_rusage);
+	delta_maxrss = cur_maxrss - prev_maxrss;
+	printf("[ RUSAGE_SELF ]\n");
+	OKNG(cur_maxrss != prev_maxrss,
+			"  maxrss: %d KB (+ %d KB)", cur_maxrss, delta_maxrss);
+
+	prev_maxrss = cur_maxrss;
+
+	/* mmap 16MB */
+	printf("----  mmap and access 16MB (%d KB)  ----\n", 16 * 1024);
+	buf2 = mmap(0, 16 * M_BYTE, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+	CHKANDJUMP(!buf2, "mmap 2nd");
+	memset(buf2, 0xff, 16 * M_BYTE);
+
+	/* check rusage 4th */
+	rc = getrusage(RUSAGE_SELF, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 4th");
+
+	cur_maxrss = get_rusage_maxrss(&cur_rusage);
+	delta_maxrss = cur_maxrss - prev_maxrss;
+	printf("[ RUSAGE_SELF ]\n");
+	OKNG(delta_maxrss < (3.8 * 1024) || delta_maxrss > (4.2 * 1024),
+			"  maxrss: %d KB (+ %d KB)", cur_maxrss, delta_maxrss);
+
+	prev_maxrss = cur_maxrss;
+
+	munmap(buf2, 16 * M_BYTE);
+
+	printf("*** %s PASS\n\n", TEST_NAME);
+	return 0;
+fn_fail:
+
+	printf("*** %s FAILED\n\n", TEST_NAME);
+	return -1;
+}

test/mng_mod/issues/1032-34/x86_64/CT_003.c

@@ -0,0 +1,92 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+
+#include "./test_chk.h"
+#include "./test_rusage.h"
+
+#define TEST_NAME "CT_003"
+
+void *subth_func(void *arg)
+{
+	/* add utime 2sec */
+	printf("    ----  add utime 2sec in sub thread  ----\n");
+	add_utime(2);
+
+	/* add stime 1sec */
+	printf("    ----  add stime 1sec in sub thread  ----\n");
+	add_stime(1);
+
+	printf("    ----  sub thread exit ----\n");
+}
+
+int main(int argc, char* argv[])
+{
+	int rc;
+	struct rusage cur_rusage;
+	long cur_utime, cur_stime;
+	long delta_utime, delta_stime;
+	long prev_utime = 0, prev_stime = 0;
+	int status;
+	pthread_t sub_th;
+
+	printf("----  just started ----\n");
+	/* check rusage 1st */
+	rc = getrusage(RUSAGE_SELF, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 1st");
+
+	cur_utime = get_rusage_utime(&cur_rusage);
+	cur_stime = get_rusage_stime(&cur_rusage);
+	delta_utime = cur_utime - prev_utime;
+	delta_stime = cur_stime - prev_stime; 
+
+	printf("[ RUSAGE_SELF ]\n");
+	OKNG(cur_utime < 0 || cur_utime > (0.1 * ONE_SEC),
+			"  utime: %d.%06d s (+ %d.%06d s)",
+			(cur_utime / ONE_SEC), (cur_utime % ONE_SEC),
+			(delta_utime / ONE_SEC), (delta_utime % ONE_SEC));
+	OKNG(cur_stime < 0 || cur_stime > (0.1 * ONE_SEC),
+			"  stime: %d.%06d s (+ %d.%06d s)",
+			(cur_stime / ONE_SEC), (cur_stime % ONE_SEC),
+			(delta_stime / ONE_SEC), (delta_stime % ONE_SEC));
+
+	prev_utime = cur_utime;
+	prev_stime = cur_stime;
+
+	printf("----  create thread and join  ----\n");
+	status = pthread_create(&sub_th, NULL, subth_func, NULL);
+	CHKANDJUMP(status != 0, "pthread_create()");
+
+	pthread_join(sub_th, NULL);
+
+	/* check rusage 2nd  */
+	rc = getrusage(RUSAGE_SELF, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 2nd");
+
+	cur_utime = get_rusage_utime(&cur_rusage);
+	cur_stime = get_rusage_stime(&cur_rusage);
+	delta_utime = cur_utime - prev_utime;
+	delta_stime = cur_stime - prev_stime; 
+
+	printf("[ RUSAGE_SELF ]\n");
+	OKNG(delta_utime < (1.9 * ONE_SEC) || delta_utime > (2.1 * ONE_SEC),
+			"  utime: %d.%06d s (+ %d.%06d s)  <- サブスレッド増分2秒",
+			(cur_utime / ONE_SEC), (cur_utime % ONE_SEC),
+			(delta_utime / ONE_SEC), (delta_utime % ONE_SEC));
+	OKNG(delta_stime < (3.9 * ONE_SEC) || delta_stime > (4.1 * ONE_SEC),
+			"  stime: %d.%06d s (+ %d.%06d s)  <- サブスレッド増分1秒 + メインスレッドjoin待ち3秒",
+			(cur_stime / ONE_SEC), (cur_stime % ONE_SEC),
+			(delta_stime / ONE_SEC), (delta_stime % ONE_SEC));
+
+	prev_utime = cur_utime;
+	prev_stime = cur_stime;
+
+	printf("*** %s PASS\n\n", TEST_NAME);
+	return 0;
+fn_fail:
+
+	printf("*** %s FAILED\n\n", TEST_NAME);
+	return -1;
+}

test/mng_mod/issues/1032-34/x86_64/CT_004.c

@@ -0,0 +1,76 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <pthread.h>
+
+#include "./test_chk.h"
+#include "./test_rusage.h"
+
+#define TEST_NAME "CT_004"
+
+void *subth_func(void *arg)
+{
+	char *buf_subth = NULL;
+
+	/* mmap 16MB */
+	printf("    ----  mmap and access 16MB (%d KB) in sub thread  ----\n", 16 * 1024);
+	buf_subth = mmap(0, 16 * M_BYTE, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+	memset(buf_subth, 0xff, 16 * M_BYTE);
+
+	printf("    ----  munmap 16MB (%d KB) in sub thread ----\n", 16 * 1024);
+	/* unmap */
+	munmap(buf_subth, 16 * M_BYTE);
+
+	printf("    ----  sub thread exit  ----\n");
+}
+
+int main(int argc, char* argv[])
+{
+	int rc;
+	char *buf = NULL;
+	struct rusage cur_rusage;
+	long cur_maxrss, prev_maxrss = 0, delta_maxrss;
+	int status;
+	pthread_t sub_th;
+
+	printf("----  just started ----\n");
+	/* check rusage 1st */
+	rc = getrusage(RUSAGE_SELF, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 1st");
+
+	cur_maxrss = get_rusage_maxrss(&cur_rusage);
+	delta_maxrss = cur_maxrss - prev_maxrss;
+	printf("[ RUSAGE_SELF ]\n");
+	OKNG(cur_maxrss < 0 ,
+			"  maxrss: %d KB (+ %d KB)", cur_maxrss, delta_maxrss);
+
+	prev_maxrss = cur_maxrss;
+
+	printf("----  create thread and join  ----\n");
+	status = pthread_create(&sub_th, NULL, subth_func, NULL);
+	CHKANDJUMP(status != 0, "pthread_create()");
+
+	pthread_join(sub_th, NULL);
+
+	/* check rusage 2nd */
+	rc = getrusage(RUSAGE_SELF, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 2nd");
+
+	cur_maxrss = get_rusage_maxrss(&cur_rusage);
+	delta_maxrss = cur_maxrss - prev_maxrss;
+	printf("[ RUSAGE_SELF ]\n");
+	OKNG(cur_maxrss < (16 * 1024) ,
+			"  maxrss: %d KB (+ %d KB)", cur_maxrss, delta_maxrss);
+
+	prev_maxrss = cur_maxrss;
+
+	printf("*** %s PASS\n\n", TEST_NAME);
+	return 0;
+
+fn_fail:
+
+	printf("*** %s FAILED\n\n", TEST_NAME);
+	return -1;
+}

test/mng_mod/issues/1032-34/x86_64/CT_005.c

@@ -0,0 +1,119 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#include "./test_chk.h"
+#include "./test_rusage.h"
+
+#define TEST_NAME "CT_005"
+
+int main(int argc, char* argv[])
+{
+	int rc;
+	char *buf = NULL;
+	struct rusage cur_rusage;
+	long cur_utime, cur_stime, cur_maxrss;
+	long delta_utime, delta_stime, delta_maxrss;
+	long prev_utime = 0, prev_stime = 0, prev_maxrss = 0;
+	int pid, status;
+
+	printf("----  just started ----\n");
+	/* check rusage 1st  */
+	rc = getrusage(RUSAGE_SELF, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 1st");
+
+	cur_utime = get_rusage_utime(&cur_rusage);
+	cur_stime = get_rusage_stime(&cur_rusage);
+	cur_maxrss = get_rusage_maxrss(&cur_rusage);
+	delta_utime = cur_utime - prev_utime;
+	delta_stime = cur_stime - prev_stime; 
+	delta_maxrss = cur_maxrss - prev_maxrss; 
+
+	printf("[ RUSAGE_SELF ]\n");
+	OKNG(cur_utime < 0 || cur_utime > (0.1 * ONE_SEC),
+			"  utime: %d.%06d s (+ %d.%06d s)",
+			(cur_utime / ONE_SEC), (cur_utime % ONE_SEC),
+			(delta_utime / ONE_SEC), (delta_utime % ONE_SEC));
+	OKNG(cur_stime < 0 || cur_stime > (0.1 * ONE_SEC),
+			"  stime: %d.%06d s (+ %d.%06d s)",
+			(cur_stime / ONE_SEC), (cur_stime % ONE_SEC),
+			(delta_stime / ONE_SEC), (delta_stime % ONE_SEC));
+	OKNG(cur_maxrss < 0 ,
+			"  maxrss: %d KB (+ %d KB)", cur_maxrss, delta_maxrss);
+
+	prev_utime = cur_utime;
+	prev_stime = cur_stime;
+	prev_maxrss = cur_maxrss;
+
+	printf("----  fork child process  ----\n");
+	pid = fork();
+	CHKANDJUMP(pid == -1, "fork");
+
+	if (pid == 0) { /* child */
+		/* add utime 1sec */
+		printf("    ----  add utime 1sec in child  ----\n");
+		add_utime(1);
+	
+		/* add stime 1sec */
+		printf("    ----  add stime 1sec in child  ----\n");
+		add_stime(1);
+
+		/* mmap 16MB */
+		printf("    ----  mmap and access 16MB (%d KB) in child  ----\n", 16 * 1024);
+		buf = mmap(0, 16 * M_BYTE, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+		CHKANDJUMP(!buf, "mmap");
+		memset(buf, 0xff, 16 * M_BYTE);
+
+		/* munmap 16MB */
+		printf("    ----  munmap 16MB (%d KB) in child  ----\n", 16 * 1024);
+		munmap(buf, 16 * M_BYTE);
+
+		printf("    ----  child process exit  ----\n");
+		_exit(123);
+	} else { /* parent */
+		/* add utime 3sec */
+		printf("----  add utime 3sec in parent  ----\n");
+		add_utime(3);
+		
+		printf("----  wait child's exit  ----\n");
+		rc = waitpid(pid, &status, 0);
+		CHKANDJUMP(rc == -1, "waitpid");
+
+	}
+
+	/* check rusage 2nd */
+	rc = getrusage(RUSAGE_SELF, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 2nd");
+
+	cur_utime = get_rusage_utime(&cur_rusage);
+	cur_stime = get_rusage_stime(&cur_rusage);
+	cur_maxrss = get_rusage_maxrss(&cur_rusage);
+	delta_utime = cur_utime - prev_utime;
+	delta_stime = cur_stime - prev_stime; 
+	delta_maxrss = cur_maxrss - prev_maxrss; 
+
+	printf("[ RUSAGE_SELF ]\n");
+	OKNG(delta_utime < (2.9 * ONE_SEC) || delta_utime > (3.1 * ONE_SEC),
+			"  utime: %d.%06d s (+ %d.%06d s)",
+			(cur_utime / ONE_SEC), (cur_utime % ONE_SEC),
+			(delta_utime / ONE_SEC), (delta_utime % ONE_SEC));
+	OKNG(delta_stime < 0 || delta_stime > (0.1 * ONE_SEC),
+			"  stime: %d.%06d s (+ %d.%06d s)",
+			(cur_stime / ONE_SEC), (cur_stime % ONE_SEC),
+			(delta_stime / ONE_SEC), (delta_stime % ONE_SEC));
+	OKNG(cur_maxrss > 16 * 1024,
+			"  maxrss: %d KB (+ %d KB)", cur_maxrss, delta_maxrss);
+
+	prev_utime = cur_utime;
+	prev_stime = cur_stime;
+	prev_maxrss = cur_maxrss;
+
+	printf("*** %s PASS\n\n", TEST_NAME);
+	return 0;
+fn_fail:
+
+	printf("*** %s FAILED\n\n", TEST_NAME);
+	return -1;
+}

test/mng_mod/issues/1032-34/x86_64/CT_006.c

@@ -0,0 +1,118 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#include "./test_chk.h"
+#include "./test_rusage.h"
+
+#define TEST_NAME "CT_006"
+
+int main(int argc, char* argv[])
+{
+	int rc;
+	char *buf = NULL;
+	struct rusage cur_rusage;
+	long cur_utime, cur_stime, cur_maxrss;
+	long delta_utime, delta_stime, delta_maxrss;
+	long prev_utime = 0, prev_stime = 0, prev_maxrss = 0;
+	int pid, status;
+
+	printf("----  just started ----\n");
+	/* check rusage 1st */
+	rc = getrusage(RUSAGE_CHILDREN, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 1st");
+
+	cur_utime = get_rusage_utime(&cur_rusage);
+	cur_stime = get_rusage_stime(&cur_rusage);
+	delta_utime = cur_utime - prev_utime;
+	delta_stime = cur_stime - prev_stime; 
+
+	printf("[ RUSAGE_CHILDREN ]\n");
+	OKNG(cur_utime != 0,
+			"  utime: %d.%06d s (+ %d.%06d s)",
+			(cur_utime / ONE_SEC), (cur_utime % ONE_SEC),
+			(delta_utime / ONE_SEC), (delta_utime % ONE_SEC));
+	OKNG(cur_stime != 0,
+			"  stime: %d.%06d s (+ %d.%06d s)",
+			(cur_stime / ONE_SEC), (cur_stime % ONE_SEC),
+			(delta_stime / ONE_SEC), (delta_stime % ONE_SEC));
+
+	prev_utime = cur_utime;
+	prev_stime = cur_stime;
+
+	printf("----  fork child process  ----\n");
+	pid = fork();
+	CHKANDJUMP(pid == -1, "fork");
+
+	if (pid == 0) { /* child */
+		/* add utime 2sec */
+		printf("    ----  add utime 2sec in child  ----\n");
+		add_utime(2);
+	
+		/* add stime 1sec */
+		printf("    ----  add stime 1sec in child  ----\n");
+		add_stime(1);
+
+		printf("    ----  child process exit  ----\n");
+		_exit(123);
+	} else { /* parent */
+		/* add utime 1sec */
+		printf("----  add utime 1sec in parent  ----\n");
+		add_utime(1);
+		
+		/* check rusage 2nd */
+		rc = getrusage(RUSAGE_CHILDREN, &cur_rusage);
+		CHKANDJUMP(rc == -1, "getrusage 1st");
+
+		cur_utime = get_rusage_utime(&cur_rusage);
+		cur_stime = get_rusage_stime(&cur_rusage);
+		delta_utime = cur_utime - prev_utime;
+		delta_stime = cur_stime - prev_stime; 
+
+		printf("[ RUSAGE_CHILDREN ]\n");
+		OKNG(cur_utime != 0,
+				"  utime: %d.%06d s (+ %d.%06d s)  <- 子プロセスが未終了のため、0",
+				(cur_utime / ONE_SEC), (cur_utime % ONE_SEC),
+				(delta_utime / ONE_SEC), (delta_utime % ONE_SEC));
+		OKNG(cur_stime != 0,
+				"  stime: %d.%06d s (+ %d.%06d s)  <- 子プロセスが未終了のため、0",
+				(cur_stime / ONE_SEC), (cur_stime % ONE_SEC),
+				(delta_stime / ONE_SEC), (delta_stime % ONE_SEC));
+
+		printf("----  wait child's exit  ----\n");
+		rc = waitpid(pid, &status, 0);
+		CHKANDJUMP(rc == -1, "waitpid");
+
+	}
+
+	/* check rusage 3rd */
+	rc = getrusage(RUSAGE_CHILDREN, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 2nd");
+
+	cur_utime = get_rusage_utime(&cur_rusage);
+	cur_stime = get_rusage_stime(&cur_rusage);
+	delta_utime = cur_utime - prev_utime;
+	delta_stime = cur_stime - prev_stime; 
+
+	printf("[ RUSAGE_CHILDREN ]\n");
+	OKNG(delta_utime < (1.9 * ONE_SEC) || delta_utime > (2.1 * ONE_SEC),
+			"  utime: %d.%06d s (+ %d.%06d s)",
+			(cur_utime / ONE_SEC), (cur_utime % ONE_SEC),
+			(delta_utime / ONE_SEC), (delta_utime % ONE_SEC));
+	OKNG(delta_stime < (0.9 * ONE_SEC) || delta_stime > (1.1 * ONE_SEC),
+			"  stime: %d.%06d s (+ %d.%06d s)",
+			(cur_stime / ONE_SEC), (cur_stime % ONE_SEC),
+			(delta_stime / ONE_SEC), (delta_stime % ONE_SEC));
+
+	prev_utime = cur_utime;
+	prev_stime = cur_stime;
+
+	printf("*** %s PASS\n\n", TEST_NAME);
+	return 0;
+fn_fail:
+
+	printf("*** %s FAILED\n\n", TEST_NAME);
+	return -1;
+}

test/mng_mod/issues/1032-34/x86_64/CT_007.c

@@ -0,0 +1,94 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#include "./test_chk.h"
+#include "./test_rusage.h"
+
+#define TEST_NAME "CT_007"
+
+int main(int argc, char* argv[])
+{
+	int rc;
+	char *buf = NULL, *buf_child = NULL;
+	struct rusage cur_rusage;
+	long cur_utime, cur_stime, cur_maxrss;
+	long delta_utime, delta_stime, delta_maxrss;
+	long prev_utime = 0, prev_stime = 0, prev_maxrss = 0;
+	int pid, status;
+
+	printf("----  just started ----\n");
+	/* check rusage 1st */
+	rc = getrusage(RUSAGE_CHILDREN, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 1st");
+
+	cur_maxrss = get_rusage_maxrss(&cur_rusage);
+	delta_maxrss = cur_maxrss - prev_maxrss; 
+
+	printf("[ RUSAGE_CHILDREN ]\n");
+	OKNG(cur_maxrss != 0,
+			"  maxrss: %d KB (+ %d KB)", cur_maxrss, delta_maxrss);
+
+	prev_maxrss = cur_maxrss;
+
+	printf("----  fork child process  ----\n");
+	pid = fork();
+	CHKANDJUMP(pid == -1, "fork");
+
+	if (pid == 0) { /* child */
+		/* add utime 1sec */
+		printf("    ----  add utime 1sec in child  ----\n");
+		add_utime(1);
+
+		/* mmap 16MB */
+		printf("    ----  mmap and access 16MB (%d KB) in child  ----\n", 16 * 1024);
+		buf = mmap(0, 16 * M_BYTE, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+		CHKANDJUMP(!buf, "mmap");
+		memset(buf, 0xff, 16 * M_BYTE);
+
+		/* munmap 16MB */
+		printf("    ----  munmap 16MB (%d KB) in child  ----\n", 16 * 1024);
+		munmap(buf, 16 * M_BYTE);
+
+		printf("    ----  child process exit ----\n");
+		_exit(123);
+	} else { /* parent */
+		/* mmap 32MB */
+		printf("----  mmap and access 32MB (%d KB) in parent  ----\n", 32 * 1024);
+		buf = mmap(0, 32 * M_BYTE, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+		CHKANDJUMP(!buf, "mmap");
+		memset(buf, 0xff, 32 * M_BYTE);
+
+		/* munmap 32MB */
+		printf("----  munmap 32MB (%d KB) in parent  ----\n", 32 * 1024);
+		munmap(buf, 32 * M_BYTE);
+		
+		printf("----  wait child's exit  ----\n");
+		rc = waitpid(pid, &status, 0);
+		CHKANDJUMP(rc == -1, "waitpid");
+
+	}
+
+	/* check rusage 2nd */
+	rc = getrusage(RUSAGE_CHILDREN, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 2nd");
+
+	cur_maxrss = get_rusage_maxrss(&cur_rusage);
+	delta_maxrss = cur_maxrss - prev_maxrss; 
+
+	printf("[ RUSAGE_CHILDREN ]\n");
+	OKNG(cur_maxrss < 16 * 1024 || cur_maxrss > 32 * 1024,
+			"  maxrss: %d KB (+ %d KB)  <- 子プロセス終了後に更新 (プロセス生成時の5～6M + mmapでの16M)", 
+	        cur_maxrss, delta_maxrss);
+
+	prev_maxrss = cur_maxrss;
+
+	printf("*** %s PASS\n\n", TEST_NAME);
+	return 0;
+fn_fail:
+
+	printf("*** %s FAILED\n\n", TEST_NAME);
+	return -1;
+}

test/mng_mod/issues/1032-34/x86_64/CT_008.c

@@ -0,0 +1,147 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#include "./test_chk.h"
+#include "./test_rusage.h"
+
+#define TEST_NAME "CT_008"
+
+int main(int argc, char* argv[])
+{
+	int rc;
+	char *buf_child = NULL, *buf_grand_child = NULL;
+	struct rusage cur_rusage;
+	long cur_utime, cur_stime, cur_maxrss;
+	long delta_utime, delta_stime, delta_maxrss;
+	long prev_utime = 0, prev_stime = 0, prev_maxrss = 0;
+	int pid, pid_grand_child, status, status_grand_child;
+
+	printf("----  just started ----\n");
+	/* check rusage 1st */
+	rc = getrusage(RUSAGE_CHILDREN, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 1st");
+
+	cur_utime = get_rusage_utime(&cur_rusage);
+	cur_stime = get_rusage_stime(&cur_rusage);
+	cur_maxrss = get_rusage_maxrss(&cur_rusage);
+	delta_utime = cur_utime - prev_utime;
+	delta_stime = cur_stime - prev_stime; 
+	delta_maxrss = cur_maxrss - prev_maxrss; 
+
+	printf("[ RUSAGE_CHILDREN ]\n");
+	OKNG(cur_utime != 0,
+			"  utime: %d.%06d s (+ %d.%06d s)",
+			(cur_utime / ONE_SEC), (cur_utime % ONE_SEC),
+			(delta_utime / ONE_SEC), (delta_utime % ONE_SEC));
+	OKNG(cur_stime != 0,
+			"  stime: %d.%06d s (+ %d.%06d s)",
+			(cur_stime / ONE_SEC), (cur_stime % ONE_SEC),
+			(delta_stime / ONE_SEC), (delta_stime % ONE_SEC));
+	OKNG(cur_maxrss != 0 ,
+			"  maxrss: %d KB (+ %d KB)", cur_maxrss, delta_maxrss);
+
+	prev_utime = cur_utime;
+	prev_stime = cur_stime;
+	prev_maxrss = cur_maxrss;
+
+	printf("----  fork child process  ----\n");
+	pid = fork();
+	CHKANDJUMP(pid == -1, "fork");
+
+	if (pid == 0) { /* child */
+		printf("    ----  fork grand_child process  ----\n");
+		pid_grand_child = fork();
+		CHKANDJUMP(pid_grand_child == -1, "fork grand_child");
+
+		if (pid_grand_child == 0) /* grand_child */
+		{
+			/* add utime 1sec */
+			printf("        ----  add utime 1sec in grand_child  ----\n");
+			add_utime(1);
+
+			/* add stime 1sec */
+			printf("        ----  add stime 1sec in grand_child  ----\n");
+			add_stime(1);
+			
+			/* mmap 32MB */
+			printf("        ----  mmap and access 32MB (%d KB) in grand_child  ----\n", 32 * 1024);
+			buf_grand_child = mmap(0, 32 * M_BYTE, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+			CHKANDJUMP(!buf_grand_child, "mmap");
+			memset(buf_grand_child, 0xff, 32 * M_BYTE);
+
+			/* munmap 32MB */
+			printf("        ----  munmap 32MB (%d KB) in grand_child  ----\n", 32 * 1024);
+			munmap(buf_grand_child, 16 * M_BYTE);
+
+			printf("        ----  grand_child process exit  ----\n");
+			_exit(234);
+		}
+
+		/* add utime 2sec */
+		printf("    ----  add utime 2sec in child  ----\n");
+		add_utime(2);
+	
+		/* add stime 1sec */
+		printf("    ----  add stime 1sec in child  ----\n");
+		add_stime(1);
+
+		/* mmap 8MB */
+		printf("    ----  mmap and access 8MB (%d KB) in child  ----\n", 8 * 1024);
+		buf_child = mmap(0, 8 * M_BYTE, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+		CHKANDJUMP(!buf_child, "mmap");
+		memset(buf_child, 0xff, 8 * M_BYTE);
+
+		/* munmap 8MB */
+		printf("    ----  munmap 8MB (%d KB) in child  ----\n", 8 * 1024);
+		munmap(buf_child, 8 * M_BYTE);
+
+		printf("    ----  wait grand_child's exit  ----\n");
+		rc = waitpid(pid_grand_child, &status_grand_child, 0);
+		CHKANDJUMP(rc == -1, "waitpid");
+
+		printf("    ----  child process exit  ----\n");
+		_exit(123);
+	} else { /* parent */
+		printf("----  wait child's exit  ----\n");
+		rc = waitpid(pid, &status, 0);
+		CHKANDJUMP(rc == -1, "waitpid");
+	}
+
+	/* check rusage 2nd */
+	rc = getrusage(RUSAGE_CHILDREN, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 2nd");
+
+	cur_utime = get_rusage_utime(&cur_rusage);
+	cur_stime = get_rusage_stime(&cur_rusage);
+	cur_maxrss = get_rusage_maxrss(&cur_rusage);
+	delta_utime = cur_utime - prev_utime;
+	delta_stime = cur_stime - prev_stime; 
+	delta_maxrss = cur_maxrss - prev_maxrss; 
+
+	printf("[ RUSAGE_CHILDREN ]\n");
+	OKNG(cur_utime < (2.9 * ONE_SEC) || delta_utime > (3.1 * ONE_SEC),
+			"  utime: %d.%06d s (+ %d.%06d s)  <- 子プロセス2秒、孫プロセス1秒の和",
+			(cur_utime / ONE_SEC), (cur_utime % ONE_SEC),
+			(delta_utime / ONE_SEC), (delta_utime % ONE_SEC));
+	OKNG(cur_stime < (1.9 * ONE_SEC) || delta_stime > (2.1 * ONE_SEC),
+			"  stime: %d.%06d s (+ %d.%06d s)  <- 子プロセス1秒、孫プロセス1秒の和",
+			(cur_stime / ONE_SEC), (cur_stime % ONE_SEC),
+			(delta_stime / ONE_SEC), (delta_stime % ONE_SEC));
+	OKNG(cur_maxrss < 32 * 1024 || cur_maxrss > 40 * 1024,
+			"  maxrss: %d KB (+ %d KB)  <- 子、孫のmaxrssの最大値",
+	        cur_maxrss, delta_maxrss);
+
+	prev_utime = cur_utime;
+	prev_stime = cur_stime;
+	prev_maxrss = cur_maxrss;
+
+	printf("*** %s PASS\n\n", TEST_NAME);
+	return 0;
+fn_fail:
+
+	printf("*** %s FAILED\n\n", TEST_NAME);
+	return -1;
+}

test/mng_mod/issues/1032-34/x86_64/CT_009.c

@@ -0,0 +1,142 @@
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+
+#include "./test_chk.h"
+#include "./test_rusage.h"
+
+#define TEST_NAME "CT_009"
+
+void *child_func(void *arg)
+{
+	int rc;
+	struct rusage cur_rusage;
+	long cur_utime, cur_stime;
+	long delta_utime, delta_stime;
+	long prev_utime = 0, prev_stime = 0;
+
+	/* check rusage in sub thread */
+	rc = getrusage(RUSAGE_THREAD, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage");
+
+	cur_utime = get_rusage_utime(&cur_rusage);
+	cur_stime = get_rusage_stime(&cur_rusage);
+	delta_utime = cur_utime - prev_utime;
+	delta_stime = cur_stime - prev_stime; 
+
+	printf("    [ RUSAGE_THREAD ]\n");
+	OKNG(cur_utime < 0 || cur_utime > (0.1 * ONE_SEC),
+			"      utime: %d.%06d s (+ %d.%06d s)",
+			(cur_utime / ONE_SEC), (cur_utime % ONE_SEC),
+			(delta_utime / ONE_SEC), (delta_utime % ONE_SEC));
+	OKNG(cur_stime < 0 || cur_stime > (0.1 * ONE_SEC),
+			"      stime: %d.%06d s (+ %d.%06d s)",
+			(cur_stime / ONE_SEC), (cur_stime % ONE_SEC),
+			(delta_stime / ONE_SEC), (delta_stime % ONE_SEC));
+
+	/* add utime 2sec */
+	printf("    ----  add utime 2sec in sub thread  ----\n");
+	add_utime(2);
+
+	/* add stime 1sec */
+	printf("    ----  add stime 1sec in sub thread  ----\n");
+	add_stime(1);
+
+	/* check rusage in sub thread */
+	rc = getrusage(RUSAGE_THREAD, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage");
+
+	cur_utime = get_rusage_utime(&cur_rusage);
+	cur_stime = get_rusage_stime(&cur_rusage);
+	delta_utime = cur_utime - prev_utime;
+	delta_stime = cur_stime - prev_stime; 
+
+	printf("    [ RUSAGE_THREAD ]\n");
+	OKNG(delta_utime < (1.9 * ONE_SEC) || delta_utime > (2.1 * ONE_SEC),
+			"      utime: %d.%06d s (+ %d.%06d s)",
+			(cur_utime / ONE_SEC), (cur_utime % ONE_SEC),
+			(delta_utime / ONE_SEC), (delta_utime % ONE_SEC));
+	OKNG(delta_stime < (0.9 * ONE_SEC) || delta_stime > (1.1 * ONE_SEC),
+			"      stime: %d.%06d s (+ %d.%06d s)",
+			(cur_stime / ONE_SEC), (cur_stime % ONE_SEC),
+			(delta_stime / ONE_SEC), (delta_stime % ONE_SEC));
+
+fn_fail:
+	printf("    ----  sub thread exit  ----\n");
+	return;
+}
+
+int main(int argc, char* argv[])
+{
+	int rc;
+	struct rusage cur_rusage;
+	long cur_utime, cur_stime;
+	long delta_utime, delta_stime;
+	long prev_utime = 0, prev_stime = 0;
+	int status;
+	pthread_t sub_th;
+
+	printf("----  just started ----\n");
+	/* check rusage 1st */
+	rc = getrusage(RUSAGE_THREAD, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 1st");
+
+	cur_utime = get_rusage_utime(&cur_rusage);
+	cur_stime = get_rusage_stime(&cur_rusage);
+	delta_utime = cur_utime - prev_utime;
+	delta_stime = cur_stime - prev_stime; 
+
+	OKNG(cur_utime < 0 || cur_utime > (0.1 * ONE_SEC),
+			"  utime: %d.%06d s (+ %d.%06d s)",
+			(cur_utime / ONE_SEC), (cur_utime % ONE_SEC),
+			(delta_utime / ONE_SEC), (delta_utime % ONE_SEC));
+	OKNG(cur_stime < 0 || cur_stime > (0.1 * ONE_SEC),
+			"  stime: %d.%06d s (+ %d.%06d s)",
+			(cur_stime / ONE_SEC), (cur_stime % ONE_SEC),
+			(delta_stime / ONE_SEC), (delta_stime % ONE_SEC));
+
+	prev_utime = cur_utime;
+	prev_stime = cur_stime;
+
+	/* add utime 1sec */
+	printf("----  add utime 1sec in main thread  ----\n");
+	add_utime(1);
+
+	printf("----  create thread and join  ----\n");
+	status = pthread_create(&sub_th, NULL, child_func, NULL);
+	CHKANDJUMP(status != 0, "pthread_create()");
+
+	pthread_join(sub_th, NULL);
+
+	/* check rusage 2nd  */
+	rc = getrusage(RUSAGE_THREAD, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 2nd");
+
+	cur_utime = get_rusage_utime(&cur_rusage);
+	cur_stime = get_rusage_stime(&cur_rusage);
+	delta_utime = cur_utime - prev_utime;
+	delta_stime = cur_stime - prev_stime; 
+
+	printf("[ RUSAGE_THREAD ]\n");
+	OKNG(delta_utime < (0.9 * ONE_SEC) || delta_utime > (1.1 * ONE_SEC),
+			"  utime: %d.%06d s (+ %d.%06d s)",
+			(cur_utime / ONE_SEC), (cur_utime % ONE_SEC),
+			(delta_utime / ONE_SEC), (delta_utime % ONE_SEC));
+	OKNG(delta_stime < (2.9 * ONE_SEC) || delta_stime > (3.1 * ONE_SEC),
+			"  stime: %d.%06d s (+ %d.%06d s)  <- join待ち3秒",
+			(cur_stime / ONE_SEC), (cur_stime % ONE_SEC),
+			(delta_stime / ONE_SEC), (delta_stime % ONE_SEC));
+
+	prev_utime = cur_utime;
+	prev_stime = cur_stime;
+
+	printf("*** %s PASS\n\n", TEST_NAME);
+	return 0;
+fn_fail:
+
+	printf("*** %s FAILED\n\n", TEST_NAME);
+	return -1;
+}

test/mng_mod/issues/1032-34/x86_64/CT_010.c

@@ -0,0 +1,101 @@
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <pthread.h>
+
+#include "./test_chk.h"
+#include "./test_rusage.h"
+
+#define TEST_NAME "CT_010"
+
+void *subth_func(void *arg)
+{
+	int rc;
+	char *buf_subth = NULL;
+	struct rusage cur_rusage;
+	long cur_maxrss;
+
+	/* check rusage in sub thread */
+	rc = getrusage(RUSAGE_THREAD, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage");
+
+	cur_maxrss = get_rusage_maxrss(&cur_rusage);
+
+	printf("    [ RUSAGE_THREAD ]\n");
+    OKNG(cur_maxrss < (8 * 1024) ,
+            "      maxrss: %d KB", cur_maxrss);
+
+	/* mmap 16MB */
+	printf("    ----  mmap and access 16MB (%d KB) in sub thread  ----\n", 16 * 1024);
+	buf_subth = mmap(0, 16 * M_BYTE, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+	memset(buf_subth, 0xff, 16 * M_BYTE);
+
+	printf("    ----  munmap 16MB (%d KB) in sub thread ----\n", 16 * 1024);
+	/* unmap */
+	munmap(buf_subth, 16 * M_BYTE);
+
+fn_fail:
+	printf("    ----  sub thread exit  ----\n");
+	return;
+}
+
+int main(int argc, char* argv[])
+{
+	int rc;
+	char *buf = NULL;
+	struct rusage cur_rusage;
+	long cur_maxrss, prev_maxrss = 0, delta_maxrss;
+	int status;
+	pthread_t sub_th;
+
+	printf("----  just started ----\n");
+	/* check rusage 1st */
+	rc = getrusage(RUSAGE_THREAD, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 1st");
+
+	cur_maxrss = get_rusage_maxrss(&cur_rusage);
+	delta_maxrss = cur_maxrss - prev_maxrss;
+	printf("[ RUSAGE_THREAD ]\n");
+	OKNG(cur_maxrss < 0 ,
+			"  maxrss: %d KB (+ %d KB)", cur_maxrss, delta_maxrss);
+
+	prev_maxrss = cur_maxrss;
+
+	/* mmap 8MB */
+	printf("----  mmap and access 8MB (%d KB) in main thread  ----\n", 8 * 1024);
+	buf = mmap(0, 8 * M_BYTE, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+	memset(buf, 0xff, 8 * M_BYTE);
+
+	printf("----  munmap 8MB (%d KB) in main thread ----\n", 8 * 1024);
+	/* unmap */
+	munmap(buf, 8 * M_BYTE);
+
+	printf("----  create and join thread  ----\n");
+	status = pthread_create(&sub_th, NULL, subth_func, NULL);
+	CHKANDJUMP(status != 0, "pthread_create()");
+
+	pthread_join(sub_th, NULL);
+
+	/* check rusage 2nd */
+	rc = getrusage(RUSAGE_THREAD, &cur_rusage);
+	CHKANDJUMP(rc == -1, "getrusage 2nd");
+
+	cur_maxrss = get_rusage_maxrss(&cur_rusage);
+	delta_maxrss = cur_maxrss - prev_maxrss;
+	printf("[ RUSAGE_THREAD ]\n");
+	OKNG(cur_maxrss < (16 * 1024) ,
+			"  maxrss: %d KB (+ %d KB)", cur_maxrss, delta_maxrss);
+
+	prev_maxrss = cur_maxrss;
+
+	printf("*** %s PASS\n\n", TEST_NAME);
+	return 0;
+
+fn_fail:
+
+	printf("*** %s FAILED\n\n", TEST_NAME);
+	return -1;
+}

test/mng_mod/issues/1032-34/x86_64/ins_test_driver.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+MOD_NAME="test_driver"
+DEV_PATH="/dev/test_rusage"
+
+sudo insmod ./${MOD_NAME}.ko
+sudo chmod 666 ${DEV_PATH}

test/mng_mod/issues/1032-34/x86_64/rm_test_driver.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+
+MOD_NAME="test_driver"
+
+lsmod | grep ${MOD_NAME} &> /dev/null
+
+if [ $? -eq 1 ]; then
+	echo "Module test_driver is not currently loaded"
+else
+	sudo rmmod ${MOD_NAME}
+fi
+

test/mng_mod/issues/1032-34/x86_64/test_chk.h

@@ -0,0 +1,25 @@
+#ifndef HEADER_TEST_CHK_H
+#define HEADER_TEST_CHK_H
+
+#define CHKANDJUMP(cond, ...)							\
+	do {												\
+		if (cond) {										\
+			fprintf(stderr, " [NG] ");					\
+			fprintf(stderr, __VA_ARGS__);				\
+			fprintf(stderr, " failed\n");				\
+			goto fn_fail;								\
+		}												\
+	} while(0);
+
+#define OKNG(cond, ...)									\
+	do {												\
+		if (cond) {										\
+			CHKANDJUMP(cond, __VA_ARGS__);				\
+		} else {										\
+			fprintf(stdout, " [OK] ");					\
+			fprintf(stdout, __VA_ARGS__);				\
+			fprintf(stdout, "\n");						\
+		}												\
+	} while(0);
+
+#endif	

test/mng_mod/issues/1032-34/x86_64/test_driver.c

@@ -0,0 +1,94 @@
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/time.h>
+
+#define DEV_CLASS_NAME "dev_class"
+#define DEVICE_NAME "test_rusage"
+
+static int major_num = 0;
+static struct class *test_class = NULL;
+static struct device *test_dev = NULL;
+
+static int dev_open(struct inode *inode, struct file *file)
+{
+
+	return 0;
+}
+
+static int dev_release(struct inode *inode, struct file *file)
+{
+	return 0;
+}
+
+static long dev_ioctl(struct file *file, unsigned int request, unsigned long arg)
+{
+	mdelay(request * 1000);
+	return 0;
+/*
+	struct timespec s_time, c_time;
+
+	getnstimeofday(&s_time);
+
+	while (1) {
+		getnstimeofday(&c_time);
+		if ( c_time.tv_sec >= s_time.tv_sec + request &&
+		     c_time.tv_nsec >= s_time.tv_nsec) {
+			break;
+		}
+	}
+
+	return 0;
+*/
+}
+
+static struct file_operations fops = {
+	.open = dev_open,
+	.release = dev_release,
+	.unlocked_ioctl = dev_ioctl,
+};
+
+static int register_device(void)
+{
+	major_num = register_chrdev(0, DEVICE_NAME, &fops);
+	if (major_num < 0) {
+		printk(KERN_ALERT "failed\n");
+		return major_num;
+	}
+
+	test_class = class_create(THIS_MODULE, DEV_CLASS_NAME);
+
+	test_dev = device_create(test_class, NULL, MKDEV(major_num, 0), NULL, DEVICE_NAME);
+
+	return 0;
+}
+
+void unregister_device(void)
+{
+	device_destroy(test_class, MKDEV(major_num, 0));
+	class_unregister(test_class);
+	class_destroy(test_class);
+	unregister_chrdev(major_num, DEVICE_NAME);
+}
+
+static int __init dev_init(void)
+{
+	register_device();
+	return 0;
+}
+
+module_init(dev_init);
+
+static void __exit dev_exit(void)
+{
+	unregister_device();
+}
+
+module_exit(dev_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Test for getrusage");
+MODULE_VERSION("1.0");