Whamcloud - gitweb
LU-3864 mdt: return st_blocks=1 for released files
[fs/lustre-release.git] / lustre / tests / sanity-hsm.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 # exit on error
7 set -e
8 set +o monitor
9
10 SRCDIR=$(dirname $0)
11 export PATH=$PWD/$SRCDIR:$SRCDIR:$PWD/$SRCDIR/utils:$PATH:/sbin:/usr/sbin
12
13 ONLY=${ONLY:-"$*"}
14 # bug number for skipped test:
15 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
16 # skip test cases failed before landing - Jinshan
17
18 ALWAYS_EXCEPT="$SANITY_HSM_EXCEPT 12a 12b 12n 13 30a 31a 34 35 36"
19 ALWAYS_EXCEPT="$ALWAYS_EXCEPT 110a 200 201 221 222a 223a 223b 225"
20
21 LUSTRE=${LUSTRE:-$(cd $(dirname $0)/..; echo $PWD)}
22
23 . $LUSTRE/tests/test-framework.sh
24 init_test_env $@
25 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
26 init_logging
27
28 MULTIOP=${MULTIOP:-multiop}
29 OPENFILE=${OPENFILE:-openfile}
30 MCREATE=${MCREATE:-mcreate}
31 MOUNT_2=${MOUNT_2:-"yes"}
32 FAIL_ON_ERROR=false
33
34 if [[ $MDSCOUNT -ge 2 ]]; then
35         skip_env "Only run with single MDT for now" && exit
36 fi
37
38 check_and_setup_lustre
39
40 if [[ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.4.53) ]]; then
41         skip_env "Need MDS version at least 2.4.53" && exit
42 fi
43
44 # $RUNAS_ID may get set incorrectly somewhere else
45 if [[ $UID -eq 0 && $RUNAS_ID -eq 0 ]]; then
46         skip_env "\$RUNAS_ID set to 0, but \$UID is also 0!" && exit
47 fi
48 check_runas_id $RUNAS_ID $RUNAS_GID $RUNAS
49
50 build_test_filter
51
52 #
53 # In order to test multiple remote HSM agents, a new facet type named "AGT" and
54 # the following associated variables are added:
55 #
56 # AGTCOUNT: number of agents
57 # AGTDEV{N}: target HSM mount point (root path of the backend)
58 # agt{N}_HOST: hostname of the agent agt{N}
59 # SINGLEAGT: facet of the single agent
60 #
61 # The number of agents is initialized as the number of remote client nodes.
62 # By default, only single copytool is started on a remote client/agent. If there
63 # was no remote client, then the copytool will be started on the local client.
64 #
65 init_agt_vars() {
66         local n
67         local agent
68
69         export AGTCOUNT=${AGTCOUNT:-$((CLIENTCOUNT - 1))}
70         [[ $AGTCOUNT -gt 0 ]] || AGTCOUNT=1
71
72         export SHARED_DIRECTORY=${SHARED_DIRECTORY:-$TMP}
73         if [[ $CLIENTCOUNT -gt 1 ]] &&
74                 ! check_shared_dir $SHARED_DIRECTORY $CLIENTS; then
75                 skip_env "SHARED_DIRECTORY should be accessible"\
76                          "on all client nodes"
77                 exit 0
78         fi
79
80         for n in $(seq $AGTCOUNT); do
81                 eval export AGTDEV$n=\$\{AGTDEV$n:-"$SHARED_DIRECTORY/arc$n"\}
82                 agent=CLIENT$((n + 1))
83                 if [[ -z "${!agent}" ]]; then
84                         [[ $CLIENTCOUNT -eq 1 ]] && agent=CLIENT1 ||
85                                 agent=CLIENT2
86                 fi
87                 eval export agt${n}_HOST=\$\{agt${n}_HOST:-${!agent}\}
88         done
89
90         export SINGLEAGT=${SINGLEAGT:-agt1}
91
92         export HSMTOOL=${HSMTOOL:-"lhsmtool_posix"}
93         export HSMTOOL_VERBOSE=${HSMTOOL_VERBOSE:-""}
94         export HSMTOOL_BASE=$(basename "$HSMTOOL" | cut -f1 -d" ")
95         HSM_ARCHIVE=$(copytool_device $SINGLEAGT)
96         HSM_ARCHIVE_NUMBER=2
97
98         MDT_PARAM="mdt.$FSNAME-MDT0000"
99         HSM_PARAM="$MDT_PARAM.hsm"
100
101         # archive is purged at copytool setup
102         HSM_ARCHIVE_PURGE=true
103 }
104
105 # Get the backend root path for the given agent facet.
106 copytool_device() {
107         local facet=$1
108         local dev=AGTDEV$(facet_number $facet)
109
110         echo -n ${!dev}
111 }
112
113 # Stop copytool and unregister an existing changelog user.
114 cleanup() {
115         copytool_cleanup
116         changelog_cleanup
117         cdt_set_sanity_policy
118 }
119
120 search_and_kill_copytool() {
121         local agents=${1:-$(facet_active_host $SINGLEAGT)}
122
123         echo "Killing existing copytools on $agents"
124         do_nodesv $agents "killall -q $HSMTOOL_BASE" || true
125 }
126
127 copytool_setup() {
128         local facet=${1:-$SINGLEAGT}
129         local lustre_mntpnt=${2:-$MOUNT}
130         local arc_id=$3
131         local hsm_root=$(copytool_device $facet)
132         local agent=$(facet_active_host $facet)
133
134         if [[ -z "$arc_id" ]] &&
135                 do_facet $facet "pkill -CONT -x $HSMTOOL_BASE"; then
136                         echo "Wakeup copytool $facet on $agent"
137                         return 0
138         fi
139
140         if $HSM_ARCHIVE_PURGE; then
141                 echo "Purging archive on $agent"
142                 do_facet $facet "rm -rf $hsm_root/*"
143         fi
144
145         echo "Starting copytool $facet on $agent"
146         do_facet $facet "mkdir -p $hsm_root" || error "mkdir '$hsm_root' failed"
147         # bandwidth is limited to 1MB/s so the copy time is known and
148         # independent of hardware
149         local cmd="$HSMTOOL $HSMTOOL_VERBOSE --daemon --hsm-root $hsm_root"
150         [[ -z "$arc_id" ]] || cmd+=" --archive $arc_id"
151         cmd+=" --bandwidth 1 $lustre_mntpnt"
152
153         # Redirect the standard output and error to a log file which
154         # can be uploaded to Maloo.
155         local prefix=$TESTLOG_PREFIX
156         [[ -z "$TESTNAME" ]] || prefix=$prefix.$TESTNAME
157         local copytool_log=$prefix.copytool${arc_id}_log.$agent.log
158
159         do_facet $facet "$cmd < /dev/null > $copytool_log 2>&1" ||
160                 error "start copytool $facet on $agent failed"
161         trap cleanup EXIT
162 }
163
164 copytool_cleanup() {
165         trap - EXIT
166         local agents=${1:-$(facet_active_host $SINGLEAGT)}
167
168         do_nodesv $agents "pkill -INT -x $HSMTOOL_BASE" || return 0
169         sleep 1
170         echo "Copytool is stopped on $agents"
171 }
172
173 copytool_suspend() {
174         local agents=${1:-$(facet_active_host $SINGLEAGT)}
175
176         do_nodesv $agents "pkill -STOP -x $HSMTOOL_BASE" || return 0
177         echo "Copytool is suspended on $agents"
178 }
179
180 copytool_remove_backend() {
181         local fid=$1
182         local be=$(find $HSM_ARCHIVE -name $fid)
183         echo "Remove from backend: $fid = $be"
184         rm -f $be
185 }
186
187 import_file() {
188         do_facet $SINGLEAGT \
189                 "$HSMTOOL --archive $HSM_ARCHIVE_NUMBER --hsm-root $HSM_ARCHIVE\
190                 --import $1 $2 $MOUNT" ||
191                 error "import of $1 to $2 failed"
192 }
193
194 make_archive() {
195         local file=$HSM_ARCHIVE/$1
196         mkdir -p $(dirname $file)
197         dd if=/dev/urandom of=$file count=32 bs=1000000 ||
198                 error "cannot create $file"
199 }
200
201 changelog_setup() {
202         CL_USER=$(do_facet $SINGLEMDS $LCTL --device $MDT0\
203                   changelog_register -n)
204         do_facet $SINGLEMDS lctl set_param mdd.$MDT0.changelog_mask="+hsm"
205         $LFS changelog_clear $MDT0 $CL_USER 0
206 }
207
208 changelog_cleanup() {
209 #       $LFS changelog $MDT0
210         [[ -n "$CL_USER" ]] || return 0
211
212         $LFS changelog_clear $MDT0 $CL_USER 0
213         do_facet $SINGLEMDS lctl --device $MDT0 changelog_deregister $CL_USER
214         CL_USER=
215 }
216
217 changelog_get_flags() {
218         local mdt=$1
219         local cltype=$2
220         local fid=$3
221
222         $LFS changelog $mdt | awk "/$cltype/ && /t=\[$fid\]/ {print \$5}"
223 }
224
225 get_hsm_param() {
226         local param=$1
227         local val=$(do_facet $SINGLEMDS $LCTL get_param -n $HSM_PARAM.$param)
228         echo $val
229 }
230
231 set_hsm_param() {
232         local param=$1
233         local value=$2
234         do_facet $SINGLEMDS $LCTL set_param -n $HSM_PARAM.$param=$value
235         return $?
236 }
237
238 set_test_state() {
239         local cmd=$1
240         local target=$2
241         do_facet $SINGLEMDS $LCTL set_param $MDT_PARAM.hsm_control=$cmd
242         wait_result $SINGLEMDS "$LCTL get_param -n $MDT_PARAM.hsm_control"\
243                 $target 10 || error "cdt state is not $target"
244 }
245
246 cdt_set_sanity_policy() {
247         if [[ "$CDT_POLICY_HAD_CHANGED" ]]
248         then
249                 # clear all
250                 do_facet $SINGLEMDS $LCTL set_param $HSM_PARAM.policy=+NRA
251                 do_facet $SINGLEMDS $LCTL set_param $HSM_PARAM.policy=-NBR
252                 CDT_POLICY_HAD_CHANGED=
253         fi
254 }
255
256 cdt_set_no_retry() {
257         do_facet $SINGLEMDS $LCTL set_param $HSM_PARAM.policy=+NRA
258         CDT_POLICY_HAD_CHANGED=true
259 }
260
261 cdt_clear_no_retry() {
262         do_facet $SINGLEMDS $LCTL set_param $HSM_PARAM.policy=-NRA
263         CDT_POLICY_HAD_CHANGED=true
264 }
265
266 cdt_set_non_blocking_restore() {
267         do_facet $SINGLEMDS $LCTL set_param $HSM_PARAM.policy=+NBR
268         CDT_POLICY_HAD_CHANGED=true
269 }
270
271 cdt_clear_non_blocking_restore() {
272         do_facet $SINGLEMDS $LCTL set_param $HSM_PARAM.policy=-NBR
273         CDT_POLICY_HAD_CHANGED=true
274 }
275
276 cdt_clear_mount_state() {
277         # /!\ conf_param and set_param syntax differ +> we cannot use
278         # $MDT_PARAM
279         do_facet $SINGLEMDS $LCTL conf_param -d $FSNAME-MDT0000.mdt.hsm_control
280 }
281
282 cdt_set_mount_state() {
283         # /!\ conf_param and set_param syntax differ +> we cannot use
284         # $MDT_PARAM
285         do_facet $SINGLEMDS $LCTL conf_param $FSNAME-MDT0000.mdt.hsm_control=$1
286 }
287
288 cdt_check_state() {
289         local target=$1
290         wait_result $SINGLEMDS\
291                 "$LCTL get_param -n $MDT_PARAM.hsm_control" "$target" 20 ||
292                         error "cdt state is not $target"
293 }
294
295 cdt_disable() {
296         set_test_state disabled disabled
297 }
298
299 cdt_enable() {
300         set_test_state enabled enabled
301 }
302
303 cdt_shutdown() {
304         set_test_state shutdown stopped
305 }
306
307 cdt_purge() {
308         set_test_state purge enabled
309 }
310
311 cdt_restart() {
312         cdt_shutdown
313         cdt_enable
314         cdt_set_sanity_policy
315 }
316
317 needclients() {
318         local clnt_count=$1
319         if [[ $CLIENTCOUNT -lt $clnt_count ]]; then
320                 skip "Need $clnt_count or more clients, have $CLIENTCOUNT"
321                 return 1
322         fi
323         return 0
324 }
325
326 path2fid() {
327         $LFS path2fid $1 | tr -d '[]'
328 }
329
330 get_hsm_flags() {
331         local f=$1
332         local u=$2
333
334         if [[ $u == "user" ]]
335         then
336                 local st=$($RUNAS $LFS hsm_state $f)
337         else
338                 local st=$($LFS hsm_state $f)
339                 u=root
340         fi
341
342         [[ $? == 0 ]] || error "$LFS hsm_state $f failed (run as $u)"
343
344         st=$(echo $st | cut -f 2 -d" " | tr -d "()," )
345         echo $st
346 }
347
348 get_hsm_archive_id() {
349         local f=$1
350         local st=$($LFS hsm_state $f)
351         [[ $? == 0 ]] || error "$LFS hsm_state $f failed"
352
353         local ar=$(echo $st | grep "archive_id" | cut -f5 -d" " |
354                    cut -f2 -d:)
355         echo $ar
356 }
357
358 check_hsm_flags() {
359         local f=$1
360         local fl=$2
361
362         local st=$(get_hsm_flags $f)
363         [[ $st == $fl ]] || error "hsm flags on $f are $st != $fl"
364 }
365
366 check_hsm_flags_user() {
367         local f=$1
368         local fl=$2
369
370         local st=$(get_hsm_flags $f user)
371         [[ $st == $fl ]] || error "hsm flags on $f are $st != $fl"
372 }
373
374 copy_file() {
375         local f=
376
377         if [[ -d $2 ]]
378         then
379                 f=$2/$(basename $1)
380         else
381                 f=$2
382         fi
383
384         if [[ "$3" != 1 ]]
385         then
386                 f=${f/$DIR/$DIR2}
387         fi
388         rm -f $f
389         cp $1 $f || error "cannot copy $1 to $f"
390         path2fid $f || error "cannot get fid on $f"
391 }
392
393 make_small() {
394         local file2=${1/$DIR/$DIR2}
395         dd if=/dev/urandom of=$file2 count=2 bs=1M conv=fsync ||
396                 error "cannot create $file2"
397         path2fid $1 || error "cannot get fid on $1"
398 }
399
400 cleanup_large_files() {
401         local ratio=$(df $MOUNT |awk '{print $5}' |sed 's/%//g' |grep -v Use)
402         [ $ratio -gt 50 ] && find $MOUNT -size +10M -exec rm -f {} \;
403 }
404
405 make_large_for_striping() {
406         local file2=${1/$DIR/$DIR2}
407         local sz=$($LCTL get_param -n lov.*-clilov-*.stripesize | head -1)
408
409         cleanup_large_files
410
411         dd if=/dev/urandom of=$file2 count=5 bs=$sz conv=fsync ||
412                 error "cannot create $file2"
413         path2fid $1 || error "cannot get fid on $1"
414 }
415
416 make_large_for_progress() {
417         local file2=${1/$DIR/$DIR2}
418
419         cleanup_large_files
420
421         # big file is large enough, so copy time is > 30s
422         # so copytool make 1 progress
423         # size is not a multiple of 1M to avoid stripe
424         # aligment
425         dd if=/dev/urandom of=$file2 count=39 bs=1000000 conv=fsync ||
426                 error "cannot create $file2"
427         path2fid $1 || error "cannot get fid on $1"
428 }
429
430 make_large_for_progress_aligned() {
431         local file2=${1/$DIR/$DIR2}
432
433         cleanup_large_files
434
435         # big file is large enough, so copy time is > 30s
436         # so copytool make 1 progress
437         # size is a multiple of 1M to have stripe
438         # aligment
439         dd if=/dev/urandom of=$file2 count=33 bs=1M conv=fsync ||
440                 error "cannot create $file2"
441         path2fid $1 || error "cannot get fid on $1"
442 }
443
444 make_large_for_cancel() {
445         local file2=${1/$DIR/$DIR2}
446
447         cleanup_large_files
448
449         # Copy timeout is 100s. 105MB => 105s
450         dd if=/dev/urandom of=$file2 count=103 bs=1M conv=fsync ||
451                 error "cannot create $file2"
452         path2fid $1 || error "cannot get fid on $1"
453 }
454
455 wait_result() {
456         local facet=$1
457         shift
458         wait_update --verbose $(facet_active_host $facet) "$@"
459 }
460
461 wait_request_state() {
462         local fid=$1
463         local request=$2
464         local state=$3
465
466         local cmd="$LCTL get_param -n $HSM_PARAM.agent_actions"
467         cmd+=" | awk '/'$fid'.*action='$request'/ {print \\\$13}' | cut -f2 -d="
468
469         wait_result $SINGLEMDS "$cmd" $state 100 ||
470                 error "request on $fid is not $state"
471 }
472
473 get_request_state() {
474         local fid=$1
475         local request=$2
476
477         do_facet $SINGLEMDS "$LCTL get_param -n $HSM_PARAM.agent_actions |"\
478                 "awk '/'$fid'.*action='$request'/ {print \\\$13}' | cut -f2 -d="
479 }
480
481 get_request_count() {
482         local fid=$1
483         local request=$2
484
485         do_facet $SINGLEMDS "$LCTL get_param -n $HSM_PARAM.agent_actions |"\
486                 "awk -vn=0 '/'$fid'.*action='$request'/ {n++}; END {print n}'"
487 }
488
489 wait_all_done() {
490         local timeout=$1
491
492         local cmd="$LCTL get_param -n $HSM_PARAM.agent_actions"
493         cmd+=" | egrep 'WAITING|STARTED'"
494
495         wait_result $SINGLEMDS "$cmd" "" $timeout ||
496                 error "requests did not complete"
497 }
498
499 wait_for_grace_delay() {
500         local val=$(get_hsm_param grace_delay)
501         sleep $val
502 }
503
504 MDT0=$($LCTL get_param -n mdc.*.mds_server_uuid |
505         awk '{gsub(/_UUID/,""); print $1}' | head -1)
506
507 # initiate variables
508 init_agt_vars
509
510 # cleanup from previous bad setup
511 search_and_kill_copytool
512
513 # for recovery tests, coordinator needs to be started at mount
514 # so force it
515 # the lustre conf must be without hsm on (like for sanity.sh)
516 echo "Set HSM on and start"
517 cdt_set_mount_state enabled
518 cdt_check_state enabled
519
520 echo "Start copytool"
521 copytool_setup
522
523 echo "Set sanity-hsm HSM policy"
524 cdt_set_sanity_policy
525
526 # finished requests are quickly removed from list
527 set_hsm_param grace_delay 10
528
529 test_1() {
530         mkdir -p $DIR/$tdir
531         chmod 777 $DIR/$tdir
532
533         local f=$DIR/$tdir/$tfile
534         $RUNAS touch $f
535
536         # User flags
537         check_hsm_flags_user $f "0x00000000"
538
539         $RUNAS $LFS hsm_set --norelease $f ||
540                 error "user could not change hsm flags"
541         check_hsm_flags_user $f "0x00000010"
542
543         $RUNAS $LFS hsm_clear --norelease $f ||
544                 error "user could not clear hsm flags"
545         check_hsm_flags_user $f "0x00000000"
546
547         # User could not change those flags...
548         $RUNAS $LFS hsm_set --exists $f &&
549                 error "user should not set this flag"
550         check_hsm_flags_user $f "0x00000000"
551
552         # ...but root can
553         $LFS hsm_set --exists $f ||
554                 error "root could not change hsm flags"
555         check_hsm_flags_user $f "0x00000001"
556
557         $LFS hsm_clear --exists $f ||
558                 error "root could not clear hsm state"
559         check_hsm_flags_user $f "0x00000000"
560
561 }
562 run_test 1 "lfs hsm flags root/non-root access"
563
564 test_2() {
565         mkdir -p $DIR/$tdir
566         local f=$DIR/$tdir/$tfile
567         touch $f
568         # New files are not dirty
569         check_hsm_flags $f "0x00000000"
570
571         # For test, we simulate an archived file.
572         $LFS hsm_set --exists $f || error "user could not change hsm flags"
573         check_hsm_flags $f "0x00000001"
574
575         # chmod do not put the file dirty
576         chmod 600 $f || error "could not chmod test file"
577         check_hsm_flags $f "0x00000001"
578
579         # chown do not put the file dirty
580         chown $RUNAS_ID $f || error "could not chown test file"
581         check_hsm_flags $f "0x00000001"
582
583         # truncate put the file dirty
584         $TRUNCATE $f 1 || error "could not truncate test file"
585         check_hsm_flags $f "0x00000003"
586
587         $LFS hsm_clear --dirty $f || error "could not clear hsm flags"
588         check_hsm_flags $f "0x00000001"
589 }
590 run_test 2 "Check file dirtyness when doing setattr"
591
592 test_3() {
593         mkdir -p $DIR/$tdir
594         f=$DIR/$tdir/$tfile
595
596         # New files are not dirty
597         cp -p /etc/passwd $f
598         check_hsm_flags $f "0x00000000"
599
600         # For test, we simulate an archived file.
601         $LFS hsm_set --exists $f ||
602                 error "user could not change hsm flags"
603         check_hsm_flags $f "0x00000001"
604
605         # Reading a file, does not set dirty
606         cat $f > /dev/null || error "could not read file"
607         check_hsm_flags $f "0x00000001"
608
609         # Open for write without modifying data, does not set dirty
610         openfile -f O_WRONLY $f || error "could not open test file"
611         check_hsm_flags $f "0x00000001"
612
613         # Append to a file sets it dirty
614         cp -p /etc/passwd $f.append || error "could not create file"
615         $LFS hsm_set --exists $f.append ||
616                 error "user could not change hsm flags"
617         dd if=/etc/passwd of=$f.append bs=1 count=3\
618            conv=notrunc oflag=append status=noxfer ||
619                 error "could not append to test file"
620         check_hsm_flags $f.append "0x00000003"
621
622         # Modify a file sets it dirty
623         cp -p /etc/passwd $f.modify || error "could not create file"
624         $LFS hsm_set --exists $f.modify ||
625                 error "user could not change hsm flags"
626         dd if=/dev/zero of=$f.modify bs=1 count=3\
627            conv=notrunc status=noxfer ||
628                 error "could not modify test file"
629         check_hsm_flags $f.modify "0x00000003"
630
631         # Open O_TRUNC sets dirty
632         cp -p /etc/passwd $f.trunc || error "could not create file"
633         $LFS hsm_set --exists $f.trunc ||
634                 error "user could not change hsm flags"
635         cp /etc/group $f.trunc || error "could not override a file"
636         check_hsm_flags $f.trunc "0x00000003"
637
638         # Mmapped a file sets dirty
639         cp -p /etc/passwd $f.mmap || error "could not create file"
640         $LFS hsm_set --exists $f.mmap ||
641                 error "user could not change hsm flags"
642         multiop $f.mmap OSMWUc || error "could not mmap a file"
643         check_hsm_flags $f.mmap "0x00000003"
644 }
645 run_test 3 "Check file dirtyness when opening for write"
646
647 test_4() {
648         mkdir -p $DIR/$tdir
649         local f=$DIR/$tdir/$tfile
650         local fid=$(make_small $f)
651
652         $LFS hsm_cancel $f
653         local st=$(get_request_state $fid CANCEL)
654         [[ -z "$st" ]] || error "hsm_cancel must not be registered (state=$st)"
655 }
656 run_test 4 "Useless cancel must not be registered"
657
658 test_8() {
659         # test needs a running copytool
660         copytool_setup
661
662         mkdir -p $DIR/$tdir
663         local f=$DIR/$tdir/$tfile
664         local fid=$(copy_file /etc/passwd $f)
665         $LFS hsm_archive $f
666         wait_request_state $fid ARCHIVE SUCCEED
667
668         check_hsm_flags $f "0x00000009"
669
670         copytool_cleanup
671 }
672 run_test 8 "Test default archive number"
673
674 test_9() {
675         mkdir -p $DIR/$tdir
676         local f=$DIR/$tdir/$tfile
677         local fid=$(copy_file /etc/passwd $f)
678         # we do not use the default one to be sure
679         local new_an=$((HSM_ARCHIVE_NUMBER + 1))
680         copytool_cleanup
681         copytool_setup $SINGLEAGT $MOUNT $new_an
682         $LFS hsm_archive --archive $new_an $f
683         wait_request_state $fid ARCHIVE SUCCEED
684
685         check_hsm_flags $f "0x00000009"
686
687         copytool_cleanup
688 }
689 run_test 9 "Use of explict archive number, with dedicated copytool"
690
691 test_9a() {
692         needclients 3 || return 0
693
694         local n
695         local file
696         local fid
697
698         copytool_cleanup $(comma_list $(agts_nodes))
699
700         # start all of the copytools
701         for n in $(seq $AGTCOUNT); do
702                 copytool_setup agt$n
703         done
704
705         trap "copytool_cleanup $(comma_list $(agts_nodes))" EXIT
706         # archive files
707         mkdir -p $DIR/$tdir
708         for n in $(seq $AGTCOUNT); do
709                 file=$DIR/$tdir/$tfile.$n
710                 fid=$(make_small $file)
711
712                 $LFS hsm_archive $file || error "could not archive file $file"
713                 wait_request_state $fid ARCHIVE SUCCEED
714                 check_hsm_flags $file "0x00000009"
715         done
716
717         trap - EXIT
718         copytool_cleanup $(comma_list $(agts_nodes))
719 }
720 run_test 9a "Multiple remote agents"
721
722 test_10a() {
723         # test needs a running copytool
724         copytool_setup
725
726         mkdir -p $DIR/$tdir/d1
727         local f=$DIR/$tdir/$tfile
728         local fid=$(copy_file /etc/hosts $f)
729         $LFS hsm_archive -a $HSM_ARCHIVE_NUMBER $f ||
730                 error "hsm_archive failed"
731         wait_request_state $fid ARCHIVE SUCCEED
732
733         local AFILE=$(ls $HSM_ARCHIVE/*/*/*/*/*/*/$fid) ||
734                 error "fid $fid not in archive $HSM_ARCHIVE"
735         echo "Verifying content"
736         diff $f $AFILE || error "archived file differs"
737         echo "Verifying hsm state "
738         check_hsm_flags $f "0x00000009"
739
740         echo "Verifying archive number is $HSM_ARCHIVE_NUMBER"
741         local st=$(get_hsm_archive_id $f)
742         [[ $st == $HSM_ARCHIVE_NUMBER ]] ||
743                 error "Wrong archive number, $st != $HSM_ARCHIVE_NUMBER"
744
745         copytool_cleanup
746
747 }
748 run_test 10a "Archive a file"
749
750 test_10b() {
751         # test needs a running copytool
752         copytool_setup
753
754         mkdir -p $DIR/$tdir $HSM_ARCHIVE/$tdir
755         local f=$DIR/$tdir/$tfile
756         local fid=$(copy_file /etc/hosts $f)
757         $LFS hsm_archive $f || error "archive request failed"
758         wait_request_state $fid ARCHIVE SUCCEED
759
760         $LFS hsm_archive $f || error "archive of non dirty file failed"
761         local cnt=$(get_request_count $fid ARCHIVE)
762         [[ "$cnt" == "1" ]] ||
763                 error "archive of non dirty file must not make a request"
764
765         copytool_cleanup
766 }
767 run_test 10b "Archive of non dirty file must work without doing request"
768
769 test_10c() {
770         # test needs a running copytool
771         copytool_setup
772
773         mkdir -p $DIR/$tdir $HSM_ARCHIVE/$tdir
774         local f=$DIR/$tdir/$tfile
775         local fid=$(copy_file /etc/hosts $f)
776         $LFS hsm_set --noarchive $f
777         $LFS hsm_archive $f && error "archive a noarchive file must fail"
778
779         copytool_cleanup
780 }
781 run_test 10c "Check forbidden archive"
782
783 test_10d() {
784         # test needs a running copytool
785         copytool_setup
786
787         mkdir -p $DIR/$tdir
788         local f=$DIR/$tdir/$tfile
789         local fid=$(copy_file /etc/hosts $f)
790         $LFS hsm_archive $f || error "cannot archive $f"
791         wait_request_state $fid ARCHIVE SUCCEED
792
793         local ar=$(get_hsm_archive_id $f)
794         local dflt=$(get_hsm_param archive_id)
795         [[ $ar == $dflt ]] ||
796                 error "archived file is not on default archive: $ar != $dflt"
797
798         copytool_cleanup
799 }
800 run_test 10d "Archive a file on the default archive id"
801
802 test_11() {
803         mkdir -p $DIR/$tdir $HSM_ARCHIVE/$tdir
804         cp /etc/hosts $HSM_ARCHIVE/$tdir/$tfile
805         local f=$DIR/$tdir/$tfile
806
807         import_file $tdir/$tfile $f
808         echo -n "Verifying released state: "
809         check_hsm_flags $f "0x0000000d"
810
811         local LSZ=$(stat -c "%s" $f)
812         local ASZ=$(stat -c "%s" $HSM_ARCHIVE/$tdir/$tfile)
813
814         echo "Verifying imported size $LSZ=$ASZ"
815         [[ $LSZ -eq $ASZ ]] || error "Incorrect size $LSZ != $ASZ"
816         echo -n "Verifying released pattern: "
817         local PTRN=$($GETSTRIPE -L $f)
818         echo $PTRN
819         [[ $PTRN == 80000001 ]] || error "Is not released"
820         local fid=$(path2fid $f)
821         echo "Verifying new fid $fid in archive"
822
823         local AFILE=$(ls $HSM_ARCHIVE/*/*/*/*/*/*/$fid) ||
824                 error "fid $fid not in archive $HSM_ARCHIVE"
825 }
826 run_test 11 "Import a file"
827
828 test_12a() {
829         # test needs a running copytool
830         copytool_setup
831
832         mkdir -p $DIR/$tdir $HSM_ARCHIVE/$tdir
833         cp /etc/hosts $HSM_ARCHIVE/$tdir/$tfile
834         local f=$DIR/$tdir/$tfile
835         import_file $tdir/$tfile $f
836         local f=$DIR2/$tdir/$tfile
837         echo "Verifying released state: "
838         check_hsm_flags $f "0x0000000d"
839
840         local fid=$(path2fid $f)
841         $LFS hsm_restore $f
842         wait_request_state $fid RESTORE SUCCEED
843
844         echo "Verifying file state: "
845         check_hsm_flags $f "0x00000009"
846
847         diff -q $HSM_ARCHIVE/$tdir/$tfile $f
848
849         [[ $? -eq 0 ]] || error "Restored file differs"
850
851         copytool_cleanup
852 }
853 run_test 12a "Restore an imported file explicitly"
854
855 test_12b() {
856         # test needs a running copytool
857         copytool_setup
858
859         mkdir -p $DIR/$tdir $HSM_ARCHIVE/$tdir
860         cp /etc/hosts $HSM_ARCHIVE/$tdir/$tfile
861         local f=$DIR/$tdir/$tfile
862         import_file $tdir/$tfile $f
863         echo "Verifying released state: "
864         check_hsm_flags $f "0x0000000d"
865
866         cat $f > /dev/null || error "File read failed"
867
868         echo "Verifying file state after restore: "
869         check_hsm_flags $f "0x00000009"
870
871         diff -q $HSM_ARCHIVE/$tdir/$tfile $f
872
873         [[ $? -eq 0 ]] || error "Restored file differs"
874
875         copytool_cleanup
876 }
877 run_test 12b "Restore an imported file implicitly"
878
879 test_12c() {
880         [ "$OSTCOUNT" -lt "2" ] && skip_env "skipping 2-stripe test" && return
881
882         # test needs a running copytool
883         copytool_setup
884
885         mkdir -p $DIR/$tdir
886         local f=$DIR/$tdir/$tfile
887         $LFS setstripe -c 2 $f
888         local fid=$(make_large_for_striping $f)
889         local FILE_CRC=$(md5sum $f)
890
891         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
892         wait_request_state $fid ARCHIVE SUCCEED
893         $LFS hsm_release $f || error "release $f failed"
894
895         echo "$FILE_CRC" | md5sum -c
896
897         [[ $? -eq 0 ]] || error "Restored file differs"
898
899         copytool_cleanup
900 }
901 run_test 12c "Restore a file with stripe of 2"
902
903 test_12d() {
904         # test needs a running copytool
905         copytool_setup
906
907         mkdir -p $DIR/$tdir $HSM_ARCHIVE/$tdir
908         local f=$DIR/$tdir/$tfile
909         local fid=$(copy_file /etc/hosts $f)
910         $LFS hsm_restore $f || error "restore of non archived file failed"
911         local cnt=$(get_request_count $fid RESTORE)
912         [[ "$cnt" == "0" ]] ||
913                 error "restore non archived must not make a request"
914         $LFS hsm_archive $f ||
915                 error "archive request failed"
916         wait_request_state $fid ARCHIVE SUCCEED
917         $LFS hsm_restore $f ||
918                 error "restore of non released file failed"
919         local cnt=$(get_request_count $fid RESTORE)
920         [[ "$cnt" == "0" ]] ||
921                 error "restore a non dirty file must not make a request"
922
923         copytool_cleanup
924 }
925 run_test 12d "Restore of a non archived, non released file must work"\
926                 " without doing request"
927
928 test_12e() {
929         # test needs a running copytool
930         copytool_setup
931
932         mkdir -p $DIR/$tdir $HSM_ARCHIVE/$tdir
933         local f=$DIR/$tdir/$tfile
934         local fid=$(copy_file /etc/hosts $f)
935         $LFS hsm_archive $f || error "archive request failed"
936         wait_request_state $fid ARCHIVE SUCCEED
937
938         # make file dirty
939         cat /etc/hosts >> $f
940         sync
941         $LFS hsm_state $f
942
943         $LFS hsm_restore $f && error "restore a dirty file must fail"
944
945         copytool_cleanup
946 }
947 run_test 12e "Check forbidden restore"
948
949 test_12f() {
950         # test needs a running copytool
951         copytool_setup
952
953         mkdir -p $DIR/$tdir
954         local f=$DIR/$tdir/$tfile
955         local fid=$(copy_file /etc/hosts $f)
956
957         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
958         wait_request_state $fid ARCHIVE SUCCEED
959         $LFS hsm_release $f || error "release of $f failed"
960         $LFS hsm_restore $f
961         wait_request_state $fid RESTORE SUCCEED
962
963         echo -n "Verifying file state: "
964         check_hsm_flags $f "0x00000009"
965
966         diff -q /etc/hosts $f
967
968         [[ $? -eq 0 ]] || error "Restored file differs"
969
970         copytool_cleanup
971 }
972 run_test 12f "Restore a released file explicitly"
973
974 test_12g() {
975         # test needs a running copytool
976         copytool_setup
977
978         mkdir -p $DIR/$tdir
979         local f=$DIR/$tdir/$tfile
980         local fid=$(copy_file /etc/hosts $f)
981
982         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
983         wait_request_state $fid ARCHIVE SUCCEED
984         $LFS hsm_release $f || error "release of $f failed"
985
986         diff -q /etc/hosts $f
987         local st=$?
988
989         # we check we had a restore done
990         wait_request_state $fid RESTORE SUCCEED
991
992         [[ $st -eq 0 ]] || error "Restored file differs"
993
994         copytool_cleanup
995 }
996 run_test 12g "Restore a released file implicitly"
997
998 test_12h() {
999         needclients 2 || return 0
1000
1001         # test needs a running copytool
1002         copytool_setup
1003
1004         mkdir -p $DIR/$tdir
1005         local f=$DIR/$tdir/$tfile
1006         local fid=$(copy_file /etc/hosts $f)
1007
1008         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
1009         wait_request_state $fid ARCHIVE SUCCEED
1010         $LFS hsm_release $f || error "release of $f failed"
1011
1012         do_node $CLIENT2 diff -q /etc/hosts $f
1013         local st=$?
1014
1015         # we check we had a restore done
1016         wait_request_state $fid RESTORE SUCCEED
1017
1018         [[ $st -eq 0 ]] || error "Restored file differs"
1019
1020         copytool_cleanup
1021 }
1022 run_test 12h "Restore a released file implicitly from a second node"
1023
1024 test_12m() {
1025         # test needs a running copytool
1026         copytool_setup
1027
1028         mkdir -p $DIR/$tdir
1029         local f=$DIR/$tdir/$tfile
1030         local fid=$(copy_file /etc/passwd $f)
1031         $LFS hsm_archive $f || error "archive of $f failed"
1032         wait_request_state $fid ARCHIVE SUCCEED
1033
1034         $LFS hsm_release $f || error "release of $f failed"
1035
1036         cmp /etc/passwd $f
1037
1038         [[ $? -eq 0 ]] || error "Restored file differs"
1039
1040         copytool_cleanup
1041 }
1042 run_test 12m "Archive/release/implicit restore"
1043
1044 test_12n() {
1045         # test needs a running copytool
1046         copytool_setup
1047
1048         mkdir -p $DIR/$tdir $HSM_ARCHIVE/$tdir
1049         cp /etc/hosts $HSM_ARCHIVE/$tdir/$tfile
1050         local f=$DIR/$tdir/$tfile
1051         import_file $tdir/$tfile $f
1052
1053         cmp /etc/hosts $f || error "Restored file differs"
1054
1055         $LFS hsm_release $f || error "release of $f failed"
1056
1057         copytool_cleanup
1058 }
1059 run_test 12n "Import/implicit restore/release"
1060
1061 test_13() {
1062         # test needs a running copytool
1063         copytool_setup
1064
1065         local ARC_SUBDIR="import.orig"
1066         local d=""
1067         local f=""
1068
1069         # populate directory to be imported
1070         for d in $(seq 1 10); do
1071                 local CURR_DIR="$HSM_ARCHIVE/$ARC_SUBDIR/dir.$d"
1072                 mkdir -p "$CURR_DIR"
1073                 for f in $(seq 1 10); do
1074                         CURR_FILE="$CURR_DIR/$tfile.$f"
1075                         # write file-specific data
1076                         echo "d=$d, f=$f, dir=$CURR_DIR, file=$CURR_FILE"\
1077                                 > $CURR_FILE
1078                 done
1079         done
1080         # import to Lustre
1081         import_file "$ARC_SUBDIR" $DIR/$tdir
1082         # diff lustre content and origin (triggers file restoration)
1083         # there must be 10x10 identical files, and no difference
1084         local cnt_ok=$(diff -rs $HSM_ARCHIVE/$ARC_SUBDIR \
1085                        $DIR/$tdir/$ARC_SUBDIR |
1086                 grep identical | wc -l)
1087         local cnt_diff=$(diff -r $HSM_ARCHIVE/$ARC_SUBDIR \
1088                          $DIR/$tdir/$ARC_SUBDIR |
1089                 wc -l)
1090
1091         [ $cnt_diff -eq 0 ] ||
1092                 error "$cnt_diff imported files differ from read data"
1093         [ $cnt_ok -eq 100 ] ||
1094                 error "not enough identical files ($cnt_ok != 100)"
1095
1096         copytool_cleanup
1097 }
1098 run_test 13 "Recursively import and restore a directory"
1099
1100 test_14() {
1101         # test needs a running copytool
1102         copytool_setup
1103
1104         # archive a file
1105         mkdir -p $DIR/$tdir
1106         local f=$DIR/$tdir/$tfile
1107         local fid=$(make_small $f)
1108         local sum=$(md5sum $f | awk '{print $1}')
1109         $LFS hsm_archive $f || error "could not archive file"
1110         wait_request_state $fid ARCHIVE SUCCEED
1111
1112         # delete the file
1113         rm -f $f
1114         # create released file (simulate llapi_hsm_import call)
1115         touch $f
1116         local fid2=$(path2fid $f)
1117         $LFS hsm_set --archived --exists $f || error "could not force hsm flags"
1118         $LFS hsm_release $f || error "could not release file"
1119
1120         # rebind the archive to the newly created file
1121         echo "rebind $fid to $fid2"
1122
1123         do_facet $SINGLEAGT \
1124                 "$HSMTOOL --archive $HSM_ARCHIVE_NUMBER --hsm-root $HSM_ARCHIVE\
1125                  --rebind $fid $fid2 $DIR" || error "could not rebind file"
1126
1127         # restore file and compare md5sum
1128         local sum2=$(md5sum $f | awk '{print $1}')
1129
1130         [[ $sum == $sum2 ]] || error "md5sum mismatch after restore"
1131
1132         copytool_cleanup
1133 }
1134 run_test 14 "Rebind archived file to a new fid"
1135
1136 test_15() {
1137         # test needs a running copytool
1138         copytool_setup
1139
1140         # archive files
1141         mkdir -p $DIR/$tdir
1142         local f=$DIR/$tdir/$tfile
1143         local count=5
1144         local tmpfile=$SHARED_DIRECTORY/tmp.$$
1145
1146         local fids=()
1147         local sums=()
1148         for i in $(seq 1 $count); do
1149                 fids[$i]=$(make_small $f.$i)
1150                 sums[$i]=$(md5sum $f.$i | awk '{print $1}')
1151                 $LFS hsm_archive $f.$i || error "could not archive file"
1152         done
1153         wait_all_done $(($count*60))
1154
1155         :>$tmpfile
1156         # delete the files
1157         for i in $(seq 1 $count); do
1158                 rm -f $f.$i
1159                 touch $f.$i
1160                 local fid2=$(path2fid $f.$i)
1161                 # add the rebind operation to the list
1162                 echo ${fids[$i]} $fid2 >> $tmpfile
1163
1164                 # set it released (simulate llapi_hsm_import call)
1165                 $LFS hsm_set --archived --exists $f.$i ||
1166                         error "could not force hsm flags"
1167                 $LFS hsm_release $f.$i || error "could not release file"
1168         done
1169         nl=$(wc -l < $tmpfile)
1170         [[ $nl == $count ]] || error "$nl files in list, $count expected"
1171
1172         echo "rebind list of files"
1173         do_facet $SINGLEAGT \
1174                 "$HSMTOOL --archive $HSM_ARCHIVE_NUMBER --hsm-root $HSM_ARCHIVE\
1175                  --rebind $tmpfile $DIR" || error "could not rebind file list"
1176
1177         # restore files and compare md5sum
1178         for i in $(seq 1 $count); do
1179                 local sum2=$(md5sum $f.$i | awk '{print $1}')
1180                 [[ $sum2 == ${sums[$i]} ]] ||
1181                     error "md5sum mismatch after restore ($sum2 != ${sums[$i]})"
1182         done
1183
1184         rm -f $tmpfile
1185         copytool_cleanup
1186 }
1187 run_test 15 "Rebind a list of files"
1188
1189 test_16() {
1190         # test needs a running copytool
1191         copytool_setup
1192
1193         local ref=/tmp/ref
1194         # create a known size file so we can verify transfer speed
1195         # 20 MB <-> 20s
1196         local goal=20
1197         dd if=/dev/zero of=$ref bs=1M count=20
1198
1199         mkdir -p $DIR/$tdir
1200         local f=$DIR/$tdir/$tfile
1201         local fid=$(copy_file $ref $f)
1202         rm $ref
1203         local start=$(date +%s)
1204         $LFS hsm_archive $f
1205         wait_request_state $fid ARCHIVE SUCCEED
1206         local end=$(date +%s)
1207         local duration=$((end - start))
1208
1209         [[ $duration -ge $goal ]] ||
1210                 error "Transfer is too fast $duration < $goal"
1211
1212         copytool_cleanup
1213 }
1214 run_test 16 "Test CT bandwith control option"
1215
1216 test_20() {
1217         mkdir -p $DIR/$tdir
1218
1219         local f=$DIR/$tdir/$tfile
1220         touch $f || error "touch $f failed"
1221
1222         # Could not release a non-archived file
1223         $LFS hsm_release $f && error "release should not succeed"
1224
1225         # For following tests, we must test them with HS_ARCHIVED set
1226         $LFS hsm_set --exists --archived $f || error "could not add flag"
1227
1228         # Could not release a file if no-release is set
1229         $LFS hsm_set --norelease $f || error "could not add flag"
1230         $LFS hsm_release $f && error "release should not succeed"
1231         $LFS hsm_clear --norelease $f || error "could not remove flag"
1232
1233         # Could not release a file if lost
1234         $LFS hsm_set --lost $f || error "could not add flag"
1235         $LFS hsm_release $f && error "release should not succeed"
1236         $LFS hsm_clear --lost $f || error "could not remove flag"
1237
1238         # Could not release a file if dirty
1239         $LFS hsm_set --dirty $f || error "could not add flag"
1240         $LFS hsm_release $f && error "release should not succeed"
1241         $LFS hsm_clear --dirty $f || error "could not remove flag"
1242 }
1243 run_test 20 "Release is not permitted"
1244
1245 test_21() {
1246         # test needs a running copytool
1247         copytool_setup
1248
1249         mkdir -p $DIR/$tdir
1250         local f=$DIR/$tdir/test_release
1251
1252         # Create a file and check its states
1253         local fid=$(make_small $f)
1254         check_hsm_flags $f "0x00000000"
1255
1256         $LFS hsm_archive $f || error "could not archive file"
1257         wait_request_state $fid ARCHIVE SUCCEED
1258
1259         [ $(stat -c "%b" $f) -ne "1" ] || error "wrong block number"
1260         local sz=$(stat -c "%s" $f)
1261         [ $sz -ne "0" ] || error "file size should not be zero"
1262
1263         # Release and check states
1264         $LFS hsm_release $f || error "could not release file"
1265         check_hsm_flags $f "0x0000000d"
1266
1267         [ $(stat -c "%b" $f) -eq "1" ] || error "wrong block number"
1268         [ $(stat -c "%s" $f) -eq $sz ] || error "wrong file size"
1269
1270         # Check we can release an file without stripe info
1271         f=$f.nolov
1272         $MCREATE $f
1273         fid=$(path2fid $f)
1274         check_hsm_flags $f "0x00000000"
1275         $LFS hsm_archive $f || error "could not archive file"
1276         wait_request_state $fid ARCHIVE SUCCEED
1277
1278         # Release and check states
1279         $LFS hsm_release $f || error "could not release file"
1280         check_hsm_flags $f "0x0000000d"
1281
1282         # Release again a file that is already released is OK
1283         $LFS hsm_release $f || fail "second release should succeed"
1284         check_hsm_flags $f "0x0000000d"
1285
1286         copytool_cleanup
1287 }
1288 run_test 21 "Simple release tests"
1289
1290 test_22() {
1291         # test needs a running copytool
1292         copytool_setup
1293
1294         mkdir -p $DIR/$tdir
1295
1296         local f=$DIR/$tdir/test_release
1297         local swap=$DIR/$tdir/test_swap
1298
1299         # Create a file and check its states
1300         local fid=$(make_small $f)
1301         check_hsm_flags $f "0x00000000"
1302
1303         $LFS hsm_archive $f || error "could not archive file"
1304         wait_request_state $fid ARCHIVE SUCCEED
1305
1306         # Release and check states
1307         $LFS hsm_release $f || error "could not release file"
1308         check_hsm_flags $f "0x0000000d"
1309
1310         make_small $swap
1311         $LFS swap_layouts $swap $f && error "swap_layouts should failed"
1312
1313         true
1314         copytool_cleanup
1315 }
1316 run_test 22 "Could not swap a release file"
1317
1318 test_23() {
1319         # test needs a running copytool
1320         copytool_setup
1321
1322         mkdir -p $DIR/$tdir
1323
1324         local f=$DIR/$tdir/test_mtime
1325
1326         # Create a file and check its states
1327         local fid=$(make_small $f)
1328         check_hsm_flags $f "0x00000000"
1329
1330         $LFS hsm_archive $f || error "could not archive file"
1331         wait_request_state $fid ARCHIVE SUCCEED
1332
1333         # Set modification time in the past
1334         touch -m -a -d @978261179 $f
1335
1336         # Release and check states
1337         $LFS hsm_release $f || error "could not release file"
1338         check_hsm_flags $f "0x0000000d"
1339
1340         local MTIME=$(stat -c "%Y" $f)
1341         local ATIME=$(stat -c "%X" $f)
1342         [ $MTIME -eq "978261179" ] || fail "bad mtime: $MTIME"
1343         [ $ATIME -eq "978261179" ] || fail "bad atime: $ATIME"
1344
1345         copytool_cleanup
1346 }
1347 run_test 23 "Release does not change a/mtime (utime)"
1348
1349 test_24a() {
1350         local file=$DIR/$tdir/$tfile
1351         local fid
1352         local atime0
1353         local atime1
1354         local mtime0
1355         local mtime1
1356         local ctime0
1357         local ctime1
1358
1359         # test needs a running copytool
1360         copytool_setup
1361
1362         mkdir -p $DIR/$tdir
1363         rm -f $file
1364         fid=$(make_small $file)
1365
1366         # Create a file and check its states
1367         check_hsm_flags $file "0x00000000"
1368
1369         # Ensure atime is less than mtime and ctime.
1370         sleep 1
1371         echo >> $file
1372
1373         atime0=$(stat -c "%X" $file)
1374         mtime0=$(stat -c "%Y" $file)
1375         ctime0=$(stat -c "%Z" $file)
1376
1377         [ $atime0 -lt $mtime0 ] ||
1378                 error "atime $atime0 is not less than mtime $mtime0"
1379
1380         [ $atime0 -lt $ctime0 ] ||
1381                 error "atime $atime0 is not less than ctime $ctime0"
1382
1383         # Archive should not change any timestamps.
1384         $LFS hsm_archive $file || error "cannot archive '$file'"
1385         wait_request_state $fid ARCHIVE SUCCEED
1386
1387         atime1=$(stat -c "%X" $file)
1388         mtime1=$(stat -c "%Y" $file)
1389         ctime1=$(stat -c "%Z" $file)
1390
1391         [ $atime0 -eq $atime1 ] ||
1392                 error "archive changed atime from $atime0 to $atime1"
1393
1394         [ $mtime0 -eq $mtime1 ] ||
1395                 error "archive changed mtime from $mtime0 to $mtime1"
1396
1397         [ $ctime0 -eq $ctime1 ] ||
1398                 error "archive changed ctime from $ctime0 to $ctime1"
1399
1400         # Release should not change any timestamps.
1401         $LFS hsm_release $file || error "cannot release '$file'"
1402         check_hsm_flags $file "0x0000000d"
1403
1404         atime1=$(stat -c "%X" $file)
1405         mtime1=$(stat -c "%Y" $file)
1406         ctime1=$(stat -c "%Z" $file)
1407
1408         [ $atime0 -eq $atime1 ] ||
1409                 error "release changed atime from $atime0 to $atime1"
1410
1411         [ $mtime0 -eq $mtime1 ] ||
1412                 error "release changed mtime from $mtime0 to $mtime1"
1413
1414         [ $ctime0 -eq $ctime1 ] ||
1415                 error "release changed ctime from $ctime0 to $ctime1"
1416
1417         # Restore should not change atime or mtime and should not
1418         # decrease ctime.
1419         $LFS hsm_restore $file
1420         wait_request_state $fid RESTORE SUCCEED
1421
1422         atime1=$(stat -c "%X" $file)
1423         mtime1=$(stat -c "%Y" $file)
1424         ctime1=$(stat -c "%Z" $file)
1425
1426         [ $atime0 -eq $atime1 ] ||
1427                 error "restore changed atime from $atime0 to $atime1"
1428
1429         [ $mtime0 -eq $mtime1 ] ||
1430                 error "restore changed mtime from $mtime0 to $mtime1"
1431
1432         [ $ctime0 -le $ctime1 ] ||
1433                 error "restore changed ctime from $ctime0 to $ctime1"
1434
1435         copytool_cleanup
1436
1437         # Once more, after unmount and mount.
1438         umount_client $MOUNT || error "cannot unmount '$MOUNT'"
1439         mount_client $MOUNT || error "cannot mount '$MOUNT'"
1440
1441         atime1=$(stat -c "%X" $file)
1442         mtime1=$(stat -c "%Y" $file)
1443         ctime1=$(stat -c "%Z" $file)
1444
1445         [ $atime0 -eq $atime1 ] ||
1446                 error "remount changed atime from $atime0 to $atime1"
1447
1448         [ $mtime0 -eq $mtime1 ] ||
1449                 error "remount changed mtime from $mtime0 to $mtime1"
1450
1451         [ $ctime0 -le $ctime1 ] ||
1452                 error "remount changed ctime from $ctime0 to $ctime1"
1453 }
1454 run_test 24a "Archive, release, and restore does not change a/mtime (i/o)"
1455
1456 test_24b() {
1457         local file=$DIR/$tdir/$tfile
1458         local fid
1459         local sum0
1460         local sum1
1461         # LU-3811
1462
1463         # Test needs a running copytool.
1464         copytool_setup
1465         mkdir -p $DIR/$tdir
1466
1467         # Check that root can do HSM actions on a ordinary user's file.
1468         rm -f $file
1469         fid=$(make_small $file)
1470         sum0=$(md5sum $file)
1471
1472         chown $RUNAS_ID:$RUNAS_GID $file ||
1473                 error "cannot chown '$file' to '$RUNAS_ID'"
1474
1475         chmod ugo-w $DIR/$tdir ||
1476                 error "cannot chmod '$DIR/$tdir'"
1477
1478         $LFS hsm_archive $file
1479         wait_request_state $fid ARCHIVE SUCCEED
1480
1481         $LFS hsm_release $file ||
1482                 check_hsm_flags $file "0x0000000d"
1483
1484         $LFS hsm_restore $file
1485         wait_request_state $fid RESTORE SUCCEED
1486
1487         # Check that ordinary user can get HSM state.
1488         $RUNAS $LFS hsm_state $file ||
1489                 error "user '$RUNAS_ID' cannot get HSM state of '$file'"
1490
1491         $LFS hsm_release $file ||
1492                 check_hsm_flags $file "0x0000000d"
1493
1494         # Check that ordinary user can accessed released file.
1495         sum1=$($RUNAS md5sum $file) ||
1496                 error "user '$RUNAS_ID' cannot read '$file'"
1497
1498         [ "$sum0" == "$sum1" ] ||
1499                 error "md5sum mismatch for '$file'"
1500
1501         copytool_cleanup
1502 }
1503 run_test 24b "root can archive, release, and restore user files"
1504
1505 test_25a() {
1506         # test needs a running copytool
1507         copytool_setup
1508
1509         mkdir -p $DIR/$tdir $HSM_ARCHIVE/$tdir
1510         cp /etc/hosts $HSM_ARCHIVE/$tdir/$tfile
1511         local f=$DIR/$tdir/$tfile
1512
1513         import_file $tdir/$tfile $f
1514
1515         $LFS hsm_set --lost $f
1516
1517         md5sum $f
1518         local st=$?
1519
1520         [[ $st == 1 ]] || error "lost file access should failed (returns $st)"
1521
1522         copytool_cleanup
1523 }
1524 run_test 25a "Restore lost file (HS_LOST flag) from import"\
1525              " (Operation not permitted)"
1526
1527 test_25b() {
1528         # test needs a running copytool
1529         copytool_setup
1530
1531         mkdir -p $DIR/$tdir
1532
1533         local f=$DIR/$tdir/$tfile
1534         local fid=$(copy_file /etc/passwd $f)
1535
1536         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
1537         wait_request_state $fid ARCHIVE SUCCEED
1538
1539         $LFS hsm_release $f
1540         $LFS hsm_set --lost $f
1541         md5sum $f
1542         st=$?
1543
1544         [[ $st == 1 ]] || error "lost file access should failed (returns $st)"
1545
1546         copytool_cleanup
1547 }
1548 run_test 25b "Restore lost file (HS_LOST flag) after release"\
1549              " (Operation not permitted)"
1550
1551 test_26() {
1552         # test needs a running copytool
1553         copytool_setup
1554
1555         mkdir -p $DIR/$tdir
1556         local f=$DIR/$tdir/$tfile
1557         local fid=$(make_large_for_progress $f)
1558         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
1559         wait_request_state $fid ARCHIVE SUCCEED
1560
1561         $LFS hsm_remove $f
1562         wait_request_state $fid REMOVE SUCCEED
1563
1564         check_hsm_flags $f "0x00000000"
1565
1566         copytool_cleanup
1567 }
1568 run_test 26 "Remove the archive of a valid file"
1569
1570 test_27a() {
1571         # test needs a running copytool
1572         copytool_setup
1573
1574         mkdir -p $DIR/$tdir
1575         make_archive $tdir/$tfile
1576         local f=$DIR/$tdir/$tfile
1577         import_file $tdir/$tfile $f
1578         local fid=$(path2fid $f)
1579
1580         $LFS hsm_remove $f
1581
1582         [[ $? != 0 ]] || error "Remove of a released file should fail"
1583
1584         copytool_cleanup
1585 }
1586 run_test 27a "Remove the archive of an imported file (Operation not permitted)"
1587
1588 test_27b() {
1589         # test needs a running copytool
1590         copytool_setup
1591
1592         mkdir -p $DIR/$tdir
1593         local f=$DIR/$tdir/$tfile
1594         local fid=$(make_large_for_progress $f)
1595         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
1596         wait_request_state $fid ARCHIVE SUCCEED
1597         $LFS hsm_release $f
1598
1599         $LFS hsm_remove $f
1600
1601         [[ $? != 0 ]] || error "Remove of a released file should fail"
1602
1603         copytool_cleanup
1604 }
1605 run_test 27b "Remove the archive of a relased file (Operation not permitted)"
1606
1607 test_28() {
1608         # test needs a running copytool
1609         copytool_setup
1610
1611         mkdir -p $DIR/$tdir
1612         local f=$DIR/$tdir/$tfile
1613         local fid=$(make_large_for_progress $f)
1614         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
1615         wait_request_state $fid ARCHIVE SUCCEED
1616
1617         cdt_disable
1618         $LFS hsm_remove $f
1619
1620         rm -f $f
1621
1622         cdt_enable
1623
1624         wait_request_state $fid REMOVE SUCCEED
1625
1626         copytool_cleanup
1627 }
1628 run_test 28 "Concurrent archive/file remove"
1629
1630 test_30a() {
1631         # restore at exec cannot work on agent node (because of Linux kernel
1632         # protection of executables)
1633         needclients 2 || return 0
1634
1635         # test needs a running copytool
1636         copytool_setup
1637
1638         mkdir -p $DIR/$tdir $HSM_ARCHIVE/$tdir
1639         cp -p /bin/true $HSM_ARCHIVE/$tdir/$tfile
1640         local f=$DIR/$tdir/true
1641         import_file $tdir/$tfile $f
1642
1643         local fid=$(path2fid $f)
1644
1645         # set no retry action mode
1646         cdt_set_no_retry
1647         do_node $CLIENT2 $f
1648         local st=$?
1649
1650         # cleanup
1651         # remove no try action mode
1652         cdt_clear_no_retry
1653         $LFS hsm_state $f
1654
1655         [[ $st == 0 ]] || error "Failed to exec a released file"
1656
1657         copytool_cleanup
1658 }
1659 run_test 30a "Restore at exec (import case)"
1660
1661 test_30b() {
1662         # restore at exec cannot work on agent node (because of Linux kernel
1663         # protection of executables)
1664         needclients 2 || return 0
1665
1666         # test needs a running copytool
1667         copytool_setup
1668
1669         mkdir -p $DIR/$tdir
1670         local f=$DIR/$tdir/true
1671         local fid=$(copy_file /bin/true $f)
1672         chmod 755 $f
1673         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
1674         wait_request_state $fid ARCHIVE SUCCEED
1675         $LFS hsm_release $f
1676         $LFS hsm_state $f
1677         # set no retry action mode
1678         cdt_set_no_retry
1679         do_node $CLIENT2 $f
1680         local st=$?
1681
1682         # cleanup
1683         # remove no try action mode
1684         cdt_clear_no_retry
1685         $LFS hsm_state $f
1686
1687         [[ $st == 0 ]] || error "Failed to exec a released file"
1688
1689         copytool_cleanup
1690 }
1691 run_test 30b "Restore at exec (release case)"
1692
1693 restore_and_check_size() {
1694         local f=$1
1695         local fid=$2
1696         local s=$(stat -c "%s" $f)
1697         local n=$s
1698         local st=$(get_hsm_flags $f)
1699         local err=0
1700         local cpt=0
1701         $LFS hsm_restore $f
1702         while [[ "$st" != "0x00000009" && $cpt -le 10 ]]
1703         do
1704                 n=$(stat -c "%s" $f)
1705                 # we echo in both cases to show stat is not
1706                 # hang
1707                 if [[ $n != $s ]]
1708                 then
1709                         echo "size seen is $n != $s"
1710                         err=1
1711                 else
1712                         echo "size seen is right: $n == $s"
1713                 fi
1714                 st=$(get_hsm_flags $f)
1715                 sleep 10
1716                 cpt=$((cpt + 1))
1717         done
1718         if [[ $cpt -lt 10 ]]
1719         then
1720                 echo " restore is too long"
1721         else
1722                 echo " "done
1723         fi
1724         wait_request_state $fid RESTORE SUCCEED
1725         return $err
1726 }
1727
1728 test_31a() {
1729         # test needs a running copytool
1730         copytool_setup
1731
1732         mkdir -p $DIR/$tdir
1733
1734         make_archive $tdir/$tfile
1735         local f=$DIR/$tdir/$tfile
1736         import_file $tdir/$tfile $f
1737         local fid=$($LFS path2fid $f)
1738         HSM_ARCHIVE_PURGE=false copytool_setup
1739
1740         restore_and_check_size $f $fid
1741         local err=$?
1742
1743         [[ $err -eq 0 ]] || error "File size changed during restore"
1744
1745         copytool_cleanup
1746 }
1747 run_test 31a "Import a large file and check size during restore"
1748
1749
1750 test_31b() {
1751         # test needs a running copytool
1752         copytool_setup
1753
1754         mkdir -p $DIR/$tdir
1755
1756         local f=$DIR/$tdir/$tfile
1757         local fid=$(make_large_for_progress $f)
1758         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
1759         wait_request_state $fid ARCHIVE SUCCEED
1760         $LFS hsm_release $f
1761
1762         restore_and_check_size $f $fid
1763         local err=$?
1764
1765         [[ $err -eq 0 ]] || error "File size changed during restore"
1766
1767         copytool_cleanup
1768 }
1769 run_test 31b "Restore a large unaligned file and check size during restore"
1770
1771 test_31c() {
1772         # test needs a running copytool
1773         copytool_setup
1774
1775         mkdir -p $DIR/$tdir
1776
1777         local f=$DIR/$tdir/$tfile
1778         local fid=$(make_large_for_progress_aligned $f)
1779         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
1780         wait_request_state $fid ARCHIVE SUCCEED
1781         $LFS hsm_release $f
1782
1783         restore_and_check_size $f $fid
1784         local err=$?
1785
1786         [[ $err -eq 0 ]] || error "File size changed during restore"
1787
1788         copytool_cleanup
1789 }
1790 run_test 31c "Restore a large aligned file and check size during restore"
1791
1792 test_33() {
1793         # test needs a running copytool
1794         copytool_setup
1795
1796         mkdir -p $DIR/$tdir
1797
1798         local f=$DIR/$tdir/$tfile
1799         local fid=$(make_large_for_progress $f)
1800         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
1801         wait_request_state $fid ARCHIVE SUCCEED
1802         $LFS hsm_release $f
1803
1804         md5sum $f >/dev/null &
1805         local pid=$!
1806         wait_request_state $fid RESTORE STARTED
1807
1808         kill -15 $pid
1809         sleep 1
1810
1811         # Check restore trigger process was killed
1812         local killed=$(ps -o pid,comm hp $pid >/dev/null)
1813
1814         $LFS hsm_cancel $f
1815
1816         wait_request_state $fid RESTORE CANCELED
1817         wait_request_state $fid CANCEL SUCCEED
1818
1819         [ -z $killed ] ||
1820                 error "Cannot kill process waiting for restore ($killed)"
1821
1822         copytool_cleanup
1823 }
1824 run_test 33 "Kill a restore waiting process"
1825
1826 test_34() {
1827         # test needs a running copytool
1828         copytool_setup
1829
1830         mkdir -p $DIR/$tdir
1831
1832         local f=$DIR/$tdir/$tfile
1833         local fid=$(make_large_for_progress $f)
1834         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
1835         wait_request_state $fid ARCHIVE SUCCEED
1836         $LFS hsm_release $f
1837
1838         md5sum $f >/dev/null &
1839         local pid=$!
1840         wait_request_state $fid RESTORE STARTED
1841
1842         rm $f || error "rm $f failed"
1843         # rm must not block during restore
1844         wait_request_state $fid RESTORE STARTED
1845
1846         wait_request_state $fid RESTORE SUCCEED
1847         # check md5sum pgm finished
1848         local there=$(ps -o pid,comm hp $pid >/dev/null)
1849         [[ -z $there ]] || error "Restore initiator does not exit"
1850
1851         local rc=$(wait $pid)
1852         [[ $rc -eq 0 ]] || error "Restore initiator failed with $rc"
1853
1854         copytool_cleanup
1855 }
1856 run_test 34 "Remove file during restore"
1857
1858 test_35() {
1859         # test needs a running copytool
1860         copytool_setup
1861
1862         mkdir -p $DIR/$tdir
1863
1864         local f=$DIR/$tdir/$tfile
1865         local f1=$DIR/$tdir/$tfile-1
1866         local fid=$(make_large_for_progress $f)
1867         local fid1=$(copy_file /etc/passwd $f1)
1868         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
1869         wait_request_state $fid ARCHIVE SUCCEED
1870         $LFS hsm_release $f
1871
1872         md5sum $f >/dev/null &
1873         local pid=$!
1874         wait_request_state $fid RESTORE STARTED
1875
1876         mv $f1 $f || error "mv $f1 $f failed"
1877         # mv must not block during restore
1878         wait_request_state $fid RESTORE STARTED
1879
1880         wait_request_state $fid RESTORE SUCCEED
1881         # check md5sum pgm finished
1882         local there=$(ps -o pid,comm hp $pid >/dev/null)
1883         [[ -z $there ]] || error "Restore initiator does not exit"
1884
1885         local rc=$(wait $pid)
1886         [[ $rc -eq 0 ]] || error "Restore initiator failed with $rc"
1887
1888         fid2=$(path2fid $f)
1889         [[ $fid2 == $fid1 ]] || error "Wrong fid after mv $fid2 != $fid1"
1890
1891         copytool_cleanup
1892 }
1893 run_test 35 "Overwrite file during restore"
1894
1895 test_36() {
1896         # test needs a running copytool
1897         copytool_setup
1898
1899         mkdir -p $DIR/$tdir
1900
1901         local f=$DIR/$tdir/$tfile
1902         local fid=$(make_large_for_progress $f)
1903         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
1904         wait_request_state $fid ARCHIVE SUCCEED
1905         $LFS hsm_release $f
1906
1907         md5sum $f >/dev/null &
1908         local pid=$!
1909         wait_request_state $fid RESTORE STARTED
1910
1911         mv $f $f.new
1912         # rm must not block during restore
1913         wait_request_state $fid RESTORE STARTED
1914
1915         wait_request_state $fid RESTORE SUCCEED
1916         # check md5sum pgm finished
1917         local there=$(ps -o pid,comm hp $pid >/dev/null)
1918         [[ -z $there ]] ||
1919                 error "Restore initiator does not exit"
1920
1921         local rc=$(wait $pid)
1922         [[ $rc -eq 0 ]] ||
1923                 error "Restore initiator failed with $rc"
1924
1925         copytool_cleanup
1926 }
1927 run_test 36 "Move file during restore"
1928
1929 multi_archive() {
1930         local prefix=$1
1931         local count=$2
1932         local n=""
1933
1934         for n in $(seq 1 $count); do
1935                 $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $prefix.$n
1936         done
1937         echo "$count archive requests submitted"
1938 }
1939
1940 test_40() {
1941         local stream_count=4
1942         local file_count=100
1943         mkdir -p $DIR/$tdir
1944         local f=$DIR/$tdir/$tfile
1945         local i=""
1946         local p=""
1947         local fid=""
1948
1949         for i in $(seq 1 $file_count); do
1950                 for p in $(seq 1 $stream_count); do
1951                         fid=$(copy_file /etc/hosts $f.$p.$i)
1952                 done
1953         done
1954         copytool_setup
1955         # to be sure wait_all_done will not be mislead by previous tests
1956         cdt_purge
1957         wait_for_grace_delay
1958         typeset -a pids
1959         # start archive streams in background (archive files in parallel)
1960         for p in $(seq 1 $stream_count); do
1961                 multi_archive $f.$p $file_count &
1962                 pids[$p]=$!
1963         done
1964         echo -n  "Wait for all requests being enqueued..."
1965         wait ${pids[*]}
1966         echo OK
1967         wait_all_done 100
1968         copytool_cleanup
1969 }
1970 run_test 40 "Parallel archive requests"
1971
1972 test_52() {
1973         # test needs a running copytool
1974         copytool_setup
1975
1976         mkdir -p $DIR/$tdir
1977         local f=$DIR/$tdir/$tfile
1978         local fid=$(copy_file /etc/motd $f 1)
1979
1980         $LFS hsm_archive $f || error "could not archive file"
1981         wait_request_state $fid ARCHIVE SUCCEED
1982         check_hsm_flags $f "0x00000009"
1983
1984         multiop_bg_pause $f O_c || error "multiop failed"
1985         local MULTIPID=$!
1986
1987         mds_evict_client
1988         client_up || client_up || true
1989
1990         kill -USR1 $MULTIPID
1991         wait $MULTIPID || error "multiop close failed"
1992
1993         check_hsm_flags $f "0x0000000b"
1994
1995         copytool_cleanup
1996 }
1997 run_test 52 "Opened for write file on an evicted client should be set dirty"
1998
1999 test_53() {
2000         # test needs a running copytool
2001         copytool_setup
2002
2003         mkdir -p $DIR/$tdir
2004         local f=$DIR/$tdir/$tfile
2005         local fid=$(copy_file /etc/motd $f 1)
2006
2007         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f ||
2008                 error "could not archive file"
2009         wait_request_state $fid ARCHIVE SUCCEED
2010         check_hsm_flags $f "0x00000009"
2011
2012         multiop_bg_pause $f o_c || error "multiop failed"
2013         MULTIPID=$!
2014
2015         mds_evict_client
2016         client_up || client_up || true
2017
2018         kill -USR1 $MULTIPID
2019         wait $MULTIPID || error "multiop close failed"
2020
2021         check_hsm_flags $f "0x00000009"
2022
2023         copytool_cleanup
2024 }
2025 run_test 53 "Opened for read file on an evicted client should not be set dirty"
2026
2027 test_54() {
2028         # test needs a running copytool
2029         copytool_setup
2030
2031         mkdir -p $DIR/$tdir
2032         local f=$DIR/$tdir/$tfile
2033         local fid=$(make_small $f)
2034
2035         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f ||
2036                 error "could not archive file"
2037         wait_request_state $fid ARCHIVE STARTED
2038
2039         check_hsm_flags $f "0x00000001"
2040
2041         # Avoid coordinator resending this request as soon it has failed.
2042         cdt_set_no_retry
2043
2044         echo "foo" >> $f
2045         sync
2046         wait_request_state $fid ARCHIVE FAILED
2047
2048         check_hsm_flags $f "0x00000003"
2049
2050         cdt_clear_no_retry
2051         copytool_cleanup
2052 }
2053 run_test 54 "Write during an archive cancels it"
2054
2055 test_55() {
2056         # test needs a running copytool
2057         copytool_setup
2058
2059         mkdir -p $DIR/$tdir
2060         local f=$DIR/$tdir/$tfile
2061         local fid=$(make_small $f)
2062
2063         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f ||
2064                 error "could not archive file"
2065         wait_request_state $fid ARCHIVE STARTED
2066
2067         check_hsm_flags $f "0x00000001"
2068
2069         # Avoid coordinator resending this request as soon it has failed.
2070         cdt_set_no_retry
2071
2072         $TRUNCATE $f 1024 || error "truncate failed"
2073         sync
2074         wait_request_state $fid ARCHIVE FAILED
2075
2076         check_hsm_flags $f "0x00000003"
2077
2078         cdt_clear_no_retry
2079         copytool_cleanup
2080 }
2081 run_test 55 "Truncate during an archive cancels it"
2082
2083 test_56() {
2084         # test needs a running copytool
2085         copytool_setup
2086
2087         mkdir -p $DIR/$tdir
2088         local f=$DIR/$tdir/$tfile
2089         local fid=$(make_large_for_progress $f)
2090
2091         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f ||
2092                 error "could not archive file"
2093         wait_request_state $fid ARCHIVE STARTED
2094
2095         check_hsm_flags $f "0x00000001"
2096
2097         # Change metadata and sync to be sure we are not changing only
2098         # in memory.
2099         chmod 644 $f
2100         chgrp sys $f
2101         sync
2102         wait_request_state $fid ARCHIVE SUCCEED
2103
2104         check_hsm_flags $f "0x00000009"
2105
2106         copytool_cleanup
2107 }
2108 run_test 56 "Setattr during an archive is ok"
2109
2110 test_57() {
2111         # Need one client for I/O, one for request
2112         needclients 2 || return 0
2113
2114         # test needs a running copytool
2115         copytool_setup
2116
2117         mkdir -p $DIR/$tdir
2118         local f=$DIR/$tdir/test_archive_remote
2119         # Create a file on a remote node
2120         do_node $CLIENT2 "dd if=/dev/urandom of=$f bs=1M "\
2121                 "count=2 conv=fsync"
2122
2123         # And archive it
2124         do_node $CLIENT2 "$LFS hsm_archive -a $HSM_ARCHIVE_NUMBER $f" ||
2125                 error "hsm_archive failed"
2126         local fid=$(path2fid $f)
2127         wait_request_state $fid ARCHIVE SUCCEED
2128
2129         # Release and implicit restore it
2130         do_node $CLIENT2 "$LFS hsm_release $f" ||
2131                 error "hsm_release failed"
2132         do_node $CLIENT2 "md5sum $f" ||
2133                 error "hsm_restore failed"
2134
2135         wait_request_state $fid RESTORE SUCCEED
2136
2137         copytool_cleanup
2138 }
2139 run_test 57 "Archive a file with dirty cache on another node"
2140
2141 truncate_released_file() {
2142         local src_file=$1
2143         local trunc_to=$2
2144
2145         local sz=$(stat -c %s $src_file)
2146         local f=$DIR/$tdir/$tfile
2147         local fid=$(copy_file $1 $f)
2148         local ref=$f-ref
2149         cp $f $f-ref
2150
2151         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f ||
2152                 error "could not archive file"
2153         wait_request_state $fid ARCHIVE SUCCEED
2154
2155         $LFS hsm_release $f || error "could not release file"
2156
2157         $TRUNCATE $f $trunc_to || error "truncate failed"
2158         sync
2159
2160         local sz1=$(stat -c %s $f)
2161         [[ $sz1 == $trunc_to ]] ||
2162                 error "size after trunc: $sz1 expect $trunc_to, original $sz"
2163
2164         $LFS hsm_state $f
2165         check_hsm_flags $f "0x0000000b"
2166
2167         local state=$(get_request_state $fid RESTORE)
2168         [[ "$state" == "SUCCEED" ]] ||
2169                 error "truncate $sz does not trig restore, state = $state"
2170
2171         $TRUNCATE $ref $trunc_to
2172         cmp $ref $f || error "file data wrong after truncate"
2173
2174         rm -f $f $f-ref
2175 }
2176
2177 test_58() {
2178         # test needs a running copytool
2179         copytool_setup
2180
2181         mkdir -p $DIR/$tdir
2182
2183         local sz=$(stat -c %s /etc/passwd)
2184
2185         echo "truncate up from $sz to $((sz*2))"
2186         truncate_released_file /etc/passwd $((sz*2))
2187
2188         echo "truncate down from $sz to $((sz/2))"
2189         truncate_released_file /etc/passwd $((sz/2))
2190
2191         echo "truncate to 0"
2192         truncate_released_file /etc/passwd 0
2193
2194         copytool_cleanup
2195 }
2196 run_test 58 "Truncate a released file will trigger restore"
2197
2198 test_90() {
2199         file_count=57
2200         mkdir -p $DIR/$tdir
2201         local f=$DIR/$tdir/$tfile
2202         local FILELIST=/tmp/filelist.txt
2203         local i=""
2204
2205         rm -f $FILELIST
2206         for i in $(seq 1 $file_count); do
2207                 fid=$(copy_file /etc/hosts $f.$i)
2208                 echo $f.$i >> $FILELIST
2209         done
2210         copytool_setup
2211         # to be sure wait_all_done will not be mislead by previous tests
2212         cdt_purge
2213         wait_for_grace_delay
2214         $LFS hsm_archive --filelist $FILELIST ||
2215                 error "cannot archive a file list"
2216         wait_all_done 100
2217         $LFS hsm_release --filelist $FILELIST ||
2218                 error "cannot release a file list"
2219         $LFS hsm_restore --filelist $FILELIST ||
2220                 error "cannot restore a file list"
2221         wait_all_done 100
2222         copytool_cleanup
2223 }
2224 run_test 90 "Archive/restore a file list"
2225
2226 double_verify_reset_hsm_param() {
2227         local p=$1
2228         echo "Testing $HSM_PARAM.$p"
2229         local val=$(get_hsm_param $p)
2230         local save=$val
2231         local val2=$(($val * 2))
2232         set_hsm_param $p $val2
2233         val=$(get_hsm_param $p)
2234         [[ $val == $val2 ]] ||
2235                 error "$HSM_PARAM.$p: $val != $val2 should be (2 * $save)"
2236         echo "Set $p to 0 must failed"
2237         set_hsm_param $p 0
2238         local rc=$?
2239         # restore value
2240         set_hsm_param $p $save
2241
2242         if [[ $rc == 0 ]]
2243         then
2244                 error "we must not be able to set $HSM_PARAM.$p to 0"
2245         fi
2246 }
2247
2248 test_100() {
2249         double_verify_reset_hsm_param loop_period
2250         double_verify_reset_hsm_param grace_delay
2251         double_verify_reset_hsm_param request_timeout
2252         double_verify_reset_hsm_param max_requests
2253         double_verify_reset_hsm_param archive_id
2254 }
2255 run_test 100 "Set coordinator /proc tunables"
2256
2257 test_102() {
2258         cdt_disable
2259         cdt_enable
2260         cdt_restart
2261 }
2262 run_test 102 "Verify coordinator control"
2263
2264 test_103() {
2265         # test needs a running copytool
2266         copytool_setup
2267
2268         local i=""
2269         local fid=""
2270
2271         mkdir -p $DIR/$tdir
2272         for i in $(seq 1 20); do
2273                 fid=$(copy_file /etc/passwd $DIR/$tdir/$i)
2274         done
2275         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $DIR/$tdir/*
2276
2277         cdt_purge
2278
2279         echo "Current requests"
2280         local res=$(do_facet $SINGLEMDS "$LCTL get_param -n\
2281                         $HSM_PARAM.agent_actions |\
2282                         grep -v CANCELED | grep -v SUCCEED | grep -v FAILED")
2283
2284         [[ -z "$res" ]] || error "Some request have not been canceled"
2285
2286         copytool_cleanup
2287 }
2288 run_test 103 "Purge all requests"
2289
2290 DATA=CEA
2291 DATAHEX='[434541]'
2292 test_104() {
2293         # test needs a running copytool
2294         copytool_setup
2295
2296         mkdir -p $DIR/$tdir
2297         local f=$DIR/$tdir/$tfile
2298         local fid=$(make_large_for_progress $f)
2299         # if cdt is on, it can serve too quickly the request
2300         cdt_disable
2301         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER --data $DATA $f
2302         local data1=$(do_facet $SINGLEMDS "$LCTL get_param -n\
2303                         $HSM_PARAM.agent_actions |\
2304                         grep $fid | cut -f16 -d=")
2305         cdt_enable
2306
2307         [[ "$data1" == "$DATAHEX" ]] ||
2308                 error "Data field in records is ($data1) and not ($DATAHEX)"
2309
2310         copytool_cleanup
2311 }
2312 run_test 104 "Copy tool data field"
2313
2314 test_105() {
2315         mkdir -p $DIR/$tdir
2316         local i=""
2317
2318         cdt_disable
2319         for i in $(seq -w 1 10); do
2320                 cp /etc/passwd $DIR/$tdir/$i
2321                 $LFS hsm_archive $DIR/$tdir/$i
2322         done
2323         local reqcnt1=$(do_facet $SINGLEMDS "$LCTL get_param -n\
2324                         $HSM_PARAM.agent_actions |\
2325                         grep WAITING | wc -l")
2326         cdt_restart
2327         cdt_disable
2328         local reqcnt2=$(do_facet $SINGLEMDS "$LCTL get_param -n\
2329                         $HSM_PARAM.agent_actions |\
2330                         grep WAITING | wc -l")
2331         cdt_enable
2332         cdt_purge
2333         [[ "$reqcnt1" == "$reqcnt2" ]] ||
2334                 error "Requests count after shutdown $reqcnt2 != "\
2335                       "before shutdown $reqcnt1"
2336 }
2337 run_test 105 "Restart of coordinator"
2338
2339 test_106() {
2340         # test needs a running copytool
2341         copytool_setup
2342
2343         local uuid=$(do_rpc_nodes $(facet_active_host $SINGLEAGT) \
2344                 get_client_uuid | cut -d' ' -f2)
2345         local agent=$(do_facet $SINGLEMDS $LCTL get_param -n $HSM_PARAM.agents |
2346                 grep $uuid)
2347         copytool_cleanup
2348         [[ ! -z "$agent" ]] || error "My uuid $uuid not found in agent list"
2349         local agent=$(do_facet $SINGLEMDS $LCTL get_param -n $HSM_PARAM.agents |
2350                 grep $uuid)
2351         [[ -z "$agent" ]] ||
2352                 error "My uuid $uuid still found in agent list,"\
2353                       " after copytool shutdown"
2354         copytool_setup
2355         local agent=$(do_facet $SINGLEMDS $LCTL get_param -n $HSM_PARAM.agents |
2356                 grep $uuid)
2357         copytool_cleanup
2358         [[ ! -z "$agent" ]] ||
2359                 error "My uuid $uuid not found in agent list after"\
2360                       " copytool restart"
2361 }
2362 run_test 106 "Copytool register/unregister"
2363
2364 test_107() {
2365         # test needs a running copytool
2366         copytool_setup
2367         # create and archive file
2368         mkdir -p $DIR/$tdir
2369         local f1=$DIR/$tdir/$tfile
2370         local fid=$(copy_file /etc/passwd $f1)
2371         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f1
2372         wait_request_state $fid ARCHIVE SUCCEED
2373         # shutdown and restart MDS
2374         fail $SINGLEMDS
2375         # check the copytool still gets messages from MDT
2376         local f2=$DIR/$tdir/2
2377         local fid=$(copy_file /etc/passwd $f2)
2378         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f2
2379         # main check of this sanity: this request MUST succeed
2380         wait_request_state $fid ARCHIVE SUCCEED
2381         copytool_cleanup
2382 }
2383 run_test 107 "Copytool re-register after MDS restart"
2384
2385 policy_set_and_test()
2386 {
2387         local change="$1"
2388         local target="$2"
2389         do_facet $SINGLEMDS $LCTL set_param "$HSM_PARAM.policy=\\\"$change\\\""
2390         local policy=$(do_facet $SINGLEMDS $LCTL get_param -n $HSM_PARAM.policy)
2391         [[ "$policy" == "$target" ]] ||
2392                 error "Wrong policy after '$change': '$policy' != '$target'"
2393 }
2394
2395 test_109() {
2396         # to force default policy setting if error
2397         CDT_POLICY_HAD_CHANGED=true
2398
2399         local policy=$(do_facet $SINGLEMDS $LCTL get_param -n $HSM_PARAM.policy)
2400         local default="NonBlockingRestore [NoRetryAction]"
2401         [[ "$policy" == "$default" ]] ||
2402                 error "default policy has changed,"\
2403                       " '$policy' != '$default' update the test"
2404         policy_set_and_test "+NBR" "[NonBlockingRestore] [NoRetryAction]"
2405         policy_set_and_test "+NRA" "[NonBlockingRestore] [NoRetryAction]"
2406         policy_set_and_test "-NBR" "NonBlockingRestore [NoRetryAction]"
2407         policy_set_and_test "-NRA" "NonBlockingRestore NoRetryAction"
2408         policy_set_and_test "NRA NBR" "[NonBlockingRestore] [NoRetryAction]"
2409         # useless bacause we know but safer for futur changes to use real value
2410         local policy=$(do_facet $SINGLEMDS $LCTL get_param -n $HSM_PARAM.policy)
2411         echo "Next set_param must failed"
2412         policy_set_and_test "wrong" "$policy"
2413
2414         # return to default
2415         echo "Back to default policy"
2416         cdt_set_sanity_policy
2417 }
2418 run_test 109 "Policy display/change"
2419
2420 test_110a() {
2421         # test needs a running copytool
2422         copytool_setup
2423
2424         mkdir -p $DIR/$tdir $HSM_ARCHIVE/$tdir
2425         cp /etc/passwd $HSM_ARCHIVE/$tdir/$tfile
2426         local f=$DIR/$tdir/$tfile
2427         import_file $tdir/$tfile $f
2428         local fid=$(path2fid $f)
2429
2430         cdt_set_non_blocking_restore
2431         md5sum $f
2432         local st=$?
2433
2434         # cleanup
2435         wait_request_state $fid RESTORE SUCCEED
2436         cdt_clear_non_blocking_restore
2437
2438         # Test result
2439         [[ $st == 1 ]] ||
2440                 error "md5sum returns $st != 1, "\
2441                         "should also perror ENODATA (No data available)"
2442
2443         copytool_cleanup
2444 }
2445 run_test 110a "Non blocking restore policy (import case)"
2446
2447 test_110b() {
2448         # test needs a running copytool
2449         copytool_setup
2450
2451         mkdir -p $DIR/$tdir
2452         local f=$DIR/$tdir/$tfile
2453         local fid=$(copy_file /etc/passwd $f)
2454         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
2455         wait_request_state $fid ARCHIVE SUCCEED
2456         $LFS hsm_release $f
2457
2458         cdt_set_non_blocking_restore
2459         md5sum $f
2460         local st=$?
2461
2462         # cleanup
2463         wait_request_state $fid RESTORE SUCCEED
2464         cdt_clear_non_blocking_restore
2465
2466         # Test result
2467         [[ $st == 1 ]] ||
2468                 error "md5sum returns $st != 1, "\
2469                         "should also perror ENODATA (No data available)"
2470
2471         copytool_cleanup
2472 }
2473 run_test 110b "Non blocking restore policy (release case)"
2474
2475 test_111a() {
2476         # test needs a running copytool
2477         copytool_setup
2478
2479         mkdir -p $DIR/$tdir $HSM_ARCHIVE/$tdir
2480         local f=$DIR/$tdir/$tfile
2481         cp /etc/passwd $HSM_ARCHIVE/$tdir/$tfile
2482         import_file $tdir/$tfile $f
2483         local fid=$(path2fid $f)
2484
2485         cdt_set_no_retry
2486
2487         copytool_remove_backend $fid
2488
2489         $LFS hsm_restore $f
2490         wait_request_state $fid RESTORE FAILED
2491         local st=$?
2492
2493         # cleanup
2494         cdt_clear_no_retry
2495
2496         # Test result
2497         [[ $st == 0 ]] || error "Restore does not failed"
2498
2499         copytool_cleanup
2500 }
2501 run_test 111a "No retry policy (import case), restore will error"\
2502               " (No such file or directory)"
2503
2504 test_111b() {
2505         # test needs a running copytool
2506         copytool_setup
2507
2508         mkdir -p $DIR/$tdir
2509         local f=$DIR/$tdir/$tfile
2510         local fid=$(copy_file /etc/passwd $f)
2511         cdt_set_no_retry
2512         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
2513         wait_request_state $fid ARCHIVE SUCCEED
2514         $LFS hsm_release $f
2515
2516         copytool_remove_backend $fid
2517
2518         $LFS hsm_restore $f
2519         wait_request_state $fid RESTORE FAILED
2520         local st=$?
2521
2522         # cleanup
2523         cdt_clear_no_retry
2524
2525         # Test result
2526         [[ $st == 0 ]] || error "Restore does not failed"
2527
2528         copytool_cleanup
2529 }
2530 run_test 111b "No retry policy (release case), restore will error"\
2531               " (No such file or directory)"
2532
2533 test_112() {
2534         # test needs a running copytool
2535         copytool_setup
2536
2537         mkdir -p $DIR/$tdir
2538         local f=$DIR/$tdir/$tfile
2539         local fid=$(copy_file /etc/passwd $f)
2540         cdt_disable
2541         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
2542         local l=$($LFS hsm_action $f)
2543         echo $l
2544         local res=$(echo $l | cut -f 2- -d" " | grep ARCHIVE)
2545
2546         # cleanup
2547         cdt_enable
2548         wait_request_state $fid ARCHIVE SUCCEED
2549
2550         # Test result
2551         [[ ! -z "$res" ]] || error "action is $l which is not an ARCHIVE"
2552
2553         copytool_cleanup
2554 }
2555 run_test 112 "State of recorded request"
2556
2557 test_200() {
2558         # test needs a running copytool
2559         copytool_setup
2560
2561         mkdir -p $DIR/$tdir
2562         local f=$DIR/$tdir/$tfile
2563         local fid=$(make_large_for_cancel $f)
2564         # test with cdt on is made in test_221
2565         cdt_disable
2566         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
2567         $LFS hsm_cancel $f
2568         cdt_enable
2569         wait_request_state $fid ARCHIVE CANCELED
2570         wait_request_state $fid CANCEL SUCCEED
2571
2572         copytool_cleanup
2573 }
2574 run_test 200 "Register/Cancel archive"
2575
2576 test_201() {
2577         # test needs a running copytool
2578         copytool_setup
2579
2580         mkdir -p $DIR/$tdir
2581         local f=$DIR/$tdir/$tfile
2582         make_archive $tdir/$tfile
2583         import_file $tdir/$tfile $f
2584         local fid=$(path2fid $f)
2585
2586         # test with cdt on is made in test_222
2587         cdt_disable
2588         $LFS hsm_restore $f
2589         $LFS hsm_cancel $f
2590         cdt_enable
2591         wait_request_state $fid RESTORE CANCELED
2592         wait_request_state $fid CANCEL SUCCEED
2593
2594         copytool_cleanup
2595 }
2596 run_test 201 "Register/Cancel restore"
2597
2598 test_202() {
2599         # test needs a running copytool
2600         copytool_setup
2601
2602         mkdir -p $DIR/$tdir
2603         local f=$DIR/$tdir/$tfile
2604         local fid=$(make_large_for_progress $f)
2605         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
2606         wait_request_state $fid ARCHIVE SUCCEED
2607
2608         cdt_disable
2609         $LFS hsm_remove $f
2610         $LFS hsm_cancel $f
2611         cdt_enable
2612         wait_request_state $fid REMOVE CANCELED
2613
2614         copytool_cleanup
2615 }
2616 run_test 202 "Register/Cancel remove"
2617
2618 test_220() {
2619         # test needs a running copytool
2620         copytool_setup
2621
2622         mkdir -p $DIR/$tdir
2623
2624         local f=$DIR/$tdir/$tfile
2625         local fid=$(copy_file /etc/passwd $f)
2626
2627         changelog_setup
2628
2629         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
2630         wait_request_state $fid ARCHIVE SUCCEED
2631
2632         local flags=$(changelog_get_flags $MDT0 HSM $fid | tail -1)
2633         changelog_cleanup
2634
2635         local target=0x0
2636         [[ $flags == $target ]] || error "Changelog flag is $flags not $target"
2637
2638         copytool_cleanup
2639 }
2640 run_test 220 "Changelog for archive"
2641
2642 test_221() {
2643         # test needs a running copytool
2644         copytool_setup
2645
2646         mkdir -p $DIR/$tdir
2647
2648         local f=$DIR/$tdir/$tfile
2649         local fid=$(make_large_for_cancel $f)
2650
2651         changelog_setup
2652
2653         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
2654         wait_request_state $fid ARCHIVE STARTED
2655         $LFS hsm_cancel $f
2656         wait_request_state $fid ARCHIVE CANCELED
2657         wait_request_state $fid CANCEL SUCCEED
2658
2659         local flags=$(changelog_get_flags $MDT0 HSM $fid | tail -1)
2660
2661         local target=0x7d
2662         [[ $flags == $target ]] || error "Changelog flag is $flags not $target"
2663
2664         cleanup
2665 }
2666 run_test 221 "Changelog for archive canceled"
2667
2668 test_222a() {
2669         # test needs a running copytool
2670         copytool_setup
2671
2672         mkdir -p $DIR/$tdir $HSM_ARCHIVE/$tdir
2673         local f=$DIR/$tdir/$tfile
2674         cp /etc/passwd $HSM_ARCHIVE/$tdir/$tfile
2675         import_file $tdir/$tfile $f
2676         local fid=$(path2fid $f)
2677
2678         changelog_setup
2679
2680         $LFS hsm_restore $f
2681         wait_request_state $fid RESTORE SUCCEED
2682
2683         local flags=$(changelog_get_flags $MDT0 HSM $fid | tail -1)
2684
2685         local target=0x80
2686         [[ $flags == $target ]] || error "Changelog flag is $flags not $target"
2687
2688         cleanup
2689 }
2690 run_test 222a "Changelog for explicit restore"
2691
2692 test_222b() {
2693         # test needs a running copytool
2694         copytool_setup
2695
2696         mkdir -p $DIR/$tdir
2697         local f=$DIR/$tdir/$tfile
2698         local fid=$(copy_file /etc/passwd $f)
2699
2700         changelog_setup
2701         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
2702         wait_request_state $fid ARCHIVE SUCCEED
2703         $LFS hsm_release $f
2704
2705         md5sum $f
2706
2707         wait_request_state $fid RESTORE SUCCEED
2708
2709         local flags=$(changelog_get_flags $MDT0 HSM $fid | tail -1)
2710
2711         local target=0x80
2712         [[ $flags == $target ]] || error "Changelog flag is $flags not $target"
2713
2714         cleanup
2715 }
2716 run_test 222b "Changelog for implicit restore"
2717
2718 test_223a() {
2719         # test needs a running copytool
2720         copytool_setup
2721
2722         mkdir -p $DIR/$tdir
2723
2724         local f=$DIR/$tdir/$tfile
2725         make_archive $tdir/$tfile
2726
2727         changelog_setup
2728
2729         import_file $tdir/$tfile $f
2730         local fid=$(path2fid $f)
2731
2732         $LFS hsm_restore $f
2733         wait_request_state $fid RESTORE STARTED
2734         $LFS hsm_cancel $f
2735         wait_request_state $fid RESTORE CANCELED
2736         wait_request_state $fid CANCEL SUCCEED
2737
2738         local flags=$(changelog_get_flags $MDT0 HSM $fid | tail -1)
2739
2740         local target=0xfd
2741         [[ $flags == $target ]] ||
2742                 error "Changelog flag is $flags not $target"
2743
2744         cleanup
2745 }
2746 run_test 223a "Changelog for restore canceled (import case)"
2747
2748 test_223b() {
2749         # test needs a running copytool
2750         copytool_setup
2751
2752         mkdir -p $DIR/$tdir
2753
2754         local f=$DIR/$tdir/$tfile
2755         local fid=$(make_large_for_progress $f)
2756
2757         changelog_setup
2758         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
2759         wait_request_state $fid ARCHIVE SUCCEED
2760         $LFS hsm_release $f
2761         $LFS hsm_restore $f
2762         wait_request_state $fid RESTORE STARTED
2763         $LFS hsm_cancel $f
2764         wait_request_state $fid RESTORE CANCELED
2765         wait_request_state $fid CANCEL SUCCEED
2766
2767         local flags=$(changelog_get_flags $MDT0 HSM $fid | tail -1)
2768
2769         local target=0xfd
2770         [[ $flags == $target ]] ||
2771                 error "Changelog flag is $flags not $target"
2772
2773         cleanup
2774 }
2775 run_test 223b "Changelog for restore canceled (release case)"
2776
2777 test_224() {
2778         # test needs a running copytool
2779         copytool_setup
2780
2781         mkdir -p $DIR/$tdir
2782
2783         local f=$DIR/$tdir/$tfile
2784         local fid=$(copy_file /etc/passwd $f)
2785
2786         changelog_setup
2787         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
2788         wait_request_state $fid ARCHIVE SUCCEED
2789
2790         $LFS hsm_remove $f
2791         wait_request_state $fid REMOVE SUCCEED
2792
2793         local flags=$(changelog_get_flags $MDT0 HSM $fid | tail -1)
2794
2795         local target=0x200
2796         [[ $flags == $target ]] ||
2797                 error "Changelog flag is $flags not $target"
2798
2799         cleanup
2800 }
2801 run_test 224 "Changelog for remove"
2802
2803 test_225() {
2804         # test needs a running copytool
2805         copytool_setup
2806
2807         # test is not usable because remove request is too fast
2808         # so it is always finished before cancel can be done ...
2809         echo "Test disabled"
2810         copytool_cleanup
2811         return 0
2812
2813         mkdir -p $DIR/$tdir
2814         local f=$DIR/$tdir/$tfile
2815         local fid=$(make_large_for_progress $f)
2816
2817         changelog_setup
2818         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
2819         wait_request_state $fid ARCHIVE SUCCEED
2820
2821         # if cdt is on, it can serve too quickly the request
2822         cdt_disable
2823         $LFS hsm_remove $f
2824         $LFS hsm_cancel $f
2825         cdt_enable
2826         wait_request_state $fid REMOVE CANCELED
2827         wait_request_state $fid CANCEL SUCCEED
2828
2829         flags=$(changelog_get_flags $MDT0 RENME $fid2)
2830         local flags=$($LFS changelog $MDT0 | grep HSM | grep $fid | tail -1 |
2831                 awk '{print $5}')
2832
2833         local target=0x27d
2834         [[ $flags == $target ]] ||
2835                 error "Changelog flag is $flags not $target"
2836
2837         cleanup
2838 }
2839 run_test 225 "Changelog for remove canceled"
2840
2841 test_226() {
2842         # test needs a running copytool
2843         copytool_setup
2844
2845         mkdir -p $DIR/$tdir
2846
2847         local f1=$DIR/$tdir/$tfile-1
2848         local f2=$DIR/$tdir/$tfile-2
2849         local f3=$DIR/$tdir/$tfile-3
2850         local fid1=$(copy_file /etc/passwd $f1)
2851         local fid2=$(copy_file /etc/passwd $f2)
2852         copy_file /etc/passwd $f3
2853
2854         changelog_setup
2855         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f1
2856         wait_request_state $fid1 ARCHIVE SUCCEED
2857
2858         $LFS hsm_archive $f2
2859         wait_request_state $fid2 ARCHIVE SUCCEED
2860
2861         rm $f1 || error "rm $f1 failed"
2862
2863         local flags=$(changelog_get_flags $MDT0 UNLNK $fid1)
2864
2865         local target=0x3
2866         [[ $flags == $target ]] ||
2867                 error "Changelog flag is $flags not $target"
2868
2869         mv $f3 $f2 || error "mv $f3 $f2 failed"
2870
2871         flags=$(changelog_get_flags $MDT0 RENME $fid2)
2872
2873         target=0x3
2874         [[ $flags == $target ]] ||
2875                 error "Changelog flag is $flags not $target"
2876
2877         cleanup
2878 }
2879 run_test 226 "changelog for last rm/mv with exiting archive"
2880
2881 check_flags_changes() {
2882         local f=$1
2883         local fid=$2
2884         local hsm_flag=$3
2885         local fst=$4
2886         local cnt=$5
2887
2888         local target=0x280
2889         $LFS hsm_set --$hsm_flag $f ||
2890                 error "Cannot set $hsm_flag on $f"
2891         local flags=($(changelog_get_flags $MDT0 HSM $fid))
2892         local seen=${#flags[*]}
2893         cnt=$((fst + cnt))
2894         [[ $seen == $cnt ]] ||
2895                 error "set $hsm_flag: Changelog events $seen != $cnt"
2896         [[ ${flags[$((cnt - 1))]} == $target ]] ||
2897                 error "set $hsm_flag: Changelog flags are "\
2898                         "${flags[$((cnt - 1))]} not $target"
2899
2900         $LFS hsm_clear --$hsm_flag $f ||
2901                 error "Cannot clear $hsm_flag on $f"
2902         flags=($(changelog_get_flags $MDT0 HSM $fid))
2903         seen=${#flags[*]}
2904         cnt=$(($cnt + 1))
2905         [[ $cnt == $seen ]] ||
2906                 error "clear $hsm_flag: Changelog events $seen != $cnt"
2907
2908         [[ ${flags[$((cnt - 1))]} == $target ]] ||
2909                 error "clear $hsm_flag: Changelog flag is "\
2910                         "${flags[$((cnt - 1))]} not $target"
2911 }
2912
2913 test_227() {
2914         # test needs a running copytool
2915         copytool_setup
2916         changelog_setup
2917
2918         mkdir -p $DIR/$tdir
2919         typeset -a flags
2920
2921         for i in norelease noarchive exists archived
2922         do
2923                 local f=$DIR/$tdir/$tfile-$i
2924                 local fid=$(copy_file /etc/passwd $f)
2925                 check_flags_changes $f $fid $i 0 1
2926         done
2927
2928         f=$DIR/$tdir/$tfile---lost
2929         fid=$(copy_file /etc/passwd $f)
2930         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
2931         wait_request_state $fid ARCHIVE SUCCEED
2932         check_flags_changes $f $fid lost 3 1
2933
2934         cleanup
2935 }
2936 run_test 227 "changelog when explicit setting of HSM flags"
2937
2938 test_250() {
2939         # test needs a running copytool
2940         copytool_setup
2941
2942         mkdir -p $DIR/$tdir
2943         local maxrequest=$(get_hsm_param max_requests)
2944         local rqcnt=$(($maxrequest * 3))
2945         local i=""
2946
2947         cdt_disable
2948         for i in $(seq -w 1 $rqcnt); do
2949                 rm -f $DIR/$tdir/$i
2950                 dd if=/dev/urandom of=$DIR/$tdir/$i bs=1M count=10 conv=fsync
2951         done
2952         # we do it in 2 steps, so all requests arrive at the same time
2953         for i in $(seq -w 1 $rqcnt); do
2954                 $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $DIR/$tdir/$i
2955         done
2956         cdt_enable
2957         local cnt=$rqcnt
2958         local wt=$rqcnt
2959         while [[ $cnt != 0 || $wt != 0 ]]; do
2960                 sleep 1
2961                 cnt=$(do_facet $SINGLEMDS "$LCTL get_param -n\
2962                         $HSM_PARAM.agent_actions |\
2963                         grep STARTED | grep -v CANCEL | wc -l")
2964                 [[ $cnt -le $maxrequest ]] ||
2965                         error "$cnt > $maxrequest too many started requests"
2966                 wt=$(do_facet $SINGLEMDS "$LCTL get_param\
2967                         $HSM_PARAM.agent_actions |\
2968                         grep WAITING | wc -l")
2969                 echo "max=$maxrequest started=$cnt waiting=$wt"
2970         done
2971
2972         copytool_cleanup
2973 }
2974 run_test 250 "Coordinator max request"
2975
2976 test_251() {
2977         # test needs a running copytool
2978         copytool_setup
2979
2980         mkdir -p $DIR/$tdir
2981         local f=$DIR/$tdir/$tfile
2982         local fid=$(make_large_for_cancel $f)
2983
2984         cdt_disable
2985         # to have a short test
2986         local old_to=$(get_hsm_param request_timeout)
2987         set_hsm_param request_timeout 4
2988         # to be sure the cdt will wake up frequently so
2989         # it will be able to cancel the "old" request
2990         local old_loop=$(get_hsm_param loop_period)
2991         set_hsm_param loop_period 2
2992         cdt_enable
2993
2994         $LFS hsm_archive --archive $HSM_ARCHIVE_NUMBER $f
2995         wait_request_state $fid ARCHIVE STARTED
2996         sleep 5
2997         wait_request_state $fid ARCHIVE CANCELED
2998
2999         set_hsm_param request_timeout $old_to
3000         set_hsm_param loop_period $old_loop
3001
3002         copytool_cleanup
3003 }
3004 run_test 251 "Coordinator request timeout"
3005
3006 test_300() {
3007         # the only way to test ondisk conf is to restart MDS ...
3008         echo "Stop coordinator and remove coordinator state at mount"
3009         # stop coordinator
3010         cdt_shutdown
3011         # clean on disk conf set by default
3012         cdt_clear_mount_state
3013         cdt_check_state stopped
3014
3015         # check cdt still off after umount/remount
3016         fail $SINGLEMDS
3017         cdt_check_state stopped
3018
3019         echo "Set coordinator start at mount, and start coordinator"
3020         cdt_set_mount_state enabled
3021
3022         # check cdt is on
3023         cdt_check_state enabled
3024
3025         # check cdt still on after umount/remount
3026         fail $SINGLEMDS
3027         cdt_check_state enabled
3028
3029         # we are back to original state (cdt started at mount)
3030 }
3031 run_test 300 "On disk coordinator state kept between MDT umount/mount"
3032
3033 copytool_cleanup
3034
3035 complete $SECONDS
3036 check_and_cleanup_lustre
3037 exit_status