diff options
Diffstat (limited to 'tests/bugs/glusterfs')
24 files changed, 1350 insertions, 0 deletions
diff --git a/tests/bugs/glusterfs/bug-811493.t b/tests/bugs/glusterfs/bug-811493.t new file mode 100755 index 00000000000..98f7c121a02 --- /dev/null +++ b/tests/bugs/glusterfs/bug-811493.t @@ -0,0 +1,18 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc + +cleanup; + +TEST glusterd +TEST pidof glusterd +TEST $CLI system uuid reset; + +uuid1=$(grep UUID $GLUSTERD_WORKDIR/glusterd.info | cut -f 2 -d "="); + +TEST $CLI system uuid reset; +uuid2=$(grep UUID $GLUSTERD_WORKDIR/glusterd.info | cut -f 2 -d "="); + +TEST [ $uuid1 != $uuid2 ] + +cleanup diff --git a/tests/bugs/glusterfs/bug-844688.t b/tests/bugs/glusterfs/bug-844688.t new file mode 100755 index 00000000000..a1b0b15f5ed --- /dev/null +++ b/tests/bugs/glusterfs/bug-844688.t @@ -0,0 +1,34 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc +. $(dirname $0)/../../volume.rc + +cleanup; + +TEST glusterd +TEST pidof glusterd +TEST $CLI volume create $V0 $H0:$B0/brick0 +TEST $CLI volume start $V0 +TEST glusterfs -s $H0 --volfile-id $V0 $M0 + +mount_pid=$(get_mount_process_pid $V0); +# enable dumping of call stack creation and frame creation times in statedump +kill -USR2 $mount_pid; + +TEST touch $M0/touchfile; +(dd if=/dev/urandom of=$M0/file bs=5k 2>/dev/null 1>/dev/null)& +back_pid=$!; +statedump_file=$(generate_mount_statedump $V0); +grep "callstack-creation-time" $statedump_file 2>/dev/null 1>/dev/null; +TEST [ $? -eq 0 ]; +grep "frame-creation-time" $statedump_file 2>/dev/null 1>/dev/null; +TEST [ $? -eq 0 ]; + +kill -SIGTERM $back_pid; +wait >/dev/null 2>&1; + +TEST rm -f $M0/touchfile $M0/file; +EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0 + +rm -f $statedumpdir/glusterdump.$mount_pid.*; +cleanup diff --git a/tests/bugs/glusterfs/bug-848251.t b/tests/bugs/glusterfs/bug-848251.t new file mode 100644 index 00000000000..b44ec9d9bf2 --- /dev/null +++ b/tests/bugs/glusterfs/bug-848251.t @@ -0,0 +1,51 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc +. $(dirname $0)/../../volume.rc + +cleanup; + +TEST glusterd +TEST pidof glusterd +TEST $CLI volume info; + +TEST $CLI volume create $V0 $H0:$B0/brick1; + +TEST $CLI volume start $V0; + +#enable quota +TEST $CLI volume quota $V0 enable; + +#mount on a random dir +TEST MOUNTDIR="/tmp/$RANDOM" +TEST mkdir $MOUNTDIR +TEST glusterfs -s $H0 --volfile-id=$V0 $MOUNTDIR + +function set_quota(){ + mkdir "$MOUNTDIR/$name" + $CLI volume quota $V0 limit-usage /$name 50KB +} + +function quota_list(){ + $CLI volume quota $V0 list | grep -- /$name | awk '{print $3}' +} + +TEST name=":d1" +#file name containing ':' in the start +TEST set_quota +EXPECT "80%" quota_list + +TEST name=":d1/d:1" +#file name containing ':' in between +TEST set_quota +EXPECT "80%" quota_list + +TEST name=":d1/d:1/d1:" +#file name containing ':' in the end +TEST set_quota +EXPECT "80%" quota_list + +EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $MOUNTDIR +TEST rm -rf $MOUNTDIR + +cleanup; diff --git a/tests/bugs/glusterfs/bug-853690.t b/tests/bugs/glusterfs/bug-853690.t new file mode 100755 index 00000000000..d81be011438 --- /dev/null +++ b/tests/bugs/glusterfs/bug-853690.t @@ -0,0 +1,91 @@ +#!/bin/bash +# +# Bug 853690 - Test that short writes do not lead to corruption. +# +# Mismanagement of short writes in AFR leads to corruption and immediately +# detectable split-brain. Write a file to a replica volume using error-gen +# to cause short writes on one replica. +# +# Short writes are also possible during heal. If ignored, the files are marked +# consistent and silently differ. After reading the file, cause a lookup, wait +# for self-heal and verify that the afr xattrs do not match. +# +######## + +. $(dirname $0)/../../include.rc +. $(dirname $0)/../../volume.rc + +cleanup; + +TEST mkdir -p $B0/test{1,2} + +# Our graph is a two brick replica with 100% frequency of short writes on one +# side of the replica. This guarantees a single write fop leads to an out-of-sync +# situation. +cat > $B0/test.vol <<EOF +volume test-posix-0 + type storage/posix + option directory $B0/test1 +end-volume + +volume test-error-0 + type debug/error-gen + option failure 100 + option enable writev + option error-no GF_ERROR_SHORT_WRITE + subvolumes test-posix-0 +end-volume + +volume test-locks-0 + type features/locks + subvolumes test-error-0 +end-volume + +volume test-posix-1 + type storage/posix + option directory $B0/test2 +end-volume + +volume test-locks-1 + type features/locks + subvolumes test-posix-1 +end-volume + +volume test-replicate-0 + type cluster/replicate + option background-self-heal-count 0 + subvolumes test-locks-0 test-locks-1 +end-volume +EOF + +TEST glusterd + +TEST glusterfs --volfile=$B0/test.vol --attribute-timeout=0 --entry-timeout=0 $M0 + +# Send a single write, guaranteed to be short on one replica, and attempt to +# read the data back. Failure to detect the short write results in different +# file sizes and immediate split-brain (EIO). +TEST dd if=/dev/zero of=$M0/file bs=128k count=1 +TEST dd if=$M0/file of=/dev/null bs=128k count=1 +######## +# +# Test self-heal with short writes... +# +######## + +# Cause a lookup and wait a few seconds for posterity. This self-heal also fails +# due to a short write. +TEST ls $M0/file +# Verify the attributes on the healthy replica do not reflect consistency with +# the other replica. +xa=`getfattr -n trusted.afr.test-locks-0 -e hex $B0/test2/file 2>&1 | grep = | cut -f2 -d=` +EXPECT_NOT 0x000000000000000000000000 echo $xa + +TEST rm -f $M0/file +EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0 + +rm -f $B0/test.vol +rm -rf $B0/test1 $B0/test2 + +cleanup; + diff --git a/tests/bugs/glusterfs/bug-856455.t b/tests/bugs/glusterfs/bug-856455.t new file mode 100644 index 00000000000..25a30bfda48 --- /dev/null +++ b/tests/bugs/glusterfs/bug-856455.t @@ -0,0 +1,42 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc + +cleanup; + +BRICK_COUNT=3 + +TEST glusterd +TEST pidof glusterd + +TEST $CLI volume create $V0 $H0:$B0/${V0}0 $H0:$B0/${V0}1 $H0:$B0/${V0}2 +TEST $CLI volume start $V0 + +## Mount FUSE with caching disabled +TEST $GFS -s $H0 --volfile-id $V0 $M0; + +function query_pathinfo() +{ + local path=$1; + local retval; + + local pathinfo=$(getfattr -n trusted.glusterfs.pathinfo $path); + retval=$(echo $pathinfo | grep -o 'POSIX' | wc -l); + echo $retval +} + +TEST touch $M0/f00f; +TEST mkdir $M0/f00d; + +# verify pathinfo for a file and directory +EXPECT 1 query_pathinfo $M0/f00f; +EXPECT $BRICK_COUNT query_pathinfo $M0/f00d; + +# Kill a brick process and then query for pathinfo +# for directories pathinfo should list backend patch from available (up) subvolumes + +kill -9 `cat $GLUSTERD_WORKDIR/vols/$V0/run/$H0-d-backends-${V0}1.pid`; + +EXPECT `expr $BRICK_COUNT - 1` query_pathinfo $M0/f00d; + +cleanup; diff --git a/tests/bugs/glusterfs/bug-860297.t b/tests/bugs/glusterfs/bug-860297.t new file mode 100644 index 00000000000..c2d21553f68 --- /dev/null +++ b/tests/bugs/glusterfs/bug-860297.t @@ -0,0 +1,13 @@ +#!/bin/bash +. $(dirname $0)/../../include.rc +cleanup; + +TEST glusterd +TEST pidof glusterd +TEST $CLI volume info +TEST $CLI volume create $V0 $H0:$B0/brick1 +setfattr -x trusted.glusterfs.volume-id $B0/brick1 +## If Extended attribute trusted.glusterfs.volume-id is not present +## then volume should not be able to start +TEST ! $CLI volume start $V0; +cleanup; diff --git a/tests/bugs/glusterfs/bug-861015-index.t b/tests/bugs/glusterfs/bug-861015-index.t new file mode 100644 index 00000000000..05f3e8b1ee0 --- /dev/null +++ b/tests/bugs/glusterfs/bug-861015-index.t @@ -0,0 +1,36 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc +. $(dirname $0)/../../volume.rc + +cleanup; + +TEST glusterd +TEST pidof glusterd +TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1,2,3,4,5} +TEST $CLI volume set $V0 ensure-durability off +TEST $CLI volume start $V0 +EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" glustershd_up_status +TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0 --attribute-timeout=0 --entry-timeout=0 +TEST kill_brick $V0 $H0 $B0/${V0}0 +TEST kill_brick $V0 $H0 $B0/${V0}2 +TEST kill_brick $V0 $H0 $B0/${V0}4 +cd $M0 +HEAL_FILES=0 +for i in {1..10} +do + echo "abc" > $i + HEAL_FILES=$(($HEAL_FILES+1)) +done +HEAL_FILES=$(($HEAL_FILES+3)) #count brick root distribute-subvol num of times + +cd ~ +EXPECT "$HEAL_FILES" afr_get_pending_heal_count $V0 +TEST rm -f $M0/* +EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0 +TEST $CLI volume heal $V0 info +#Only root dir should be present now in the indices +EXPECT "1" afr_get_num_indices_in_brick $B0/${V0}1 +EXPECT "1" afr_get_num_indices_in_brick $B0/${V0}3 +EXPECT "1" afr_get_num_indices_in_brick $B0/${V0}5 +cleanup diff --git a/tests/bugs/glusterfs/bug-861015-log.t b/tests/bugs/glusterfs/bug-861015-log.t new file mode 100644 index 00000000000..2f3e0ad14f4 --- /dev/null +++ b/tests/bugs/glusterfs/bug-861015-log.t @@ -0,0 +1,29 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc +. $(dirname $0)/../../volume.rc + +cleanup; + +log_wd=$(gluster --print-logdir) +TEST glusterd +TEST pidof glusterd +rm -f $log_wd/glustershd.log +TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1} +TEST $CLI volume start $V0 +TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0 --attribute-timeout=0 --entry-timeout=0 +TEST kill_brick $V0 $H0 $B0/${V0}0 +cd $M0 +for i in {1..10} +do + dd if=/dev/urandom of=f bs=1024k count=10 2>/dev/null +done + +cd ~ +TEST $CLI volume heal $V0 info +function count_inode_link_failures { + logfile=$1 + grep "inode link failed on the inode" $logfile | wc -l +} +EXPECT "0" count_inode_link_failures $log_wd/glustershd.log +cleanup diff --git a/tests/bugs/glusterfs/bug-866459.t b/tests/bugs/glusterfs/bug-866459.t new file mode 100644 index 00000000000..f90aa3fdc08 --- /dev/null +++ b/tests/bugs/glusterfs/bug-866459.t @@ -0,0 +1,45 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc +. $(dirname $0)/../../volume.rc + +cleanup; + + +## Start and create a volume +TEST glusterd +TEST pidof glusterd +TEST $CLI volume info; + +## Create and start a volume with aio enabled +TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{1,2}; +TEST $CLI volume set $V0 linux-aio on +TEST $CLI volume set $V0 background-self-heal-count 0 +TEST $CLI volume set $V0 performance.stat-prefetch off; +TEST $CLI volume start $V0 + +## Mount FUSE with caching disabled +TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id $V0 $M0; + +dd of=$M0/a if=/dev/urandom bs=1024k count=1 2>&1 > /dev/null +B0_hiphenated=`echo $B0 | tr '/' '-'` +## Bring a brick down +TEST kill_brick $V0 $H0 $B0/${V0}1 +EXPECT '1' echo `pgrep glusterfsd | wc -l` +## Rewrite the file +dd of=$M0/a if=/dev/urandom bs=1024k count=1 2>&1 > /dev/null +TEST $CLI volume start $V0 force +## Wait for the brick to give CHILD_UP in client protocol +EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0 +md5offile2=`md5sum $B0/${V0}2/a | awk '{print $1}'` + +##trigger self-heal +ls -l $M0/a + +EXPECT "$md5offile2" echo `md5sum $B0/${V0}1/a | awk '{print $1}'` + +## Finish up +TEST $CLI volume stop $V0; +TEST $CLI volume delete $V0; + +cleanup; diff --git a/tests/bugs/glusterfs/bug-867253.t b/tests/bugs/glusterfs/bug-867253.t new file mode 100644 index 00000000000..3df49a1bd61 --- /dev/null +++ b/tests/bugs/glusterfs/bug-867253.t @@ -0,0 +1,69 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc +. $(dirname $0)/../../volume.rc +. $(dirname $0)/../../nfs.rc + +# Skip the entire test if /proc/sys/vm/drop_caches does not exist +if [ ! -f /proc/sys/vm/drop_caches ] ; then + echo "Skip test using /proc/sys/vm/drop_caches, "\ + "which does not exists on this system" >&2 + SKIP_TESTS + exit 0 +fi + +cleanup; + +function file_count() +{ + val=1 + + if [ "$1" == "0" ] + then + if [ "$2" == "0" ] + then + val=0 + fi + fi + echo $val +} + +BRICK_COUNT=2 + +TEST glusterd +TEST pidof glusterd + +TEST $CLI volume create $V0 $H0:$B0/${V0}0 $H0:$B0/${V0}1 +TEST $CLI volume start $V0 + +EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available; +## Mount nfs, with nocache option +TEST mount_nfs $H0:/$V0 $M0 nolock,noac; + +touch $M0/files{1..1000}; + +# Kill a brick process +kill -9 `cat $GLUSTERD_WORKDIR/vols/$V0/run/$H0-d-backends-${V0}0.pid`; + +echo 3 >/proc/sys/vm/drop_caches; + +ls -l $M0 >/dev/null; + +NEW_FILE_COUNT=`echo $?`; + +TEST $CLI volume start $V0 force + +# Kill a brick process +kill -9 `cat $GLUSTERD_WORKDIR/vols/$V0/run/$H0-d-backends-${V0}1.pid`; + +echo 3 >/proc/sys/vm/drop_caches; + +ls -l $M0 >/dev/null; + +NEW_FILE_COUNT1=`echo $?`; + +EXPECT "0" file_count $NEW_FILE_COUNT $NEW_FILE_COUNT1 + +EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0 + +cleanup diff --git a/tests/bugs/glusterfs/bug-869724.t b/tests/bugs/glusterfs/bug-869724.t new file mode 100644 index 00000000000..ca5bb17081c --- /dev/null +++ b/tests/bugs/glusterfs/bug-869724.t @@ -0,0 +1,37 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc + +cleanup; + + +## Start and create a volume +TEST glusterd +TEST pidof glusterd + +TEST $CLI volume create $V0 $H0:$B0/${V0}1; + +## Verify volume is is created +EXPECT "$V0" volinfo_field $V0 'Volume Name'; +EXPECT 'Created' volinfo_field $V0 'Status'; + + +## Start volume and verify +TEST $CLI volume start $V0; +EXPECT 'Started' volinfo_field $V0 'Status'; + + +## Make volume tightly consistent for metdata +TEST $CLI volume set $V0 performance.stat-prefetch off; + +## Mount FUSE with caching disabled +TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id $V0 $M0; + +touch $M0/test; +build_tester $(dirname $0)/getlk_owner.c + +TEST $(dirname $0)/getlk_owner $M0/test; + +rm -f $(dirname $0)/getlk_owner +cleanup; + diff --git a/tests/bugs/glusterfs/bug-872923.t b/tests/bugs/glusterfs/bug-872923.t new file mode 100755 index 00000000000..de24117a037 --- /dev/null +++ b/tests/bugs/glusterfs/bug-872923.t @@ -0,0 +1,56 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc +. $(dirname $0)/../../volume.rc +. $(dirname $0)/../../nfs.rc + +cleanup; + +TEST glusterd +TEST pidof glusterd +TEST $CLI volume info +TEST $CLI volume create $V0 replica 2 $H0:$B0/brick0 $H0:$B0/brick1 +TEST $CLI volume start $V0 + +EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available; +TEST mount_nfs $H0:/$V0 $N0 nolock + +cd $N0 +mkdir test_hardlink_self_heal; +cd test_hardlink_self_heal; + +for i in `seq 1 5`; +do + mkdir dir.$i; + for j in `seq 1 10`; + do + dd if=/dev/zero of=dir.$i/file.$j bs=1k count=$j > /dev/null 2>&1; + done; +done; + +cd .. +TEST kill_brick $V0 $H0 $B0/brick0 +cd test_hardlink_self_heal; + +RET=0 +for i in `seq 1 5`; +do + for j in `seq 1 10`; + do + ln dir.$i/file.$j dir.$i/link_file.$j > /dev/null 2>&1; + RET=$? + if [ $RET -ne 0 ]; then + break; + fi + done ; + if [ $RET -ne 0 ]; then + break; + fi +done; + +cd +EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N0 + +EXPECT "0" echo $RET; + +cleanup; diff --git a/tests/bugs/glusterfs/bug-873962-spb.t b/tests/bugs/glusterfs/bug-873962-spb.t new file mode 100644 index 00000000000..db84a223089 --- /dev/null +++ b/tests/bugs/glusterfs/bug-873962-spb.t @@ -0,0 +1,39 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc +. $(dirname $0)/../../volume.rc + +cleanup; +TEST glusterd +TEST pidof glusterd + +TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1} +TEST $CLI volume set $V0 cluster.self-heal-daemon off +TEST $CLI volume set $V0 performance.quick-read off +TEST $CLI volume set $V0 performance.io-cache off +TEST $CLI volume set $V0 performance.write-behind off +TEST $CLI volume set $V0 performance.stat-prefetch off +TEST $CLI volume set $V0 performance.read-ahead off +TEST $CLI volume set $V0 cluster.background-self-heal-count 0 +TEST $CLI volume start $V0 +TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id=$V0 $M0 --direct-io-mode=enable +touch $M0/a + +exec 5<$M0/a + +kill_brick $V0 $H0 $B0/${V0}0 +echo "hi" > $M0/a +TEST $CLI volume start $V0 force +EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0 + +kill_brick $V0 $H0 $B0/${V0}1 +echo "bye" > $M0/a +TEST $CLI volume start $V0 force +EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 1 + +TEST ! cat $M0/a #To mark split-brain + +TEST ! read -u 5 line +exec 5<&- + +cleanup; diff --git a/tests/bugs/glusterfs/bug-873962.t b/tests/bugs/glusterfs/bug-873962.t new file mode 100755 index 00000000000..492d0285497 --- /dev/null +++ b/tests/bugs/glusterfs/bug-873962.t @@ -0,0 +1,107 @@ +#!/bin/bash + +#AFR TEST-IDENTIFIER SPLIT-BRAIN +. $(dirname $0)/../../include.rc +. $(dirname $0)/../../volume.rc + +cleanup; + +TEST glusterd +TEST pidof glusterd +TEST $CLI volume info; + +B0_hiphenated=`echo $B0 | tr '/' '-'` +TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{1,2} + +# If we allow self-heal to happen in the background, we'll get spurious +# failures - especially at the point labeled "FAIL HERE" but +# occasionally elsewhere. This behavior is very timing-dependent. It +# doesn't show up in Jenkins, but it does on JD's and KP's machines, and +# it got sharply worse because of an unrelated fsync change (6ae6f3d) +# which changed timing. Putting anything at the FAIL HERE marker tends +# to make it go away most of the time on affected machines, even if the +# "anything" is unrelated. +# +# What's going on is that the I/O on the first mountpoint is allowed to +# complete even though self-heal is still in progress and the state on +# disk does not reflect its result. In fact, the state changes during +# self-heal create the appearance of split brain when the second I/O +# comes in, so that fails even though we haven't actually been in split +# brain since the manual xattr operations. By disallowing background +# self-heal, we ensure that the second I/O can't happen before self-heal +# is complete, because it has to follow the first I/O which now has to +# follow self-heal. +TEST $CLI volume set $V0 cluster.background-self-heal-count 0 + +#Make sure self-heal is not triggered when the bricks are re-started +TEST $CLI volume set $V0 cluster.self-heal-daemon off +TEST $CLI volume set $V0 performance.stat-prefetch off +TEST $CLI volume start $V0 +TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id=$V0 $M0 --direct-io-mode=enable +TEST touch $M0/a +TEST touch $M0/b +TEST touch $M0/c +TEST touch $M0/d +echo "1" > $M0/b +echo "1" > $M0/d +TEST kill_brick $V0 $H0 $B0/${V0}2 +echo "1" > $M0/a +echo "1" > $M0/c +TEST setfattr -n trusted.mdata -v abc $M0/b +TEST setfattr -n trusted.mdata -v abc $M0/d +TEST $CLI volume start $V0 force +EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 1 +TEST kill_brick $V0 $H0 $B0/${V0}1 +echo "2" > $M0/a +echo "2" > $M0/c +TEST setfattr -n trusted.mdata -v def $M0/b +TEST setfattr -n trusted.mdata -v def $M0/d +TEST $CLI volume start $V0 force +EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 0 +EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 1 + +TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id=$V0 $M1 --direct-io-mode=enable + +#Files are in split-brain, so open should fail +TEST ! cat $M0/a; +TEST ! cat $M1/a; +TEST cat $M0/b; +TEST cat $M1/b; + +#Reset split-brain status +TEST setfattr -n trusted.afr.$V0-client-1 -v 0x000000000000000000000000 $B0/${V0}1/a; +TEST setfattr -n trusted.afr.$V0-client-1 -v 0x000000000000000000000000 $B0/${V0}1/b; + +#The operations should do self-heal and give correct output +EXPECT "2" cat $M0/a; +# FAIL HERE - see comment about cluster.self-heal-background-count above. +EXPECT "2" cat $M1/a; +TEST dd if=$M0/b of=/dev/null bs=1024k +EXPECT "def" getfattr -n trusted.mdata --only-values $M0/b 2>/dev/null +EXPECT "def" getfattr -n trusted.mdata --only-values $M1/b 2>/dev/null + +EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0 +EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M1 + +TEST $CLI volume set $V0 cluster.data-self-heal off +TEST $CLI volume set $V0 cluster.metadata-self-heal off + +TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id=$V0 $M0 --direct-io-mode=enable +TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id=$V0 $M1 --direct-io-mode=enable + +#Files are in split-brain, so open should fail +TEST ! cat $M0/c +TEST ! cat $M1/c +TEST cat $M0/d +TEST cat $M1/d + +TEST setfattr -n trusted.afr.$V0-client-1 -v 0x000000000000000000000000 $B0/${V0}1/c +TEST setfattr -n trusted.afr.$V0-client-1 -v 0x000000000000000000000000 $B0/${V0}1/d + +#The operations should NOT do self-heal but give correct output +EXPECT "2" cat $M0/c +EXPECT "2" cat $M1/c +EXPECT "1" cat $M0/d +EXPECT "1" cat $M1/d + +cleanup; diff --git a/tests/bugs/glusterfs/bug-879490.t b/tests/bugs/glusterfs/bug-879490.t new file mode 100755 index 00000000000..7cec6713654 --- /dev/null +++ b/tests/bugs/glusterfs/bug-879490.t @@ -0,0 +1,37 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc +. $(dirname $0)/../../volume.rc + +cleanup; + +## Start and create a volume +TEST glusterd; +TEST pidof glusterd; +TEST $CLI volume info; + +TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8}; + +## Verify volume is is created +EXPECT "$V0" volinfo_field $V0 'Volume Name'; +EXPECT 'Created' volinfo_field $V0 'Status'; + +## Start volume and verify +TEST $CLI volume start $V0; +EXPECT 'Started' volinfo_field $V0 'Status'; + +function peer_probe() +{ + $CLI peer probe a.b.c.d --xml | xmllint --format - | grep "<opErrstr>" +} + +EXPECT " <opErrstr>Probe returned with unknown errno 107</opErrstr>" peer_probe + +## Finish up +TEST $CLI volume stop $V0; +EXPECT 'Stopped' volinfo_field $V0 'Status'; + +TEST $CLI volume delete $V0; +TEST ! $CLI volume info $V0; + +cleanup; diff --git a/tests/bugs/glusterfs/bug-879494.t b/tests/bugs/glusterfs/bug-879494.t new file mode 100755 index 00000000000..06a5e5d876d --- /dev/null +++ b/tests/bugs/glusterfs/bug-879494.t @@ -0,0 +1,37 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc +. $(dirname $0)/../../volume.rc + +cleanup; + +## Start and create a volume +TEST glusterd; +TEST pidof glusterd; +TEST $CLI volume info; + +TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8}; + +## Verify volume is is created +EXPECT "$V0" volinfo_field $V0 'Volume Name'; +EXPECT 'Created' volinfo_field $V0 'Status'; + +## Start volume and verify +TEST $CLI volume start $V0; +EXPECT 'Started' volinfo_field $V0 'Status'; + +function peer_probe() +{ + $CLI peer detach a.b.c.d --xml | xmllint --format - | grep "<opErrstr>" +} + +EXPECT " <opErrstr>a.b.c.d is not part of cluster</opErrstr>" peer_probe + +## Finish up +TEST $CLI volume stop $V0; +EXPECT 'Stopped' volinfo_field $V0 'Status'; + +TEST $CLI volume delete $V0; +TEST ! $CLI volume info $V0; + +cleanup; diff --git a/tests/bugs/glusterfs/bug-892730.t b/tests/bugs/glusterfs/bug-892730.t new file mode 100755 index 00000000000..a76961134c5 --- /dev/null +++ b/tests/bugs/glusterfs/bug-892730.t @@ -0,0 +1,77 @@ +#!/bin/bash +# +# Bug 892730 - Verify that afr handles EIO errors from the brick properly. +# +# The associated bug describes a problem where EIO errors returned from the +# local filesystem of a brick that is part of a replica volume are exposed to +# the user. This test simulates such failures and verifies that the volume +# operates as expected. +# +######## + +. $(dirname $0)/../../include.rc +. $(dirname $0)/../../volume.rc + +cleanup; + +TEST mkdir -p $B0/test{1,2} + +# The graph is a two brick replica with error-gen enabled on the second brick +# and configured to return EIO lookup errors 100% of the time. This simulates +# a brick with a crashed or shut down local filesystem. Note that the order in +# which errors occur is a factor in reproducing the original bug (error-gen +# must be enabled in the second brick for this test to be effective). + +cat > $B0/test.vol <<EOF +volume test-posix-0 + type storage/posix + option directory $B0/test1 +end-volume + +volume test-locks-0 + type features/locks + subvolumes test-posix-0 +end-volume + +volume test-posix-1 + type storage/posix + option directory $B0/test2 +end-volume + +volume test-error-1 + type debug/error-gen + option failure 100 + option enable lookup + option error-no EIO + subvolumes test-posix-1 +end-volume + +volume test-locks-1 + type features/locks + subvolumes test-error-1 +end-volume + +volume test-replicate-0 + type cluster/replicate + option background-self-heal-count 0 + subvolumes test-locks-0 test-locks-1 +end-volume +EOF + +TEST glusterd + +TEST glusterfs --volfile=$B0/test.vol --attribute-timeout=0 --entry-timeout=0 $M0 + +# We should be able to create and remove a file without interference from the +# "broken" brick. + +TEST touch $M0/file +TEST rm $M0/file + +EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0 + +rm -f $B0/test.vol +rm -rf $B0/test1 $B0/test2 + +cleanup; + diff --git a/tests/bugs/glusterfs/bug-893338.t b/tests/bugs/glusterfs/bug-893338.t new file mode 100644 index 00000000000..0df1b9af2fe --- /dev/null +++ b/tests/bugs/glusterfs/bug-893338.t @@ -0,0 +1,34 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc +. $(dirname $0)/../../volume.rc + +cleanup; + +## Start and create a volume +TEST glusterd; +TEST pidof glusterd; +TEST $CLI volume info; + +TEST $CLI volume create $V0 stripe 2 $H0:$B0/${V0}{1,2,3,4}; + +## Verify volume is is created +EXPECT "$V0" volinfo_field $V0 'Volume Name'; +EXPECT 'Created' volinfo_field $V0 'Status'; + +## Start volume and verify +TEST $CLI volume start $V0; + +TEST glusterfs -s $H0 --volfile-id=$V0 $M0 + +## Test for symlink success +TEST touch $M0/reg_file +TEST ln -s $M0/reg_file $M0/symlink + +## Finish up +TEST $CLI volume stop $V0; +EXPECT 'Stopped' volinfo_field $V0 'Status'; + +TEST $CLI volume delete $V0; + +cleanup; diff --git a/tests/bugs/glusterfs/bug-893378.t b/tests/bugs/glusterfs/bug-893378.t new file mode 100755 index 00000000000..72a23f99e26 --- /dev/null +++ b/tests/bugs/glusterfs/bug-893378.t @@ -0,0 +1,73 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc +cleanup; +BRICK_COUNT=3 + +function file_has_linkfile() +{ + i=0 + j=0 + while [ $i -lt $BRICK_COUNT ] + do + stat=`stat $B0/${V0}$i/$1 2>/dev/null` + if [ $? -eq 0 ] + then + let j++ + let "BRICK${j}=$i" + + fi + let i++ + done + return $j +} + +function get_cached_brick() +{ + i=1 + while [ $i -lt 3 ] + do + test=`getfattr -n trusted.glusterfs.dht.linkto -e text $B0/${V0}$BRICK$i 2>&1` + if [ $? -eq 1 ] + then + cached=$BRICK"$i" + i=$(( $i+3 )) + fi + let i++ + done + + return $cached +} + +TEST glusterd +TEST pidof glusterd + +TEST $CLI volume create $V0 $H0:$B0/${V0}0 $H0:$B0/${V0}1 $H0:$B0/${V0}2 +TEST $CLI volume start $V0 + +## Mount FUSE +TEST glusterfs --attribute-timeout=0 --entry-timeout=0 -s $H0 --volfile-id $V0 $M0; + +## create a linkfile on subvolume 0 +TEST touch $M0/1 +TEST mv $M0/1 $M0/2 + +file_has_linkfile 2 +has_link=$? +if [ $has_link -eq 2 ] +then + get_cached_brick + CACHED=$? + # Kill a brick process + kill -9 `cat $GLUSTERD_WORKDIR/vols/$V0/run/$H0-d-backends-${V0}$CACHED.pid`; +fi + +## trigger a lookup +ls -l $M0/2 2>/dev/null + +## fail dd if file exists. + +dd if=/dev/zero of=$M0/2 bs=1 count=1 conv=excl 2>/dev/null +EXPECT "1" echo $? + +cleanup; diff --git a/tests/bugs/glusterfs/bug-895235.t b/tests/bugs/glusterfs/bug-895235.t new file mode 100644 index 00000000000..ac9caae9561 --- /dev/null +++ b/tests/bugs/glusterfs/bug-895235.t @@ -0,0 +1,23 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc +. $(dirname $0)/../../volume.rc + +cleanup; +TEST glusterd +TEST pidof glusterd + +TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1} +TEST $CLI volume set $V0 ensure-durability off +TEST $CLI volume set $V0 performance.write-behind off +TEST $CLI volume set $V0 cluster.eager-lock off +TEST $CLI volume start $V0 +TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id=$V0 $M0 --direct-io-mode=enable + +TEST gluster volume profile $V0 start +TEST dd of=$M0/a if=/dev/zero bs=1024k count=1 oflag=append +finodelk_max_latency=$($CLI volume profile $V0 info | grep FINODELK | awk 'BEGIN {max = 0} {if ($6 > max) max=$6;} END {print max}' | cut -d. -f 1 | egrep "[0-9]{7,}") + +TEST [ -z $finodelk_max_latency ] + +cleanup; diff --git a/tests/bugs/glusterfs/bug-896431.t b/tests/bugs/glusterfs/bug-896431.t new file mode 100755 index 00000000000..7764a88d896 --- /dev/null +++ b/tests/bugs/glusterfs/bug-896431.t @@ -0,0 +1,124 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc +. $(dirname $0)/../../volume.rc + +cleanup; + +## Start and create a volume +TEST glusterd; +TEST pidof glusterd; +TEST $CLI volume create $V0 replica 2 stripe 2 $H0:$B0/${V0}{1,2,3,4,5,6,7,8}; + +## Verify volume is created +EXPECT "$V0" volinfo_field $V0 'Volume Name'; +EXPECT 'Created' volinfo_field $V0 'Status'; + +## Start volume and verify +TEST $CLI volume start $V0; +EXPECT 'Started' volinfo_field $V0 'Status'; + +## Setting cluster.subvols-per-directory as -5 +TEST ! $CLI volume set $V0 cluster.subvols-per-directory -5 +EXPECT '' volinfo_field $V0 'cluster.subvols-per-directory'; +TEST ! $CLI volume set $V0 subvols-per-directory -5 +EXPECT '' volinfo_field $V0 'cluster.subvols-per-directory'; + +## Setting cluster.subvols-per-directory as 0 +TEST ! $CLI volume set $V0 cluster.subvols-per-directory 0 +EXPECT '' volinfo_field $V0 'cluster.subvols-per-directory'; +TEST ! $CLI volume set $V0 subvols-per-directory 0 +EXPECT '' volinfo_field $V0 'cluster.subvols-per-directory'; + +## Setting cluster.subvols-per-directory as 4 (the total number of bricks) +TEST ! $CLI volume set $V0 cluster.subvols-per-directory 4 +EXPECT '' volinfo_field $V0 'cluster.subvols-per-directory'; +TEST ! $CLI volume set $V0 subvols-per-directory 4 +EXPECT '' volinfo_field $V0 'cluster.subvols-per-directory'; + +## Setting cluster.subvols-per-directory as 2 (the total number of subvolumes) +TEST $CLI volume set $V0 cluster.subvols-per-directory 2 +EXPECT '2' volinfo_field $V0 'cluster.subvols-per-directory'; + +## Setting cluster.subvols-per-directory as 1 +TEST $CLI volume set $V0 subvols-per-directory 1 +EXPECT '1' volinfo_field $V0 'cluster.subvols-per-directory'; + +## Finish up +TEST $CLI volume stop $V0; +EXPECT 'Stopped' volinfo_field $V0 'Status'; + +TEST $CLI volume delete $V0; +TEST ! $CLI volume info $V0; + +cleanup; + +## Start and create a pure replicate volume +TEST glusterd; +TEST pidof glusterd; +TEST $CLI volume create $V0 replica 8 $H0:$B0/${V0}{1,2,3,4,5,6,7,8}; + +## Verify volume is created +EXPECT "$V0" volinfo_field $V0 'Volume Name'; +EXPECT 'Created' volinfo_field $V0 'Status'; +EXPECT 'Replicate' volinfo_field $V0 'Type'; + +## Start volume and verify +TEST $CLI volume start $V0; +EXPECT 'Started' volinfo_field $V0 'Status'; + +## Setting cluster.subvols-per-directory as 8 for a replicate volume +TEST ! $CLI volume set $V0 cluster.subvols-per-directory 8 +EXPECT '' volinfo_field $V0 'cluster.subvols-per-directory'; +TEST ! $CLI volume set $V0 subvols-per-directory 8 +EXPECT '' volinfo_field $V0 'cluster.subvols-per-directory'; + +## Setting cluster.subvols-per-directory as 1 for a replicate volume +TEST $CLI volume set $V0 cluster.subvols-per-directory 1 +EXPECT '1' volinfo_field $V0 'cluster.subvols-per-directory'; +TEST $CLI volume set $V0 subvols-per-directory 1 +EXPECT '1' volinfo_field $V0 'cluster.subvols-per-directory'; + +## Finish up +TEST $CLI volume stop $V0; +EXPECT 'Stopped' volinfo_field $V0 'Status'; + +TEST $CLI volume delete $V0; +TEST ! $CLI volume info $V0; + +cleanup; + +## Start and create a pure stripe volume +TEST glusterd; +TEST pidof glusterd; +TEST $CLI volume create $V0 stripe 8 $H0:$B0/${V0}{1,2,3,4,5,6,7,8}; + +## Verify volume is created +EXPECT "$V0" volinfo_field $V0 'Volume Name'; +EXPECT 'Created' volinfo_field $V0 'Status'; +EXPECT 'Stripe' volinfo_field $V0 'Type'; + +## Start volume and verify +TEST $CLI volume start $V0; +EXPECT 'Started' volinfo_field $V0 'Status'; + +## Setting cluster.subvols-per-directory as 8 for a stripe volume +TEST ! $CLI volume set $V0 cluster.subvols-per-directory 8 +EXPECT '' volinfo_field $V0 'cluster.subvols-per-directory'; +TEST ! $CLI volume set $V0 subvols-per-directory 8 +EXPECT '' volinfo_field $V0 'cluster.subvols-per-directory'; + +## Setting cluster.subvols-per-directory as 1 for a stripe volume +TEST $CLI volume set $V0 cluster.subvols-per-directory 1 +EXPECT '1' volinfo_field $V0 'cluster.subvols-per-directory'; +TEST $CLI volume set $V0 subvols-per-directory 1 +EXPECT '1' volinfo_field $V0 'cluster.subvols-per-directory'; + +## Finish up +TEST $CLI volume stop $V0; +EXPECT 'Stopped' volinfo_field $V0 'Status'; + +TEST $CLI volume delete $V0; +TEST ! $CLI volume info $V0; + +cleanup; diff --git a/tests/bugs/glusterfs/bug-902610.t b/tests/bugs/glusterfs/bug-902610.t new file mode 100755 index 00000000000..656bf50137e --- /dev/null +++ b/tests/bugs/glusterfs/bug-902610.t @@ -0,0 +1,65 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc + +cleanup; + +## Layout-spread set to 3, but subvols up are 2. So layout should split 50-50 +function get_layout() +{ + layout1=`getfattr -n trusted.glusterfs.dht -e hex $1 2>&1|grep dht |cut -d = -f2` + layout1_s=$(echo $layout1 | cut -c 19-26) + layout1_e=$(echo $layout1 | cut -c 27-34) + #echo "layout1 from $layout1_s to $layout1_e" > /dev/tty + layout2=`getfattr -n trusted.glusterfs.dht -e hex $2 2>&1|grep dht |cut -d = -f2` + layout2_s=$(echo $layout2 | cut -c 19-26) + layout2_e=$(echo $layout2 | cut -c 27-34) + #echo "layout2 from $layout2_s to $layout2_e" > /dev/tty + + if [ x"$layout2_s" = x"00000000" ]; then + # Reverse so we only have the real logic in one place. + tmp_s=$layout1_s + tmp_e=$layout1_e + layout1_s=$layout2_s + layout1_e=$layout2_e + layout2_s=$tmp_s + layout2_e=$tmp_e + fi + + # Figure out where the join point is. + target=$( $PYTHON -c "print '%08x' % (0x$layout1_e + 1)") + #echo "target for layout2 = $target" > /dev/tty + + # The second layout should cover everything that the first doesn't. + if [ x"$layout2_s" = x"$target" -a x"$layout2_e" = x"ffffffff" ]; then + return 0 + fi + + return 1 +} + +BRICK_COUNT=4 + +TEST glusterd +TEST pidof glusterd + +TEST $CLI volume create $V0 $H0:$B0/${V0}0 $H0:$B0/${V0}1 $H0:$B0/${V0}2 $H0:$B0/${V0}3 +## set subvols-per-dir option +TEST $CLI volume set $V0 subvols-per-directory 3 +TEST $CLI volume start $V0 + +## Mount FUSE +TEST glusterfs -s $H0 --volfile-id $V0 $M0 --entry-timeout=0 --attribute-timeout=0; + +TEST ls -l $M0 + +## kill 2 bricks to bring down available subvol < spread count +kill -9 `cat $GLUSTERD_WORKDIR/vols/$V0/run/$H0-d-backends-${V0}2.pid`; +kill -9 `cat $GLUSTERD_WORKDIR/vols/$V0/run/$H0-d-backends-${V0}3.pid`; + +mkdir $M0/dir1 2>/dev/null + +get_layout $B0/${V0}0/dir1 $B0/${V0}1/dir1 +EXPECT "0" echo $? + +cleanup; diff --git a/tests/bugs/glusterfs/bug-906646.t b/tests/bugs/glusterfs/bug-906646.t new file mode 100644 index 00000000000..45c85d9f67c --- /dev/null +++ b/tests/bugs/glusterfs/bug-906646.t @@ -0,0 +1,93 @@ +#!/bin/bash + +. $(dirname $0)/../../include.rc +. $(dirname $0)/../../volume.rc + +cleanup; + +REPLICA=2 + +TEST glusterd +TEST pidof glusterd + +TEST $CLI volume create $V0 replica $REPLICA $H0:$B0/${V0}-00 $H0:$B0/${V0}-01 $H0:$B0/${V0}-10 $H0:$B0/${V0}-11 +TEST $CLI volume start $V0 + +TEST $CLI volume set $V0 cluster.self-heal-daemon off +TEST $CLI volume set $V0 cluster.background-self-heal-count 0 + +## Mount FUSE with caching disabled +TEST $GFS -s $H0 --volfile-id $V0 $M0; + +function xattr_query_check() +{ + local path=$1 + local xa_name=$2 + + local ret=$(getfattr -n $xa_name $path 2>&1 | grep -o "$xa_name: No such attribute" | wc -l) + echo $ret +} + +function set_xattr() +{ + local path=$1 + local xa_name=$2 + local xa_val=$3 + + setfattr -n $xa_name -v $xa_val $path + echo $? +} + +function remove_xattr() +{ + local path=$1 + local xa_name=$2 + + setfattr -x $xa_name $path + echo $? +} + +f=f00f +pth=$M0/$f + +TEST touch $pth + +# fetch backend paths +backend_paths=`get_backend_paths $pth` + +# convert it into and array +backend_paths_array=($backend_paths) + +# setxattr xattr for this file +EXPECT 0 set_xattr $pth "trusted.name" "test" + +# confirm the set on backend +EXPECT 0 xattr_query_check ${backend_paths_array[0]} "trusted.name" +EXPECT 0 xattr_query_check ${backend_paths_array[1]} "trusted.name" + +brick_path=`echo ${backend_paths_array[0]} | sed -n 's/\(.*\)\/'$f'/\1/p'` +brick_id=`$CLI volume info $V0 | grep "Brick[[:digit:]]" | grep -n $brick_path | cut -f1 -d:` + +# Kill a brick process +TEST kill_brick $V0 $H0 $brick_path + +# remove the xattr from the mount point +EXPECT 0 remove_xattr $pth "trusted.name" + +# we killed ${backend_paths[0]} - so expect the xattr to be there +# on the backend there +EXPECT 0 xattr_query_check ${backend_paths_array[0]} "trusted.name" +EXPECT 1 xattr_query_check ${backend_paths_array[1]} "trusted.name" + +# restart the brick process +TEST $CLI volume start $V0 force + +EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status $V0 `expr $brick_id - 1` + +cat $pth >/dev/null + +# check backends - xattr should not be present anywhere +EXPECT 1 xattr_query_check ${backend_paths_array[0]} "trusted.name" +EXPECT 1 xattr_query_check ${backend_paths_array[1]} "trusted.name" + +cleanup; diff --git a/tests/bugs/glusterfs/getlk_owner.c b/tests/bugs/glusterfs/getlk_owner.c new file mode 100644 index 00000000000..85fd1042496 --- /dev/null +++ b/tests/bugs/glusterfs/getlk_owner.c @@ -0,0 +1,120 @@ +#include <stdio.h> +#include <unistd.h> +#include <fcntl.h> +#include <string.h> + +#define GETLK_OWNER_CHECK(f, cp, label) \ + do { \ + switch (f.l_type) { \ + case F_RDLCK: \ + case F_WRLCK: \ + ret = 1; \ + goto label; \ + case F_UNLCK: \ + if (!are_flocks_sane (&f, &cp)) { \ + ret = 1; \ + goto label; \ + } \ + break; \ + } \ + } while (0) + +void +flock_init (struct flock *f, short int type, off_t start, off_t len) +{ + f->l_type = type; + f->l_start = start; + f->l_len = len; +} + +int +flock_cp (struct flock *dst, struct flock *src) +{ + memcpy ((void *) dst, (void *) src, sizeof (struct flock)); +} + +int +are_flocks_sane (struct flock *src, struct flock *cpy) +{ + return ((src->l_whence == cpy->l_whence) && + (src->l_start == cpy->l_start) && + (src->l_len == cpy->l_len)); +} + +/* + * Test description: + * SETLK (0,3), F_WRLCK + * SETLK (3,3), F_WRLCK + * + * the following GETLK requests must return flock struct unmodified + * except for l_type to F_UNLCK + * GETLK (3,3), F_WRLCK + * GETLK (3,3), F_RDLCK + * + * */ + +int main (int argc, char **argv) +{ + int fd = -1; + int ret = 1; + char *fname = NULL; + struct flock f = {0,}; + struct flock cp = {0,}; + + if (argc < 2) + goto out; + + fname = argv[1]; + fd = open (fname, O_RDWR); + if (fd == -1) { + perror ("open"); + goto out; + } + + flock_init (&f, F_WRLCK, 0, 3); + flock_cp (&cp, &f); + ret = fcntl (fd, F_SETLK, &f); + if (ret) { + perror ("fcntl"); + goto out; + } + if (!are_flocks_sane (&f, &cp)) { + ret = 1; + goto out; + } + + flock_init (&f, F_WRLCK, 3, 3); + flock_cp (&cp, &f); + ret = fcntl (fd, F_SETLK, &f); + if (ret) { + perror ("fcntl"); + goto out; + } + if (!are_flocks_sane (&f, &cp)) { + ret = 1; + goto out; + } + + flock_init (&f, F_WRLCK, 3, 3); + flock_cp (&cp, &f); + ret = fcntl (fd, F_GETLK, &f); + if (ret) { + perror ("fcntl"); + return 1; + } + GETLK_OWNER_CHECK (f, cp, out); + + flock_init (&f, F_RDLCK, 3, 3); + flock_cp (&cp, &f); + ret = fcntl (fd, F_GETLK, &f); + if (ret) { + perror ("fcntl"); + return 1; + } + GETLK_OWNER_CHECK (f, cp, out); + +out: + if (fd != -1) + close (fd); + return ret; +} |