Use monotonic time for durationscirrus

7 files changed, 69 insertions, 69 deletions

diff --git a/test/locked_mkdir.sh b/test/locked_mkdir.sh
index 4c9f82c5..b86ead81 100644
--- a/test/locked_mkdir.sh
+++ b/test/locked_mkdir.sh
@@ -4,22 +4,22 @@ set +e
 LOCK1="${LOCKBASE}/lock1"
 
 # Take first lock
-time=$(date +%s)
+time=$(clock -monotonic)
 locked_mkdir 10 ${LOCK1} $$
 assert 0 $? "$0:$LINENO: Unlocked dir should succeed to lock"
 [ -d "${LOCK1}" ]
 assert 0 $? "$0:$LINENO: Lock dir should exist"
 assert_pid "$0:$LINENO" "${LOCK1}" "$$"
-nowtime=$(date +%s)
+nowtime=$(clock -monotonic)
 elapsed=$((${nowtime} - ${time}))
 [ "${elapsed}" -lt 5 ]
 assert 0 $? "$0:$LINENO: Unlocked dir should not wait to lock"
 
 # Wait on and fail to take owned lock
-time=$(date +%s)
+time=$(clock -monotonic)
 locked_mkdir 2 ${LOCK1} $$
 assert 75 $? "$0:$LINENO: Locked dir should timeout"
-nowtime=$(date +%s)
+nowtime=$(clock -monotonic)
 elapsed=$((${nowtime} - ${time}))
 [ "${elapsed}" -le 3 ]
 assert 0 $? "$0:$LINENO: Lock sleep took too long. elapsed=${elapsed}"
@@ -29,11 +29,11 @@ assert 0 $? "$0:$LINENO: Lock dir should exist"
 # Drop lock and retake it
 rmdir "${LOCK1}"
 assert 0 $? "$0:$LINENO: rmdir should succeed"
-time=$(date +%s)
+time=$(clock -monotonic)
 locked_mkdir 10 ${LOCK1} $$
 assert 0 $? "$0:$LINENO: Unlocked dir should succeed to lock"
 assert_pid "$0:$LINENO" "${LOCK1}" "$$"
-nowtime=$(date +%s)
+nowtime=$(clock -monotonic)
 elapsed=$((${nowtime} - ${time}))
 [ "${elapsed}" -lt 5 ]
 assert 0 $? "$0:$LINENO: Unlocked dir should not wait to lock"
@@ -41,7 +41,7 @@ assert 0 $? "$0:$LINENO: Unlocked dir should not wait to lock"
 assert 0 $? "$0:$LINENO: Lock dir should exist"
 
 # Wait on and succeed taking owned lock
