Whamcloud - gitweb
LU-17000 utils: handle_yaml_no_op() has wrong signature
[fs/lustre-release.git] / lustre / tests / lustre-rsync-test.sh
1 #!/bin/bash
2 #
3 # Run select tests by setting ONLY, or as arguments to the script.
4 # Skip specific tests by setting EXCEPT.
5 #
6 set -e
7
8 ONLY=${ONLY:-"$*"}
9
10 KILL=/bin/kill
11 LREPL_LOG=$TMP/lustre_rsync.log
12 ORIG_PWD=${PWD}
13
14 LUSTRE=${LUSTRE:-$(dirname $0)/..}
15 . $LUSTRE/tests/test-framework.sh
16 init_test_env "$@"
17 init_logging
18
19 ALWAYS_EXCEPT="$LRSYNC_EXCEPT "
20 always_except LU-4256   2b
21 [[ $(uname -r) = *"debug" ]] &&
22         always_except LU-16489  2c
23
24 build_test_filter
25
26 [ -n "$FILESET" ] && skip "Not functional for FILESET set"
27
28 check_and_setup_lustre
29
30 DIR=${DIR:-$MOUNT}
31 assert_DIR
32
33 if getent group nobody; then
34         GROUP=nobody
35 elif getent group nogroup; then
36         GROUP=nogroup
37 else
38         error "No generic nobody group"
39 fi
40
41 export LRSYNC=${LRSYNC:-"$LUSTRE/utils/lustre_rsync"}
42 [ ! -f "$LRSYNC" ] && export LRSYNC=$(which lustre_rsync)
43 export LRSYNC="$LRSYNC -v -c no -d 2"
44
45 # Number of seconds to run dbench
46 DBENCH_TIME=${DBENCH_TIME:-60}
47 TGT=$TMP/target
48 TGT2=$TMP/target2
49 MDT0=$($LCTL get_param -n mdc.*.mds_server_uuid |
50         awk '{ gsub(/_UUID/,""); print $1 }' | head -n1)
51
52 init_changelog() {
53         changelog_register || error "changelog_register failed"
54         CL_USER=(${CL_USERS[$SINGLEMDS]})
55         echo $MDT0: Registered changelog user $CL_USER
56         [ -z $CL_USER ] &&
57                 echo "No changelog users present on $SINGLEMDS"
58 }
59
60 fini_changelog() {
61         changelog_clear
62         changelog_deregister
63 }
64
65 init_src() {
66         rm -rf $TGT/$tdir $TGT/d*.lustre-rsync-test 2> /dev/null
67         rm -rf $TGT2/$tdir $TGT2/d*.lustre-rsync-test 2> /dev/null
68         rm -rf ${DIR}/$tdir $DIR/d*.lustre-rsync-test ${DIR}/tgt 2> /dev/null
69         rm -f $LREPL_LOG
70
71         mkdir_on_mdt0 $DIR/$tdir || error "Failed to create target: " $DIR/$tdir
72         mkdir -p ${TGT}/$tdir || error "Failed to create target: " $TGT/$tdir
73         mkdir -p ${TGT2}/$tdir || error "Failed to create target: " $TGT2/$tdir
74 }
75
76 cleanup_src_tgt() {
77         [ ! -d $TGT2/$tdir ] || rm -rf $TGT2/$tdir # /tmp/target2/...
78         [ ! -d $TGT/$tdir ] || rm -rf $TGT/$tdir # /tmp/target/...
79         rm -rf $DIR/$tdir  # /mnt/lustre/...
80         rm -rf $DIR/tgt    # /mnt/lustre/tgt
81 }
82
83 # Check whether the filesystem supports xattr or not.
84 # Return value:
85 # "large" - large xattr is supported
86 # "small" - large xattr is unsupported but small xattr is supported
87 # "no"    - xattr is unsupported
88 check_xattr() {
89         local tgt=$1
90         local xattr="no"
91
92         touch $tgt
93
94         local val="$(generate_string $(max_xattr_size))"
95
96         if large_xattr_enabled &&
97                 setfattr -n user.foo -v $val $tgt 2>/dev/null; then
98                 xattr="large"
99         else
100                 setfattr -n user.foo -v bar $tgt 2>/dev/null && xattr="small"
101         fi
102
103         rm -f $tgt
104         echo $xattr
105 }
106
107 check_diff() {
108         local changelog_file=$(generate_logname "changelog")
109
110         if [ -e $1 -o -e $2 ]; then
111                 diff -rq -x "dev1" $1 $2
112                 local RC=$?
113                 if [ $RC -ne 0 ]; then
114                         $LFS changelog $MDT0 > $changelog_file
115                         error "Failure in replication; differences found."
116                 fi
117         fi
118 }
119
120 procs_are_stopped() {
121         local pids="$*"
122         local state
123
124         for state in $(ps -p "$pids" -o state=); do
125                 if [[ "$state" != T ]]; then
126                         return 1
127                 fi
128         done
129
130         return 0
131 }
132
133 # Send SIGSTOP to PIDs and wait up to 60 seconds for them to show a
134 # stopped process state.
135 stop_procs() {
136         local pids="$*"
137         local end
138
139         $KILL -SIGSTOP $pids
140         end=$((SECONDS + 60))
141         while ((SECONDS < end)); do
142                 if procs_are_stopped $pids; then
143                         return 0
144                 fi
145
146                 sleep 1
147         done
148
149         return 1
150 }
151
152 # Test 1A - test basic operations
153 test_1A() { # was test_1
154         init_src
155         init_changelog
156         local xattr=$(check_xattr $TGT/foo)
157
158         # Directory create
159         mkdir $DIR/$tdir/d1
160         mkdir $DIR/$tdir/d2
161
162         # File create
163         touch $DIR/$tdir/file1
164         cp /etc/hosts  $DIR/$tdir/d1/
165         touch $DIR/$tdir/d1/"space in filename"
166         touch $DIR/$tdir/d1/file2
167
168         # File rename
169         mv $DIR/$tdir/d1/file2 $DIR/$tdir/d2/file3
170
171         # File and directory delete
172         touch $DIR/$tdir/d1/file4
173         mkdir $DIR/$tdir/d1/del
174         touch $DIR/$tdir/d1/del/del1
175         touch $DIR/$tdir/d1/del/del2
176         rm -rf $DIR/$tdir/d1/del
177         rm $DIR/$tdir/d1/file4
178
179         # Hard and soft links
180         cat /etc/hosts > $DIR/$tdir/d1/link1
181         ln $DIR/$tdir/d1/link1  $DIR/$tdir/d1/link2
182         ln -s $DIR/$tdir/d1/link1  $DIR/$tdir/d1/link3
183
184         # Device files
185         #mknod $DIR/$tdir/dev1 b 8 1
186
187         # Replicate
188         local LRSYNC_LOG=$(generate_logname "lrsync_log")
189         echo "Replication #1"
190         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
191                 -D $LRSYNC_LOG
192
193         # Set attributes
194         chmod 000 $DIR/$tdir/d2/file3
195         chown nobody:$GROUP $DIR/$tdir/d2/file3
196
197         # Set xattrs
198         if [[ "$xattr" != "no" ]]; then
199                 local value
200                 touch $DIR/$tdir/file5
201                 [[ "$xattr" = "large" ]] &&
202                         value="$(generate_string $(max_xattr_size))" || value="bar"
203                 setfattr -n user.foo -v $value $DIR/$tdir/file5 ||
204                         error "setfattr failed"
205         fi
206
207         echo "Replication #2"
208         $LRSYNC -l $LREPL_LOG -D $LRSYNC_LOG
209
210         if [[ "$xattr" != "no" ]]; then
211                 local xval1=$(get_xattr_value user.foo $TGT/$tdir/file5)
212                 local xval2=$(get_xattr_value user.foo $TGT2/$tdir/file5)
213
214                 if [[ "$xval1" != "$value" || "$xval2" != "$value" ]]; then
215                         error "Error in replicating xattrs."
216                 fi
217         fi
218
219         # Use diff to compare the source and the destination
220         check_diff $DIR/$tdir $TGT/$tdir
221         check_diff $DIR/$tdir $TGT2/$tdir
222
223         fini_changelog
224         cleanup_src_tgt
225 }
226 run_test 1A "Simple Replication"
227
228 # Test 1a - test create/delete operations in ROOT directory
229 test_1a() { # LU-5005
230         rm -rf $TGT/root-* 2> /dev/null
231         rm -rf $DIR/root-* 2> /dev/null
232         init_src
233         init_changelog
234
235         # Directory create
236         mkdir_on_mdt0 $DIR/root-dir
237
238         # File create
239         touch $DIR/root-file
240         touch $DIR/root-file2
241
242         # File rename
243         mv $DIR/root-file2 $DIR/root-file3
244
245         # File and directory delete
246         touch $DIR/root-file4
247         mkdir_on_mdt0 $DIR/root-dir1
248         rm $DIR/root-file4
249         rm -rf $DIR/root-dir1
250
251         # Replicate
252         local LRSYNC_LOG=$(generate_logname "lrsync_log")
253         echo "Replication"
254         $LRSYNC -s $DIR -t $TGT -m $MDT0 -u $CL_USER -l $LREPL_LOG \
255                 -D $LRSYNC_LOG
256
257         # Verify
258         stat $TGT/root-dir || error "Dir create not replicated"
259         stat $TGT/root-file || error "File create not replicated"
260         stat $TGT/root-file2 && error "Rename not replicated (src)"
261         stat $TGT/root-file3 || error "Rename not replicated (tgt)"
262         stat $TGT/root-dir1 && error "Dir delete not replicated"
263         stat $TGT/root-file4 && error "File delete not replicated"
264
265         cleanup_src_tgt
266         fini_changelog
267         rm -fr $TGT/root-*
268         rm -fr $DIR/root-*
269         return 0
270 }
271 run_test 1a "Replicate create/delete operations in ROOT directory"
272
273 # Test 2a - Replicate files created by dbench
274 test_2a() {
275         init_src
276         init_changelog
277
278         # Run dbench
279         bash rundbench -C -D $DIR/$tdir 2 -t $DBENCH_TIME ||
280                 error "dbench failed to complete $DBENCH_TIME seconds"
281
282         local log=$(generate_logname "lrsync_log")
283         # Replicate the changes to $TGT
284         $LRSYNC -s $DIR -t $TGT -m $MDT0 -u $CL_USER -l $LREPL_LOG -D $log
285
286         # Use diff to compare the source and the destination
287         check_diff $DIR/$tdir $TGT/$tdir
288
289         fini_changelog
290         cleanup_src_tgt
291         return 0
292 }
293 run_test 2a "Replicate files created by dbench."
294
295 # Test 2b - Replicate files changed by dbench.
296 test_2b() {
297         local child_pid
298         init_src
299         init_changelog
300
301         # Run dbench
302         bash rundbench -C -D $DIR/$tdir 2 -t $DBENCH_TIME &
303         # wait for dbench to start
304         wait_for_function 'child_pid=$(pgrep dbench)' 360
305         # let dbench run for a bit
306         sleep 10
307
308         echo PIDs: $child_pid
309         echo Stopping dbench
310         stop_procs $child_pid
311
312         local log=$(generate_logname "lrsync_log")
313         echo Starting replication
314         $LRSYNC -s $DIR -t $TGT -m $MDT0 -u $CL_USER -l $LREPL_LOG -D $log
315         check_diff $DIR/$tdir $TGT/$tdir
316
317         echo Resuming dbench
318         $KILL -SIGCONT $child_pid
319         sleep 10
320
321         echo Stopping dbench
322         stop_procs $child_pid
323
324         echo Starting replication
325         $LRSYNC -l $LREPL_LOG -D $log
326         check_diff $DIR/$tdir $TGT/$tdir
327
328         echo "Wait for dbench to finish"
329         $KILL -SIGCONT $child_pid
330         wait
331
332         # Replicate the changes to $TGT
333         echo Starting replication
334         $LRSYNC -l $LREPL_LOG -D $log
335
336         check_diff $DIR/$tdir $TGT/$tdir
337
338         fini_changelog
339         cleanup_src_tgt
340         return 0
341 }
342 run_test 2b "Replicate files changed by dbench."
343
344 # Test 2c - Replicate files while dbench is running
345 test_2c() {
346         init_src
347         init_changelog
348
349         # Run dbench
350         bash rundbench -C -D $DIR/$tdir 2 -t $DBENCH_TIME &
351
352         local LRSYNC_LOG=$(generate_logname "lrsync_log")
353         # Replicate the changes to $TGT
354         sleep 10 # give dbench a headstart
355         local quit=0
356         while [ $quit -le 1 ];
357         do
358                 echo "Running lustre_rsync"
359                 $LRSYNC -s $DIR -t $TGT -t $TGT2 -m ${mds1_svc} -u $CL_USER \
360                         -l $LREPL_LOG -D $LRSYNC_LOG
361                 sleep 5
362                 pgrep dbench
363                 if [ $? -ne 0 ]; then
364                         quit=$(expr $quit + 1)
365                 fi
366         done
367
368         # Use diff to compare the source and the destination
369         check_diff $DIR/$tdir $TGT/$tdir
370         check_diff $DIR/$tdir $TGT2/$tdir
371
372         fini_changelog
373         cleanup_src_tgt
374         return 0
375 }
376 run_test 2c "Replicate files while dbench is running."
377
378 # Test 3a - Replicate files created by createmany
379 test_3a() {
380         init_src
381         init_changelog
382
383         local numfiles=1000
384         createmany -o $DIR/$tdir/$tfile $numfiles || error "createmany failed"
385
386         local LRSYNC_LOG=$(generate_logname "lrsync_log")
387         # Replicate the changes to $TGT
388         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
389                 -D $LRSYNC_LOG
390         check_diff $DIR/$tdir $TGT/$tdir
391         check_diff $DIR/$tdir $TGT2/$tdir
392
393         fini_changelog
394         cleanup_src_tgt
395         return 0
396 }
397 run_test 3a "Replicate files created by createmany"
398
399 # Test 3b - Replicate files created by writemany
400 test_3b() {
401         init_src
402         init_changelog
403
404         local time=60
405         local threads=5
406         writemany -q -a $DIR/$tdir/$tfile $time $threads ||
407                 error "writemany failed"
408
409         local LRSYNC_LOG=$(generate_logname "lrsync_log")
410         # Replicate the changes to $TGT
411         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
412                 -D $LRSYNC_LOG
413
414         check_diff $DIR/$tdir $TGT/$tdir
415         check_diff $DIR/$tdir $TGT2/$tdir
416
417         fini_changelog
418         cleanup_src_tgt
419         return 0
420 }
421 run_test 3b "Replicate files created by writemany"
422
423 # Test 3c - Replicate files created by createmany/unlinkmany
424 test_3c() {
425         init_src
426         init_changelog
427
428         local numfiles=1000
429         createmany -o $DIR/$tdir/$tfile $numfiles || error "createmany failed"
430         unlinkmany $DIR/$tdir/$tfile $numfiles || error "unlinkmany failed"
431
432         local LRSYNC_LOG=$(generate_logname "lrsync_log")
433         # Replicate the changes to $TGT
434         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0  -u $CL_USER -l $LREPL_LOG \
435                 -D $LRSYNC_LOG
436         check_diff $DIR/$tdir $TGT/$tdir
437         check_diff $DIR/$tdir $TGT2/$tdir
438
439         fini_changelog
440         cleanup_src_tgt
441         return 0
442 }
443 run_test 3c "Replicate files created by createmany/unlinkmany"
444
445 # Test 4 - Replicate files created by iozone
446 test_4() {
447         which iozone > /dev/null 2>&1
448         [ $? -ne 0 ] && skip "iozone not found"
449
450         init_src
451         init_changelog
452
453         END_RUN_FILE=${DIR}/$tdir/run LOAD_PID_FILE=${DIR}/$tdir/pid \
454                 MOUNT=${DIR}/$tdir RECOVERY_SCALE_ENABLE_REMOTE_DIRS=false \
455                 RECOVERY_SCALE_ENABLE_STRIPED_DIRS=false run_iozone.sh &
456         sleep 30
457         child_pid=$(pgrep iozone)
458         stop_procs $child_pid
459
460         local LRSYNC_LOG=$(generate_logname "lrsync_log")
461         # Replicate the changes to $TGT
462         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0  -u $CL_USER -l $LREPL_LOG \
463                 -D $LRSYNC_LOG
464         check_diff $DIR/$tdir $TGT/$tdir
465         check_diff $DIR/$tdir $TGT2/$tdir
466
467         $KILL -SIGCONT $child_pid
468         sleep 60
469         $KILL -SIGKILL $(pgrep run_iozone.sh)
470         $KILL -SIGKILL $(pgrep iozone)
471
472         # After killing 'run_iozone.sh', process 'iozone' becomes the
473         # child of PID 1. Hence 'wait' does not wait for it. Killing
474         # iozone first, means more iozone processes are spawned off which
475         # is not desirable. So, after sending a sigkill, the test goes
476         # into a wait loop for iozone to cleanup and exit.
477         wait
478         while [ "$(pgrep "iozone")" != "" ];
479         do
480                 ps -ef | grep iozone | grep -v grep
481                 sleep 1;
482         done
483
484         $LRSYNC -l $LREPL_LOG -D $LRSYNC_LOG
485         check_diff $DIR/$tdir $TGT/$tdir
486         check_diff $DIR/$tdir $TGT2/$tdir
487
488         fini_changelog
489         cleanup_src_tgt
490         return 0
491 }
492 run_test 4 "Replicate files created by iozone"
493
494 # Test 5a - Stop / start lustre_rsync
495 test_5a() {
496         init_src
497         init_changelog
498
499         NUMTEST=2000
500         createmany -o $DIR/$tdir/$tfile $NUMTEST
501
502         # Replicate the changes to $TGT
503         local LRSYNC_LOG=$(generate_logname "lrsync_log")
504         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
505                 -D $LRSYNC_LOG &
506         local child_pid=$!
507         sleep 30
508         $KILL -SIGHUP $child_pid
509         wait
510         $LRSYNC -l $LREPL_LOG -D $LRSYNC_LOG
511
512         check_diff $DIR/$tdir $TGT/$tdir
513         check_diff $DIR/$tdir $TGT2/$tdir
514
515         fini_changelog
516         cleanup_src_tgt
517         return 0
518 }
519 run_test 5a "Stop / start lustre_rsync"
520
521 # Test 5b - Kill / restart lustre_rsync
522 test_5b() {
523         init_src
524         init_changelog
525
526         NUMTEST=2000
527         createmany -o $DIR/$tdir/$tfile $NUMTEST
528
529         # Replicate the changes to $TGT
530         local LRSYNC_LOG=$(generate_logname "lrsync_log")
531         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
532                 -D $LRSYNC_LOG &
533         local child_pid=$!
534         sleep 30
535         $KILL -SIGKILL $child_pid
536         wait
537         $LRSYNC -l $LREPL_LOG -D $LRSYNC_LOG
538
539         check_diff $DIR/$tdir $TGT/$tdir
540         check_diff $DIR/$tdir $TGT2/$tdir
541
542         fini_changelog
543         cleanup_src_tgt
544         return 0
545 }
546 run_test 5b "Kill / restart lustre_rsync"
547
548 # Test 6 - lustre_rsync large no of hard links
549 test_6() {
550         init_src
551         init_changelog
552
553         local num_links=128
554         local i
555
556         touch $DIR/$tdir/link0
557         for ((i = 1; i < num_links - 1; i++)); do
558                 ln $DIR/$tdir/link0 $DIR/$tdir/link$i
559         done
560         # create an extra hard link of src name ending with dest name
561         ln $DIR/$tdir/link0 $DIR/$tdir/ink0
562
563         local LRSYNC_LOG=$(generate_logname "lrsync_log")
564         # Replicate the changes to $TGT
565         $LRSYNC -s $DIR -t $TGT -t $TGT2 -m $MDT0 -u $CL_USER -l $LREPL_LOG \
566                 -D $LRSYNC_LOG
567         check_diff $DIR/$tdir $TGT/$tdir
568         check_diff $DIR/$tdir $TGT2/$tdir
569
570         local count1=$(stat --format=%h $TGT/$tdir/link0)
571         local count2=$(stat --format=%h $TGT2/$tdir/link0)
572         if ((count1 != num_links || count2 != num_links)); then
573                 ls -l $TGT/$tdir/link0 $TGT2/$tdir/link0
574                 error "Incorrect no of hard links found $count1, $count2"
575         fi
576
577         fini_changelog
578         cleanup_src_tgt
579         return 0
580 }
581 run_test 6 "lustre_rsync large no of hard links"
582
583 # Test 7 - lustre_rsync stripesize
584 test_7() {
585         local numfiles=100
586
587         init_src
588         mkdir -p ${DIR}/tgt/$tdir
589         init_changelog
590
591         $LFS setstripe -c $OSTCOUNT $DIR/$tdir ||
592                 error "$LFS setstripe failed"
593         createmany -o $DIR/$tdir/$tfile $numfiles
594
595         # To simulate replication to another lustre filesystem, replicate
596         # the changes to $DIR/tgt. We can't turn off the changelogs
597         # while we are registered, so lustre_rsync better not try to
598         # replicate the replication steps.  It seems ok :)
599
600         local LRSYNC_LOG=$(generate_logname "lrsync_log")
601         $LRSYNC -s $DIR -t $DIR/tgt -m $MDT0 -u $CL_USER -l $LREPL_LOG \
602                 -D $LRSYNC_LOG
603         check_diff ${DIR}/$tdir $DIR/tgt/$tdir
604
605         local i=0
606         while [ $i -lt $numfiles ];
607         do
608                 local count=$($LFS getstripe $DIR/tgt/$tdir/${tfile}$i |
609                               awk '/stripe_count/ {print $2}')
610                 if [ $count -ne $OSTCOUNT ]; then
611                         error "Stripe size not replicated"
612                 fi
613                 i=$(expr $i + 1)
614         done
615         fini_changelog
616         cleanup_src_tgt
617         return 0
618 }
619 run_test 7 "lustre_rsync stripesize"
620
621 # Test 8 - Replicate multiple file/directory moves
622 test_8() {
623         init_src
624         init_changelog
625
626         for i in 1 2 3 4 5 6 7 8 9; do
627                 mkdir $DIR/$tdir/d$i
628                 for j in 1 2 3 4 5 6 7 8 9; do
629                         mkdir $DIR/$tdir/d$i/d$i$j
630                         createmany -o $DIR/$tdir/d$i/d$i$j/a 10 \
631                             > /dev/null
632                         mv $DIR/$tdir/d$i/d$i$j $DIR/$tdir/d$i/d0$i$j
633                         createmany -o $DIR/$tdir/d$i/d0$i$j/b 10 \
634                             > /dev/null
635                         mv $DIR/$tdir/d$i/d0$i$j/a0 $DIR/$tdir/d$i/d0$i$j/c0
636                 done
637                 mv $DIR/$tdir/d$i $DIR/$tdir/d0$i
638         done
639
640         local LRSYNC_LOG=$(generate_logname "lrsync_log")
641         $LRSYNC -s $DIR -t $TGT -m $MDT0 -u $CL_USER -l $LREPL_LOG \
642                 -D $LRSYNC_LOG
643
644         check_diff ${DIR}/$tdir $TGT/$tdir
645
646         fini_changelog
647         cleanup_src_tgt
648         return 0
649 }
650 run_test 8 "Replicate multiple file/directory moves"
651
652 test_9() {
653         init_src
654         init_changelog
655
656         mkdir $DIR/$tdir/foo
657         touch $DIR/$tdir/foo/a1
658
659         local LRSYNC_LOG=$(generate_logname "lrsync_log")
660         $LRSYNC -s $DIR -t $TGT -m $MDT0 -u $CL_USER -l $LREPL_LOG \
661                 -D $LRSYNC_LOG
662
663         check_diff ${DIR}/$tdir $TGT/$tdir
664
665         rm -rf $DIR/$tdir/foo
666
667         $LRSYNC -s $DIR -t $TGT -m $MDT0 -u $CL_USER -l $LREPL_LOG \
668                 -D $LRSYNC_LOG
669
670         check_diff ${DIR}/$tdir $TGT/$tdir
671
672         fini_changelog
673         cleanup_src_tgt
674         return 0
675 }
676 run_test 9 "Replicate recursive directory removal"
677
678 cd $ORIG_PWD
679 complete_test $SECONDS
680 check_and_cleanup_lustre
681 exit_status