tools/perf/perf-completion.sh

0001 # perf bash and zsh completion
0002 # SPDX-License-Identifier: GPL-2.0
0003
0004 # Taken from git.git's completion script.
0005 __my_reassemble_comp_words_by_ref()
0006 {
0007         local exclude i j first
0008         # Which word separators to exclude?
0009         exclude="${1//[^$COMP_WORDBREAKS]}"
0010         cword_=$COMP_CWORD
0011         if [ -z "$exclude" ]; then
0012                 words_=("${COMP_WORDS[@]}")
0013                 return
0014         fi
0015         # List of word completion separators has shrunk;
0016         # re-assemble words to complete.
0017         for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do
0018                 # Append each nonempty word consisting of just
0019                 # word separator characters to the current word.
0020                 first=t
0021                 while
0022                         [ $i -gt 0 ] &&
0023                         [ -n "${COMP_WORDS[$i]}" ] &&
0024                         # word consists of excluded word separators
0025                         [ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ]
0026                 do
0027                         # Attach to the previous token,
0028                         # unless the previous token is the command name.
0029                         if [ $j -ge 2 ] && [ -n "$first" ]; then
0030                                 ((j--))
0031                         fi
0032                         first=
0033                         words_[$j]=${words_[j]}${COMP_WORDS[i]}
0034                         if [ $i = $COMP_CWORD ]; then
0035                                 cword_=$j
0036                         fi
0037                         if (($i < ${#COMP_WORDS[@]} - 1)); then
0038                                 ((i++))
0039                         else
0040                                 # Done.
0041                                 return
0042                         fi
0043                 done
0044                 words_[$j]=${words_[j]}${COMP_WORDS[i]}
0045                 if [ $i = $COMP_CWORD ]; then
0046                         cword_=$j
0047                 fi
0048         done
0049 }
0050
0051 # Define preload_get_comp_words_by_ref="false", if the function
0052 # __perf_get_comp_words_by_ref() is required instead.
0053 preload_get_comp_words_by_ref="true"
0054
0055 if [ $preload_get_comp_words_by_ref = "true" ]; then
0056         type _get_comp_words_by_ref &>/dev/null ||
0057         preload_get_comp_words_by_ref="false"
0058 fi
0059 [ $preload_get_comp_words_by_ref = "true" ] ||
0060 __perf_get_comp_words_by_ref()
0061 {
0062         local exclude cur_ words_ cword_
0063         if [ "$1" = "-n" ]; then
0064                 exclude=$2
0065                 shift 2
0066         fi
0067         __my_reassemble_comp_words_by_ref "$exclude"
0068         cur_=${words_[cword_]}
0069         while [ $# -gt 0 ]; do
0070                 case "$1" in
0071                 cur)
0072                         cur=$cur_
0073                         ;;
0074                 prev)
0075                         prev=${words_[$cword_-1]}
0076                         ;;
0077                 words)
0078                         words=("${words_[@]}")
0079                         ;;
0080                 cword)
0081                         cword=$cword_
0082                         ;;
0083                 esac
0084                 shift
0085         done
0086 }
0087
0088 # Define preload__ltrim_colon_completions="false", if the function
0089 # __perf__ltrim_colon_completions() is required instead.
0090 preload__ltrim_colon_completions="true"
0091
0092 if [ $preload__ltrim_colon_completions = "true" ]; then
0093         type __ltrim_colon_completions &>/dev/null ||
0094         preload__ltrim_colon_completions="false"
0095 fi
0096 [ $preload__ltrim_colon_completions = "true" ] ||
0097 __perf__ltrim_colon_completions()
0098 {
0099         if [[ "$1" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then
0100                 # Remove colon-word prefix from COMPREPLY items
0101                 local colon_word=${1%"${1##*:}"}
0102                 local i=${#COMPREPLY[*]}
0103                 while [[ $((--i)) -ge 0 ]]; do
0104                         COMPREPLY[$i]=${COMPREPLY[$i]#"$colon_word"}
0105                 done
0106         fi
0107 }
0108
0109 __perfcomp ()
0110 {
0111         COMPREPLY=( $( compgen -W "$1" -- "$2" ) )
0112 }
0113
0114 __perfcomp_colon ()
0115 {
0116         __perfcomp "$1" "$2"
0117         if [ $preload__ltrim_colon_completions = "true" ]; then
0118                 __ltrim_colon_completions $cur
0119         else
0120                 __perf__ltrim_colon_completions $cur
0121         fi
0122 }
0123
0124 __perf_prev_skip_opts ()
0125 {
0126         local i cmd_ cmds_
0127
0128         let i=cword-1
0129         cmds_=$($cmd $1 --list-cmds)
0130         prev_skip_opts=()
0131         while [ $i -ge 0 ]; do
0132                 if [[ ${words[i]} == $1 ]]; then
0133                         return
0134                 fi
0135                 for cmd_ in $cmds_; do
0136                         if [[ ${words[i]} == $cmd_ ]]; then
0137                                 prev_skip_opts=${words[i]}
0138                                 return
0139                         fi
0140                 done
0141                 ((i--))
0142         done
0143 }
0144
0145 __perf_main ()
0146 {
0147         local cmd
0148
0149         cmd=${words[0]}
0150         COMPREPLY=()
0151
0152         # Skip options backward and find the last perf command
0153         __perf_prev_skip_opts
0154         # List perf subcommands or long options
0155         if [ -z $prev_skip_opts ]; then
0156                 if [[ $cur == --* ]]; then
0157                         cmds=$($cmd --list-opts)
0158                 else
0159                         cmds=$($cmd --list-cmds)
0160                 fi
0161                 __perfcomp "$cmds" "$cur"
0162         # List possible events for -e option
0163         elif [[ $prev == @("-e"|"--event") &&
0164                 $prev_skip_opts == @(record|stat|top) ]]; then
0165
0166                 local cur1=${COMP_WORDS[COMP_CWORD]}
0167                 local raw_evts=$($cmd list --raw-dump)
0168                 local arr s tmp result
0169
0170                 if [[ "$cur1" == */* && ${cur1#*/} =~ ^[A-Z] ]]; then
0171                         OLD_IFS="$IFS"
0172                         IFS=" "
0173                         arr=($raw_evts)
0174                         IFS="$OLD_IFS"
0175
0176                         for s in ${arr[@]}
0177                         do
0178                                 if [[ "$s" == *cpu/* ]]; then
0179                                         tmp=${s#*cpu/}
0180                                         result=$result" ""cpu/"${tmp^^}
0181                                 else
0182                                         result=$result" "$s
0183                                 fi
0184                         done
0185
0186                         evts=${result}" "$(ls /sys/bus/event_source/devices/cpu/events)
0187                 else
0188                         evts=${raw_evts}" "$(ls /sys/bus/event_source/devices/cpu/events)
0189                 fi
0190
0191                 if [[ "$cur1" == , ]]; then
0192                         __perfcomp_colon "$evts" ""
0193                 else
0194                         __perfcomp_colon "$evts" "$cur1"
0195                 fi
0196         else
0197                 # List subcommands for perf commands
0198                 if [[ $prev_skip_opts == @(kvm|kmem|mem|lock|sched|
0199                         |data|help|script|test|timechart|trace) ]]; then
0200                         subcmds=$($cmd $prev_skip_opts --list-cmds)
0201                         __perfcomp_colon "$subcmds" "$cur"
0202                 fi
0203                 # List long option names
0204                 if [[ $cur == --* ]];  then
0205                         subcmd=$prev_skip_opts
0206                         __perf_prev_skip_opts $subcmd
0207                         subcmd=$subcmd" "$prev_skip_opts
0208                         opts=$($cmd $subcmd --list-opts)
0209                         __perfcomp "$opts" "$cur"
0210                 fi
0211         fi
0212 }
0213
0214 if [[ -n ${ZSH_VERSION-} ]]; then
0215         autoload -U +X compinit && compinit
0216
0217         __perfcomp ()
0218         {
0219                 emulate -L zsh
0220
0221                 local c IFS=$' \t\n'
0222                 local -a array
0223
0224                 for c in ${=1}; do
0225                         case $c in
0226                         --*=*|*.) ;;
0227                         *) c="$c " ;;
0228                         esac
0229                         array[${#array[@]}+1]="$c"
0230                 done
0231
0232                 compset -P '*[=:]'
0233                 compadd -Q -S '' -a -- array && _ret=0
0234         }
0235
0236         __perfcomp_colon ()
0237         {
0238                 emulate -L zsh
0239
0240                 local cur_="${2-$cur}"
0241                 local c IFS=$' \t\n'
0242                 local -a array
0243
0244                 if [[ "$cur_" == *:* ]]; then
0245                         local colon_word=${cur_%"${cur_##*:}"}
0246                 fi
0247
0248                 for c in ${=1}; do
0249                         case $c in
0250                         --*=*|*.) ;;
0251                         *) c="$c " ;;
0252                         esac
0253                         array[$#array+1]=${c#"$colon_word"}
0254                 done
0255
0256                 compset -P '*[=:]'
0257                 compadd -Q -S '' -a -- array && _ret=0
0258         }
0259
0260         _perf ()
0261         {
0262                 local _ret=1 cur cword prev
0263                 cur=${words[CURRENT]}
0264                 prev=${words[CURRENT-1]}
0265                 let cword=CURRENT-1
0266                 emulate ksh -c __perf_main
0267                 let _ret && _default && _ret=0
0268                 return _ret
0269         }
0270
0271         compdef _perf perf
0272         return
0273 fi
0274
0275 type perf &>/dev/null &&
0276 _perf()
0277 {
0278         if [[ "$COMP_WORDBREAKS" != *,* ]]; then
0279                 COMP_WORDBREAKS="${COMP_WORDBREAKS},"
0280                 export COMP_WORDBREAKS
0281         fi
0282
0283         if [[ "$COMP_WORDBREAKS" == *:* ]]; then
0284                 COMP_WORDBREAKS="${COMP_WORDBREAKS/:/}"
0285                 export COMP_WORDBREAKS
0286         fi
0287
0288         local cur words cword prev
0289         if [ $preload_get_comp_words_by_ref = "true" ]; then
0290                 _get_comp_words_by_ref -n =:, cur words cword prev
0291         else
0292                 __perf_get_comp_words_by_ref -n =:, cur words cword prev
0293         fi
0294         __perf_main
0295 } &&
0296
0297 complete -o bashdefault -o default -o nospace -F _perf perf 2>/dev/null \
0298         || complete -o default -o nospace -F _perf perf