-time=$(date +%s)
+time=$(clock -monotonic)
 # Background process to drop the lock
 (
 	sleep 5
@@ -52,7 +52,7 @@ pid_unlock=$!
 locked_mkdir 10 ${LOCK1} $$
 assert 0 $? "$0:$LINENO: Lock should succeed"
 assert_pid "$0:$LINENO" "${LOCK1}" "$$"
-nowtime=$(date +%s)
+nowtime=$(clock -monotonic)
 elapsed=$((${nowtime} - ${time}))
 [ "${elapsed}" -le 6 ]
 assert 0 $? "$0:$LINENO: Lock slept too long elapsed=${elapsed}"
@@ -66,11 +66,11 @@ rmdir "${LOCK1}"
 assert 0 $? "$0:$LINENO: rmdir should succeed"
 echo -n 999999 > "${LOCK1}.pid"
 assert 0 $? "$0:$LINENO: Writing to pid should succeed"
-time=$(date +%s)
+time=$(clock -monotonic)
 locked_mkdir 10 ${LOCK1} $$
 assert 0 $? "$0:$LINENO: Unlocked existing dir with stale pid should succeed to lock"
 assert_pid "$0:$LINENO" "${LOCK1}" "$$"
-nowtime=$(date +%s)
+nowtime=$(clock -monotonic)
 elapsed=$((${nowtime} - ${time}))
 [ "${elapsed}" -lt 3 ]
 assert 0 $? "$0:$LINENO: Unlocked dir should not wait to lock"
@@ -82,11 +82,11 @@ assert 0 $? "$0:$LINENO: Lock dir should exist"
 assert 0 $? "$0:$LINENO: Lock dir should exist"
 echo -n 999999 > "${LOCK1}.pid"
 assert 0 $? "$0:$LINENO: Writing to pid should succeed"
-time=$(date +%s)
+time=$(clock -monotonic)
 locked_mkdir 10 ${LOCK1} $$
 assert 0 $? "$0:$LINENO: Unlocked existing dir with stale pid should succeed to lock"
 assert_pid "$0:$LINENO" "${LOCK1}" "$$"
-nowtime=$(date +%s)
+nowtime=$(clock -monotonic)
 elapsed=$((${nowtime} - ${time}))
 [ "${elapsed}" -lt 3 ]
 assert 0 $? "$0:$LINENO: Unlocked dir should not wait to lock"
@@ -96,14 +96,14 @@ assert 0 $? "$0:$LINENO: Lock dir should exist"
 # Sanity check taking lock owned by not our pid
 [ -d "${LOCK1}" ]
 assert 0 $? "$0:$LINENO: Lock dir should exist"
-time=$(date +%s)
+time=$(clock -monotonic)
 echo -n 1 > "${LOCK1}.pid"
 assert 0 $? "$0:$LINENO: Writing to pid should succeed"
 assert_pid "$0:$LINENO" "${LOCK1}" "1"
 locked_mkdir 5 ${LOCK1} $$
 assert 75 $? "$0:$LINENO: Lock should not succeed"
 assert_pid "$0:$LINENO" "${LOCK1}" "1"
-nowtime=$(date +%s)
+nowtime=$(clock -monotonic)
 elapsed=$((${nowtime} - ${time}))
 [ "${elapsed}" -le 6 ]
 assert 0 $? "$0:$LINENO: Lock slept too long elapsed=${elapsed}"
@@ -113,14 +113,14 @@ assert 0 $? "$0:$LINENO: Lock dir should exist"
 # Try taking lock with running pid but no dir which is considered stale
 rmdir "${LOCK1}"
 assert 0 $? "$0:$LINENO: rmdir should succeed"
-time=$(date +%s)
+time=$(clock -monotonic)
 echo -n 1 > "${LOCK1}.pid"
 assert 0 $? "$0:$LINENO: Writing to pid should succeed"
 assert_pid "$0:$LINENO" "${LOCK1}" "1"
 locked_mkdir 5 ${LOCK1} $$
 assert 0 $? "$0:$LINENO: Lock should succeed"
 assert_pid "$0:$LINENO" "${LOCK1}" "$$"
-nowtime=$(date +%s)
+nowtime=$(clock -monotonic)
 elapsed=$((${nowtime} - ${time}))
 [ "${elapsed}" -le 2 ]
 assert 0 $? "$0:$LINENO: Lock waiting too long elapsed=${elapsed}"
diff --git a/test/locked_mkdir_waiters.sh b/test/locked_mkdir_waiters.sh
index d76dfa4c..ab686d75 100644
--- a/test/locked_mkdir_waiters.sh
+++ b/test/locked_mkdir_waiters.sh
@@ -14,11 +14,11 @@ until [ "${n}" -eq "${max}" ]; do
 	assert_not 0 $? "$0:$LINENO: Lock dir should not exist"
 
 	echo "$0:$LINENO: Parent pid $$ has lock ${n}"
-	time=$(date +%s)
+	time=$(clock -monotonic)
 	locked_mkdir 0 ${LOCK1} $$
 	assert 0 $? "$0:$LINENO: Lock should succeed"
 	assert_pid "$0:$LINENO" "${LOCK1}" "$$"
-	nowtime=$(date +%s)
+	nowtime=$(clock -monotonic)
 	elapsed=$((${nowtime} - ${time}))
 	[ "${elapsed}" -le 3 ]
 	assert 0 $? "$0:$LINENO: Lock shouldn't sleep elapsed=${elapsed} ${n}"
@@ -26,11 +26,11 @@ until [ "${n}" -eq "${max}" ]; do
 	# Background waiters
 	(
 		mypid=$(sh -c 'echo $PPID')
-		time=$(date +%s)
+		time=$(clock -monotonic)
 		locked_mkdir 5 "${LOCK1}" "${mypid}"
 		got_lock=$?
 		echo "$0:$LINENO: Pid ${mypid} got_lock=${got_lock} ${n}"
-		nowtime=$(date +%s)
+		nowtime=$(clock -monotonic)
 		elapsed=$((${nowtime} - ${time}))
 		[ "${elapsed}" -le 7 ]
 		assert 0 $? "$0:$LINENO: Lock slept too long elapsed=${elapsed} ${n}"
@@ -46,11 +46,11 @@ until [ "${n}" -eq "${max}" ]; do
 	pid_unlock1=$!
 	(
 		mypid=$(sh -c 'echo $PPID')
-		time=$(date +%s)
+		time=$(clock -monotonic)
 		locked_mkdir 5 "${LOCK1}" "${mypid}"
 		got_lock=$?
 		echo "$0:$LINENO: Pid ${mypid} got_lock=${got_lock} ${n}"
-		nowtime=$(date +%s)
+		nowtime=$(clock -monotonic)
 		elapsed=$((${nowtime} - ${time}))
 		[ "${elapsed}" -le 7 ]
 		assert 0 $? "$0:$LINENO: Lock slept too long elapsed=${elapsed} ${n}"
@@ -66,11 +66,11 @@ until [ "${n}" -eq "${max}" ]; do
 	pid_unlock2=$!
 	(
 		mypid=$(sh -c 'echo $PPID')
-		time=$(date +%s)
+		time=$(clock -monotonic)
 		locked_mkdir 5 "${LOCK1}" "${mypid}"
 		got_lock=$?
 		echo "$0:$LINENO: Pid ${mypid} got_lock=${got_lock} ${n}"
-		nowtime=$(date +%s)
+		nowtime=$(clock -monotonic)
 		elapsed=$((${nowtime} - ${time}))
 		[ "${elapsed}" -le 7 ]
 		assert 0 $? "$0:$LINENO: Lock slept too long elapsed=${elapsed} ${n}"
@@ -86,11 +86,11 @@ until [ "${n}" -eq "${max}" ]; do
 	pid_unlock3=$!
 	(
 		mypid=$(sh -c 'echo $PPID')
-		time=$(date +%s)
+		time=$(clock -monotonic)
 		locked_mkdir 5 "${LOCK1}" "${mypid}"
 		got_lock=$?
 		echo "$0:$LINENO: Pid ${mypid} got_lock=${got_lock} ${n}"
-		nowtime=$(date +%s)
+		nowtime=$(clock -monotonic)
 		elapsed=$((${nowtime} - ${time}))
 		[ "${elapsed}" -le 7 ]
 		assert 0 $? "$0:$LINENO: Lock slept too long elapsed=${elapsed} ${n}"
@@ -125,7 +125,7 @@ until [ "${n}" -eq "${max}" ]; do
 	_wait "${pid_unlock4}"
 	status_unlock4=$?
 
-	nowtime=$(date +%s)
+	nowtime=$(clock -monotonic)
 
 	assert $((75 * 3)) $((status_unlock1 + status_unlock2 + status_unlock3 + \
 		status_unlock4)) "$0:$LINENO: 3 waiters should timeout on lock and 1 should win ${n}"
@@ -147,13 +147,13 @@ until [ "${n}" -eq "${max}" ]; do
 	# dir since children are all dead.
 	[ -d "${LOCK1}" ]
 	assert 0 $? "$0:$LINENO: Lock dir should exist ${n}"
-	time=$(date +%s)
+	time=$(clock -monotonic)
 	locked_mkdir 2 ${LOCK1} $$
 	assert 0 $? "$0:$LINENO: Unlocked dir should succeed to lock ${n}"
 	[ -d "${LOCK1}" ]
 	assert 0 $? "$0:$LINENO: Lock dir should exist ${n}"
 	assert_pid "$0:$LINENO" "${LOCK1}" "$$"
-	nowtime=$(date +%s)
+	nowtime=$(clock -monotonic)
 	elapsed=$((${nowtime} - ${time}))
 	[ "${elapsed}" -lt 4 ]
 	assert 0 $? "$0:$LINENO: Unlocked dir should not wait to lock ${n}"
diff --git a/test/locked_mkdir_waiters_all_lose.sh b/test/locked_mkdir_waiters_all_lose.sh
index b08de58a..9f7b4c6b 100644
--- a/test/locked_mkdir_waiters_all_lose.sh
+++ b/test/locked_mkdir_waiters_all_lose.sh
@@ -14,11 +14,11 @@ until [ "${n}" -eq "${max}" ]; do
 	assert_not 0 $? "$0:$LINENO: Lock dir should not exist"
 
 	echo "$0:$LINENO: Parent pid $$ has lock ${n}"
-	time=$(date +%s)
+	time=$(clock -monotonic)
 	locked_mkdir 0 ${LOCK1} $$
 	assert 0 $? "$0:$LINENO: Lock should succeed"
 	assert_pid "$0:$LINENO" "${LOCK1}" "$$"
-	nowtime=$(date +%s)
+	nowtime=$(clock -monotonic)
 	elapsed=$((${nowtime} - ${time}))
 	[ "${elapsed}" -le 3 ]
 	assert 0 $? "$0:$LINENO: Lock shouldn't sleep elapsed=${elapsed} ${n}"
@@ -26,11 +26,11 @@ until [ "${n}" -eq "${max}" ]; do
 	# Background waiters
 	(
 		mypid=$(sh -c 'echo $PPID')
-		time=$(date +%s)
+		time=$(clock -monotonic)
 		locked_mkdir 5 "${LOCK1}" "${mypid}"
 		got_lock=$?
 		echo "$0:$LINENO: Pid ${mypid} got_lock=${got_lock} ${n}"
-		nowtime=$(date +%s)
+		nowtime=$(clock -monotonic)
 		elapsed=$((${nowtime} - ${time}))
 		[ "${elapsed}" -le 7 ]
 		assert 0 $? "$0:$LINENO: Lock slept too long elapsed=${elapsed} ${n}"
@@ -46,11 +46,11 @@ until [ "${n}" -eq "${max}" ]; do
 	pid_unlock1=$!
 	(
 		mypid=$(sh -c 'echo $PPID')
-		time=$(date +%s)
+		time=$(clock -monotonic)
 		locked_mkdir 5 "${LOCK1}" "${mypid}"
 		got_lock=$?
 		echo "$0:$LINENO: Pid ${mypid} got_lock=${got_lock} ${n}"
-		nowtime=$(date +%s)
+		nowtime=$(clock -monotonic)
 		elapsed=$((${nowtime} - ${time}))
 		[ "${elapsed}" -le 7 ]
 		assert 0 $? "$0:$LINENO: Lock slept too long elapsed=${elapsed} ${n}"
@@ -66,11 +66,11 @@ until [ "${n}" -eq "${max}" ]; do
 	pid_unlock2=$!
 	(
 		mypid=$(sh -c 'echo $PPID')
-		time=$(date +%s)
+		time=$(clock -monotonic)
 		locked_mkdir 5 "${LOCK1}" "${mypid}"
 		got_lock=$?
 		echo "$0:$LINENO: Pid ${mypid} got_lock=${got_lock} ${n}"
-		nowtime=$(date +%s)
+		nowtime=$(clock -monotonic)
 		elapsed=$((${nowtime} - ${time}))
 		[ "${elapsed}" -le 7 ]
 		assert 0 $? "$0:$LINENO: Lock slept too long elapsed=${elapsed} ${n}"
@@ -86,11 +86,11 @@ until [ "${n}" -eq "${max}" ]; do
 	pid_unlock3=$!
 	(
 		mypid=$(sh -c 'echo $PPID')
-		time=$(date +%s)
+		time=$(clock -monotonic)
 		locked_mkdir 5 "${LOCK1}" "${mypid}"
 		got_lock=$?
 		echo "$0:$LINENO: Pid ${mypid} got_lock=${got_lock} ${n}"
-		nowtime=$(date +%s)
+		nowtime=$(clock -monotonic)
 		elapsed=$((${nowtime} - ${time}))
 		[ "${elapsed}" -le 7 ]
 		assert 0 $? "$0:$LINENO: Lock slept too long elapsed=${elapsed} ${n}"
@@ -115,7 +115,7 @@ until [ "${n}" -eq "${max}" ]; do
 	_wait "${pid_unlock4}"
 	status_unlock4=$?
 
-	nowtime=$(date +%s)
+	nowtime=$(clock -monotonic)
 
 	assert $((75 * 4)) $((status_unlock1 + status_unlock2 + status_unlock3 + \
 		status_unlock4)) "$0:$LINENO: 4 waiters should timeout on lock ${n}"
diff --git a/test/locked_mkdir_waiters_kill.sh b/test/locked_mkdir_waiters_kill.sh
index 35713093..3e962685 100644
--- a/test/locked_mkdir_waiters_kill.sh
+++ b/test/locked_mkdir_waiters_kill.sh
@@ -15,11 +15,11 @@ until [ "${n}" -eq "${max}" ]; do
 	assert_not 0 $? "$0:$LINENO: Lock dir should not exist"
 
 	echo "$0:$LINENO: Parent pid $$ has lock ${n}"
-	time=$(date +%s)
+	time=$(clock -monotonic)
 	locked_mkdir 0 ${LOCK1} $$
 	assert 0 $? "$0:$LINENO: Lock should succeed"
 	assert_pid "$0:$LINENO" "${LOCK1}" "$$"
-	nowtime=$(date +%s)
+	nowtime=$(clock -monotonic)
 	elapsed=$((${nowtime} - ${time}))
 	[ "${elapsed}" -le 3 ]
 	assert 0 $? "$0:$LINENO: Lock shouldn't sleep elapsed=${elapsed} ${n}"
@@ -30,11 +30,11 @@ until [ "${n}" -eq "${max}" ]; do
 		got_lock=66
 		trap 'exit ${got_lock}' TERM
 		mypid=$(sh -c 'echo $PPID')
-		time=$(date +%s)
+		time=$(clock -monotonic)
 		locked_mkdir 10 "${LOCK1}" "${mypid}"
 		got_lock=$?
 		echo "$0:$LINENO: Pid ${mypid} got_lock=${got_lock} ${n}"
-		nowtime=$(date +%s)
+		nowtime=$(clock -monotonic)
 		elapsed=$((${nowtime} - ${time}))
 		[ "${elapsed}" -le 12 ]
 		assert 0 $? "$0:$LINENO: Lock slept too long elapsed=${elapsed} ${n}"
@@ -53,11 +53,11 @@ until [ "${n}" -eq "${max}" ]; do
 		got_lock=66
 		trap 'exit ${got_lock}' TERM
 		mypid=$(sh -c 'echo $PPID')
-		time=$(date +%s)
+		time=$(clock -monotonic)
 		locked_mkdir 10 "${LOCK1}" "${mypid}"
 		got_lock=$?
 		echo "$0:$LINENO: Pid ${mypid} got_lock=${got_lock} ${n}"
-		nowtime=$(date +%s)
+		nowtime=$(clock -monotonic)
 		elapsed=$((${nowtime} - ${time}))
 		[ "${elapsed}" -le 12 ]
 		assert 0 $? "$0:$LINENO: Lock slept too long elapsed=${elapsed} ${n}"
@@ -76,11 +76,11 @@ until [ "${n}" -eq "${max}" ]; do
 		got_lock=66
 		trap 'exit ${got_lock}' TERM
 		mypid=$(sh -c 'echo $PPID')
-		time=$(date +%s)
+		time=$(clock -monotonic)
 		locked_mkdir 10 "${LOCK1}" "${mypid}"
 		got_lock=$?
 		echo "$0:$LINENO: Pid ${mypid} got_lock=${got_lock} ${n}"
-		nowtime=$(date +%s)
+		nowtime=$(clock -monotonic)
 		elapsed=$((${nowtime} - ${time}))
 		[ "${elapsed}" -le 12 ]
 		assert 0 $? "$0:$LINENO: Lock slept too long elapsed=${elapsed} ${n}"
@@ -99,11 +99,11 @@ until [ "${n}" -eq "${max}" ]; do
 		got_lock=66
 		trap 'exit ${got_lock}' TERM
 		mypid=$(sh -c 'echo $PPID')
-		time=$(date +%s)
+		time=$(clock -monotonic)
 		locked_mkdir 10 "${LOCK1}" "${mypid}"
 		got_lock=$?
 		echo "$0:$LINENO: Pid ${mypid} got_lock=${got_lock} ${n}"
-		nowtime=$(date +%s)
+		nowtime=$(clock -monotonic)
 		elapsed=$((${nowtime} - ${time}))
 		[ "${elapsed}" -le 12 ]
 		assert 0 $? "$0:$LINENO: Lock slept too long elapsed=${elapsed} ${n}"
@@ -178,7 +178,7 @@ until [ "${n}" -eq "${max}" ]; do
 		status_unlock4=$?
 	fi
 
-	nowtime=$(date +%s)
+	nowtime=$(clock -monotonic)
 
 	assert $(((75 * 2))) $((status_unlock1 + status_unlock2 + status_unlock3 + \
 		status_unlock4)) "$0:$LINENO: 2 waiters should timeout on lock, 1 should win, 1 should be OK after TERMed after winning ${n}"
@@ -199,13 +199,13 @@ until [ "${n}" -eq "${max}" ]; do
 	# dir since children are all dead.
 	[ -d "${LOCK1}" ]
 	assert 0 $? "$0:$LINENO: Lock dir should exist ${n}"
-	time=$(date +%s)
+	time=$(clock -monotonic)
 	locked_mkdir 2 ${LOCK1} $$
 	assert 0 $? "$0:$LINENO: Unlocked dir should succeed to lock ${n}"
 	[ -d "${LOCK1}" ]
 	assert 0 $? "$0:$LINENO: Lock dir should exist ${n}"
 	assert_pid "$0:$LINENO" "${LOCK1}" "$$"
-	nowtime=$(date +%s)
+	nowtime=$(clock -monotonic)
 	elapsed=$((${nowtime} - ${time}))
 	[ "${elapsed}" -lt 4 ]
 	assert 0 $? "$0:$LINENO: Unlocked dir should not wait to lock ${n}"
diff --git a/test/locks.sh b/test/locks.sh
index 6e9be91e..20630fd0 100644
--- a/test/locks.sh
+++ b/test/locks.sh
@@ -7,10 +7,10 @@ set +e
 
 # Acquire TEST
 {
-	time=$(date +%s)
+	time=$(clock -monotonic)
 	lock_acquire TEST ${SLEEPTIME}
 	assert 0 $? "lock_acquire failed"
-	nowtime=$(date +%s)
+	nowtime=$(clock -monotonic)
 	elapsed=$((${nowtime} - ${time}))
 	if [ ${elapsed} -ge ${SLEEPTIME} ]; then
 		result=slept
@@ -28,10 +28,10 @@ set +e
 	lock_have TEST2
 	assert 1 $? "lock_have(TEST2) should be false"
 
-	time=$(date +%s)
+	time=$(clock -monotonic)
 	lock_acquire TEST2 ${SLEEPTIME}
 	assert 0 $? "lock_acquire failed"
-	nowtime=$(date +%s)
+	nowtime=$(clock -monotonic)
 	elapsed=$((${nowtime} - ${time}))
 	if [ ${elapsed} -ge ${SLEEPTIME} ]; then
 		result=slept
@@ -45,10 +45,10 @@ set +e
 # XXX: Recursion is allowed now
 false &&
 {
-	time=$(date +%s)
+	time=$(clock -monotonic)
 	lock_acquire TEST ${SLEEPTIME}
 	assert 1 $? "lock TEST acquired but should be held"
-	nowtime=$(date +%s)
+	nowtime=$(clock -monotonic)
 	elapsed=$((${nowtime} - ${time}))
 	if [ ${elapsed} -ge ${SLEEPTIME} ]; then
 		result=slept
@@ -73,10 +73,10 @@ false &&
 
 # Reacquire TEST to ensure it was released
 {
-	time=$(date +%s)
+	time=$(clock -monotonic)
 	lock_acquire TEST ${SLEEPTIME}
 	assert 0 $? "lock_acquire failed"
-	nowtime=$(date +%s)
+	nowtime=$(clock -monotonic)
 	elapsed=$((${nowtime} - ${time}))
 	if [ ${elapsed} -ge ${SLEEPTIME} ]; then
 		result=slept
@@ -93,10 +93,10 @@ false &&
 
 # Reacquire TEST2 to ensure it was released
 {
-	time=$(date +%s)
+	time=$(clock -monotonic)
 	lock_acquire TEST2 ${SLEEPTIME}
 	assert 0 $? "lock_acquire failed"
-	nowtime=$(date +%s)
+	nowtime=$(clock -monotonic)
 	elapsed=$((${nowtime} - ${time}))
 	if [ ${elapsed} -ge ${SLEEPTIME} ]; then
 		result=slept
diff --git a/test/locks_critical_section.sh b/test/locks_critical_section.sh
index 32de5012..3d0487e5 100644
--- a/test/locks_critical_section.sh
+++ b/test/locks_critical_section.sh
@@ -29,10 +29,10 @@ assert 1 ${main_siginfo} "INFO should be trapped"
 
 # Acquire TEST
 {
-	time=$(date +%s)
+	time=$(clock -monotonic)
 	lock_acquire TEST ${SLEEPTIME}
 	assert 0 $? "lock_acquire failed"
-	nowtime=$(date +%s)
+	nowtime=$(clock -monotonic)
 	elapsed=$((${nowtime} - ${time}))
 	if [ ${elapsed} -ge ${SLEEPTIME} ]; then
 		result=slept
diff --git a/test/locks_critical_section_nested.sh b/test/locks_critical_section_nested.sh
index 754334ed..db313394 100644
--- a/test/locks_critical_section_nested.sh
+++ b/test/locks_critical_section_nested.sh
@@ -30,10 +30,10 @@ assert 1 ${main_siginfo} "INFO should be trapped"
 
 # Acquire TEST
 {
-	time=$(date +%s)
+	time=$(clock -monotonic)
 	lock_acquire TEST ${SLEEPTIME}
 	assert 0 $? "lock_acquire failed"
-	nowtime=$(date +%s)
+	nowtime=$(clock -monotonic)
 	elapsed=$((${nowtime} - ${time}))
 	if [ ${elapsed} -ge ${SLEEPTIME} ]; then
 		result=slept
@@ -48,10 +48,10 @@ assert 1 ${main_siginfo} "INFO should be trapped"
 
 # Acquire TEST2
 {
-	time=$(date +%s)
+	time=$(clock -monotonic)
 	lock_acquire TEST2 ${SLEEPTIME}
 	assert 0 $? "lock_acquire failed"
-	nowtime=$(date +%s)
+	nowtime=$(clock -monotonic)
 	elapsed=$((${nowtime} - ${time}))
 	if [ ${elapsed} -ge ${SLEEPTIME} ]; then
 		result=slept