~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/tests/shell/daemon.sh

Version: ~ [ linux-6.12-rc7 ] ~ [ linux-6.11.7 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.60 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.116 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.171 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.229 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.285 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.323 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.12 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /tools/perf/tests/shell/daemon.sh (Version linux-6.12-rc7) and /tools/perf/tests/shell/daemon.sh (Version linux-4.11.12)


  1 #!/bin/bash                                       
  2 # daemon operations                               
  3 # SPDX-License-Identifier: GPL-2.0                
  4                                                   
  5 check_line_first()                                
  6 {                                                 
  7         local line=$1                             
  8         local name=$2                             
  9         local base=$3                             
 10         local output=$4                           
 11         local lock=$5                             
 12         local up=$6                               
 13                                                   
 14         local line_name                           
 15         line_name=`echo "${line}" | awk 'BEGIN    
 16         local line_base                           
 17         line_base=`echo "${line}" | awk 'BEGIN    
 18         local line_output                         
 19         line_output=`echo "${line}" | awk 'BEG    
 20         local line_lock                           
 21         line_lock=`echo "${line}" | awk 'BEGIN    
 22         local line_up                             
 23         line_up=`echo "${line}" | awk 'BEGIN {    
 24                                                   
 25         if [ "${name}" != "${line_name}" ]; th    
 26                 echo "FAILED: wrong name"         
 27                 error=1                           
 28         fi                                        
 29                                                   
 30         if [ "${base}" != "${line_base}" ]; th    
 31                 echo "FAILED: wrong base"         
 32                 error=1                           
 33         fi                                        
 34                                                   
 35         if [ "${output}" != "${line_output}" ]    
 36                 echo "FAILED: wrong output"       
 37                 error=1                           
 38         fi                                        
 39                                                   
 40         if [ "${lock}" != "${line_lock}" ]; th    
 41                 echo "FAILED: wrong lock"         
 42                 error=1                           
 43         fi                                        
 44                                                   
 45         if [ "${up}" != "${line_up}" ]; then      
 46                 echo "FAILED: wrong up"           
 47                 error=1                           
 48         fi                                        
 49 }                                                 
 50                                                   
 51 check_line_other()                                
 52 {                                                 
 53         local line=$1                             
 54         local name=$2                             
 55         local run=$3                              
 56         local base=$4                             
 57         local output=$5                           
 58         local control=$6                          
 59         local ack=$7                              
 60         local up=$8                               
 61                                                   
 62         local line_name                           
 63         line_name=`echo "${line}" | awk 'BEGIN    
 64         local line_run                            
 65         line_run=`echo "${line}" | awk 'BEGIN     
 66         local line_base                           
 67         line_base=`echo "${line}" | awk 'BEGIN    
 68         local line_output                         
 69         line_output=`echo "${line}" | awk 'BEG    
 70         local line_control                        
 71         line_control=`echo "${line}" | awk 'BE    
 72         local line_ack                            
 73         line_ack=`echo "${line}" | awk 'BEGIN     
 74         local line_up                             
 75         line_up=`echo "${line}" | awk 'BEGIN {    
 76                                                   
 77         if [ "${name}" != "${line_name}" ]; th    
 78                 echo "FAILED: wrong name"         
 79                 error=1                           
 80         fi                                        
 81                                                   
 82         if [ "${run}" != "${line_run}" ]; then    
 83                 echo "FAILED: wrong run"          
 84                 error=1                           
 85         fi                                        
 86                                                   
 87         if [ "${base}" != "${line_base}" ]; th    
 88                 echo "FAILED: wrong base"         
 89                 error=1                           
 90         fi                                        
 91                                                   
 92         if [ "${output}" != "${line_output}" ]    
 93                 echo "FAILED: wrong output"       
 94                 error=1                           
 95         fi                                        
 96                                                   
 97         if [ "${control}" != "${line_control}"    
 98                 echo "FAILED: wrong control"      
 99                 error=1                           
100         fi                                        
101                                                   
102         if [ "${ack}" != "${line_ack}" ]; then    
103                 echo "FAILED: wrong ack"          
104                 error=1                           
105         fi                                        
106                                                   
107         if [ "${up}" != "${line_up}" ]; then      
108                 echo "FAILED: wrong up"           
109                 error=1                           
110         fi                                        
111 }                                                 
112                                                   
113 daemon_exit()                                     
114 {                                                 
115         local config=$1                           
116                                                   
117         local line                                
118         line=`perf daemon --config ${config} -    
119         local pid                                 
120         pid=`echo "${line}" | awk 'BEGIN { FS     
121                                                   
122         # Reset trap handler.                     
123         trap - SIGINT SIGTERM                     
124                                                   
125         # stop daemon                             
126         perf daemon stop --config ${config}       
127                                                   
128         # ... and wait for the pid to go away     
129         tail --pid=${pid} -f /dev/null            
130 }                                                 
131                                                   
132 daemon_start()                                    
133 {                                                 
134         local config=$1                           
135         local session=$2                          
136                                                   
137         perf daemon start --config ${config}      
138                                                   
139         # Clean up daemon if interrupted.         
140         trap 'echo "FAILED: Signal caught"; da    
141                                                   
142         # wait for the session to ping            
143         local state="FAIL"                        
144         local retries=0                           
145         while [ "${state}" != "OK" ]; do          
146                 state=`perf daemon ping --conf    
147                 sleep 0.05                        
148                 retries=$((${retries} +1))        
149                 if [ ${retries} -ge 600 ]; the    
150                         echo "FAILED: Timeout     
151                         daemon_exit ${config}     
152                         exit 1                    
153                 fi                                
154         done                                      
155 }                                                 
156                                                   
157 test_list()                                       
158 {                                                 
159         echo "test daemon list"                   
160                                                   
161         local config                              
162         config=$(mktemp /tmp/perf.daemon.confi    
163         local base                                
164         base=$(mktemp -d /tmp/perf.daemon.base    
165                                                   
166         cat <<EOF > ${config}                     
167 [daemon]                                          
168 base=BASE                                         
169                                                   
170 [session-size]                                    
171 run = -e cpu-clock -m 1 sleep 10                  
172                                                   
173 [session-time]                                    
174 run = -e task-clock -m 1 sleep 10                 
175 EOF                                               
176                                                   
177         sed -i -e "s|BASE|${base}|" ${config}     
178                                                   
179         # start daemon                            
180         daemon_start ${config} size               
181                                                   
182         # check first line                        
183         # pid:daemon:base:base/output:base/loc    
184         local line                                
185         line=`perf daemon --config ${config} -    
186         check_line_first ${line} daemon ${base    
187                                                   
188         # check 1st session                       
189         # pid:size:-e cpu-clock:base/size:base    
190         local line                                
191         line=`perf daemon --config ${config} -    
192         check_line_other "${line}" size "-e cp    
193                          ${base}/session-size/    
194                          ${base}/session-size/    
195                                                   
196         # check 2nd session                       
197         # pid:time:-e task-clock:base/time:bas    
198         local line                                
199         line=`perf daemon --config ${config} -    
200         check_line_other "${line}" time "-e ta    
201                          ${base}/session-time/    
202                          ${base}/session-time/    
203                                                   
204         # stop daemon                             
205         daemon_exit ${config}                     
206                                                   
207         rm -rf ${base}                            
208         rm -f ${config}                           
209 }                                                 
210                                                   
211 test_reconfig()                                   
212 {                                                 
213         echo "test daemon reconfig"               
214                                                   
215         local config                              
216         config=$(mktemp /tmp/perf.daemon.confi    
217         local base                                
218         base=$(mktemp -d /tmp/perf.daemon.base    
219                                                   
220         # prepare config                          
221         cat <<EOF > ${config}                     
222 [daemon]                                          
223 base=BASE                                         
224                                                   
225 [session-size]                                    
226 run = -e cpu-clock -m 1 sleep 10                  
227                                                   
228 [session-time]                                    
229 run = -e task-clock -m 1 sleep 10                 
230 EOF                                               
231                                                   
232         sed -i -e "s|BASE|${base}|" ${config}     
233                                                   
234         # start daemon                            
235         daemon_start ${config} size               
236                                                   
237         # check 2nd session                       
238         # pid:time:-e task-clock:base/time:bas    
239         local line                                
240         line=`perf daemon --config ${config} -    
241         check_line_other "${line}" time "-e ta    
242                          ${base}/session-time/    
243         local pid                                 
244         pid=`echo "${line}" | awk 'BEGIN { FS     
245                                                   
246         # prepare new config                      
247         local config_new=${config}.new            
248         cat <<EOF > ${config_new}                 
249 [daemon]                                          
250 base=BASE                                         
251                                                   
252 [session-size]                                    
253 run = -e cpu-clock -m 1 sleep 10                  
254                                                   
255 [session-time]                                    
256 run = -e cpu-clock -m 1 sleep 10                  
257 EOF                                               
258                                                   
259         # TEST 1 - change config                  
260                                                   
261         sed -i -e "s|BASE|${base}|" ${config_n    
262         cp ${config_new} ${config}                
263                                                   
264         # wait for old session to finish          
265         tail --pid=${pid} -f /dev/null            
266                                                   
267         # wait for new one to start               
268         local state="FAIL"                        
269         while [ "${state}" != "OK" ]; do          
270                 state=`perf daemon ping --conf    
271         done                                      
272                                                   
273         # check reconfigured 2nd session          
274         # pid:time:-e task-clock:base/time:bas    
275         local line                                
276         line=`perf daemon --config ${config} -    
277         check_line_other "${line}" time "-e cp    
278                          ${base}/session-time/    
279                                                   
280         # TEST 2 - empty config                   
281                                                   
282         local config_empty=${config}.empty        
283         cat <<EOF > ${config_empty}               
284 [daemon]                                          
285 base=BASE                                         
286 EOF                                               
287                                                   
288         # change config                           
289         sed -i -e "s|BASE|${base}|" ${config_e    
290         cp ${config_empty} ${config}              
291                                                   
292         # wait for sessions to finish             
293         local state="OK"                          
294         while [ "${state}" != "FAIL" ]; do        
295                 state=`perf daemon ping --conf    
296         done                                      
297                                                   
298         local state="OK"                          
299         while [ "${state}" != "FAIL" ]; do        
300                 state=`perf daemon ping --conf    
301         done                                      
302                                                   
303         local one                                 
304         one=`perf daemon --config ${config} -x    
305                                                   
306         if [ ${one} -ne "1" ]; then               
307                 echo "FAILED: wrong list outpu    
308                 error=1                           
309         fi                                        
310                                                   
311         # TEST 3 - config again                   
312                                                   
313         cp ${config_new} ${config}                
314                                                   
315         # wait for size to start                  
316         local state="FAIL"                        
317         while [ "${state}" != "OK" ]; do          
318                 state=`perf daemon ping --conf    
319         done                                      
320                                                   
321         # wait for time to start                  
322         local state="FAIL"                        
323         while [ "${state}" != "OK" ]; do          
324                 state=`perf daemon ping --conf    
325         done                                      
326                                                   
327         # stop daemon                             
328         daemon_exit ${config}                     
329                                                   
330         rm -rf ${base}                            
331         rm -f ${config}                           
332         rm -f ${config_new}                       
333         rm -f ${config_empty}                     
334 }                                                 
335                                                   
336 test_stop()                                       
337 {                                                 
338         echo "test daemon stop"                   
339                                                   
340         local config                              
341         config=$(mktemp /tmp/perf.daemon.confi    
342         local base                                
343         base=$(mktemp -d /tmp/perf.daemon.base    
344                                                   
345         # prepare config                          
346         cat <<EOF > ${config}                     
347 [daemon]                                          
348 base=BASE                                         
349                                                   
350 [session-size]                                    
351 run = -e cpu-clock -m 1 sleep 10                  
352                                                   
353 [session-time]                                    
354 run = -e task-clock -m 1 sleep 10                 
355 EOF                                               
356                                                   
357         sed -i -e "s|BASE|${base}|" ${config}     
358                                                   
359         # start daemon                            
360         daemon_start ${config} size               
361                                                   
362         local pid_size                            
363         pid_size=`perf daemon --config ${confi    
364                   awk 'BEGIN { FS = ":" } ; {     
365         local pid_time                            
366         pid_time=`perf daemon --config ${confi    
367                   awk 'BEGIN { FS = ":" } ; {     
368                                                   
369         # check that sessions are running         
370         if [ ! -d "/proc/${pid_size}" ]; then     
371                 echo "FAILED: session size not    
372         fi                                        
373                                                   
374         if [ ! -d "/proc/${pid_time}" ]; then     
375                 echo "FAILED: session time not    
376         fi                                        
377                                                   
378         # stop daemon                             
379         daemon_exit ${config}                     
380                                                   
381         # check that sessions are gone            
382         if [ -d "/proc/${pid_size}" ]; then       
383                 echo "FAILED: session size sti    
384         fi                                        
385                                                   
386         if [ -d "/proc/${pid_time}" ]; then       
387                 echo "FAILED: session time sti    
388         fi                                        
389                                                   
390         rm -rf ${base}                            
391         rm -f ${config}                           
392 }                                                 
393                                                   
394 test_signal()                                     
395 {                                                 
396         echo "test daemon signal"                 
397                                                   
398         local config                              
399         config=$(mktemp /tmp/perf.daemon.confi    
400         local base                                
401         base=$(mktemp -d /tmp/perf.daemon.base    
402                                                   
403         # prepare config                          
404         cat <<EOF > ${config}                     
405 [daemon]                                          
406 base=BASE                                         
407                                                   
408 [session-test]                                    
409 run = -e cpu-clock --switch-output -m 1 sleep     
410 EOF                                               
411                                                   
412         sed -i -e "s|BASE|${base}|" ${config}     
413                                                   
414         # start daemon                            
415         daemon_start ${config} test               
416                                                   
417         # send 2 signals then exit. Do this in    
418         # files to avoid races. If the loop re    
419         # give up.                                
420         local retries=0                           
421         local signals=0                           
422         local success=0                           
423         while [ ${retries} -lt 600 ] && [ ${su    
424                 local files                       
425                 files=`ls ${base}/session-test    
426                 if [ ${signals} -eq 0 ]; then     
427                         perf daemon signal --c    
428                         signals=1                 
429                 elif [ ${signals} -eq 1 ] && [    
430                         perf daemon signal --c    
431                         signals=2                 
432                 elif [ ${signals} -eq 2 ] && [    
433                         daemon_exit ${config}     
434                         signals=3                 
435                 elif [ ${signals} -eq 3 ] && [    
436                         success=1                 
437                 fi                                
438                 retries=$((${retries} +1))        
439         done                                      
440         if [ ${success} -eq 0 ]; then             
441                 error=1                           
442                 echo "FAILED: perf data no gen    
443         fi                                        
444                                                   
445         rm -rf ${base}                            
446         rm -f ${config}                           
447 }                                                 
448                                                   
449 test_ping()                                       
450 {                                                 
451         echo "test daemon ping"                   
452                                                   
453         local config                              
454         config=$(mktemp /tmp/perf.daemon.confi    
455         local base                                
456         base=$(mktemp -d /tmp/perf.daemon.base    
457                                                   
458         # prepare config                          
459         cat <<EOF > ${config}                     
460 [daemon]                                          
461 base=BASE                                         
462                                                   
463 [session-size]                                    
464 run = -e cpu-clock -m 1 sleep 10                  
465                                                   
466 [session-time]                                    
467 run = -e task-clock -m 1 sleep 10                 
468 EOF                                               
469                                                   
470         sed -i -e "s|BASE|${base}|" ${config}     
471                                                   
472         # start daemon                            
473         daemon_start ${config} size               
474                                                   
475         size=`perf daemon ping --config ${conf    
476         type=`perf daemon ping --config ${conf    
477                                                   
478         if [ ${size} != "OK" ] || [ ${type} !=    
479                 error=1                           
480                 echo "FAILED: daemon ping fail    
481         fi                                        
482                                                   
483         # stop daemon                             
484         daemon_exit ${config}                     
485                                                   
486         rm -rf ${base}                            
487         rm -f ${config}                           
488 }                                                 
489                                                   
490 test_lock()                                       
491 {                                                 
492         echo "test daemon lock"                   
493                                                   
494         local config                              
495         config=$(mktemp /tmp/perf.daemon.confi    
496         local base                                
497         base=$(mktemp -d /tmp/perf.daemon.base    
498                                                   
499         # prepare config                          
500         cat <<EOF > ${config}                     
501 [daemon]                                          
502 base=BASE                                         
503                                                   
504 [session-size]                                    
505 run = -e cpu-clock -m 1 sleep 10                  
506 EOF                                               
507                                                   
508         sed -i -e "s|BASE|${base}|" ${config}     
509                                                   
510         # start daemon                            
511         daemon_start ${config} size               
512                                                   
513         # start second daemon over the same co    
514         failed=`perf daemon start --config ${c    
515                                                   
516         # check that we failed properly           
517         if [ ${failed} != "failed:" ]; then       
518                 error=1                           
519                 echo "FAILED: daemon lock fail    
520         fi                                        
521                                                   
522         # stop daemon                             
523         daemon_exit ${config}                     
524                                                   
525         rm -rf ${base}                            
526         rm -f ${config}                           
527 }                                                 
528                                                   
529 error=0                                           
530                                                   
531 test_list                                         
532 test_reconfig                                     
533 test_stop                                         
534 test_signal                                       
535 test_ping                                         
536 test_lock                                         
537                                                   
538 exit ${error}                                     
                                                      

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php