Loading...
1# perf bash and zsh completion
2# SPDX-License-Identifier: GPL-2.0
3
4# Taken from git.git's completion script.
5__my_reassemble_comp_words_by_ref()
6{
7 local exclude i j first
8 # Which word separators to exclude?
9 exclude="${1//[^$COMP_WORDBREAKS]}"
10 cword_=$COMP_CWORD
11 if [ -z "$exclude" ]; then
12 words_=("${COMP_WORDS[@]}")
13 return
14 fi
15 # List of word completion separators has shrunk;
16 # re-assemble words to complete.
17 for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do
18 # Append each nonempty word consisting of just
19 # word separator characters to the current word.
20 first=t
21 while
22 [ $i -gt 0 ] &&
23 [ -n "${COMP_WORDS[$i]}" ] &&
24 # word consists of excluded word separators
25 [ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ]
26 do
27 # Attach to the previous token,
28 # unless the previous token is the command name.
29 if [ $j -ge 2 ] && [ -n "$first" ]; then
30 ((j--))
31 fi
32 first=
33 words_[$j]=${words_[j]}${COMP_WORDS[i]}
34 if [ $i = $COMP_CWORD ]; then
35 cword_=$j
36 fi
37 if (($i < ${#COMP_WORDS[@]} - 1)); then
38 ((i++))
39 else
40 # Done.
41 return
42 fi
43 done
44 words_[$j]=${words_[j]}${COMP_WORDS[i]}
45 if [ $i = $COMP_CWORD ]; then
46 cword_=$j
47 fi
48 done
49}
50
51# Define preload_get_comp_words_by_ref="false", if the function
52# __perf_get_comp_words_by_ref() is required instead.
53preload_get_comp_words_by_ref="true"
54
55if [ $preload_get_comp_words_by_ref = "true" ]; then
56 type _get_comp_words_by_ref &>/dev/null ||
57 preload_get_comp_words_by_ref="false"
58fi
59[ $preload_get_comp_words_by_ref = "true" ] ||
60__perf_get_comp_words_by_ref()
61{
62 local exclude cur_ words_ cword_
63 if [ "$1" = "-n" ]; then
64 exclude=$2
65 shift 2
66 fi
67 __my_reassemble_comp_words_by_ref "$exclude"
68 cur_=${words_[cword_]}
69 while [ $# -gt 0 ]; do
70 case "$1" in
71 cur)
72 cur=$cur_
73 ;;
74 prev)
75 prev=${words_[$cword_-1]}
76 ;;
77 words)
78 words=("${words_[@]}")
79 ;;
80 cword)
81 cword=$cword_
82 ;;
83 esac
84 shift
85 done
86}
87
88# Define preload__ltrim_colon_completions="false", if the function
89# __perf__ltrim_colon_completions() is required instead.
90preload__ltrim_colon_completions="true"
91
92if [ $preload__ltrim_colon_completions = "true" ]; then
93 type __ltrim_colon_completions &>/dev/null ||
94 preload__ltrim_colon_completions="false"
95fi
96[ $preload__ltrim_colon_completions = "true" ] ||
97__perf__ltrim_colon_completions()
98{
99 if [[ "$1" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then
100 # Remove colon-word prefix from COMPREPLY items
101 local colon_word=${1%"${1##*:}"}
102 local i=${#COMPREPLY[*]}
103 while [[ $((--i)) -ge 0 ]]; do
104 COMPREPLY[$i]=${COMPREPLY[$i]#"$colon_word"}
105 done
106 fi
107}
108
109__perfcomp ()
110{
111 # Expansion of spaces to array is deliberate.
112 # shellcheck disable=SC2207
113 COMPREPLY=( $( compgen -W "$1" -- "$2" ) )
114}
115
116__perfcomp_colon ()
117{
118 __perfcomp "$1" "$2"
119 if [ $preload__ltrim_colon_completions = "true" ]; then
120 __ltrim_colon_completions $cur
121 else
122 __perf__ltrim_colon_completions $cur
123 fi
124}
125
126__perf_prev_skip_opts ()
127{
128 local i cmd_ cmds_
129
130 let i=cword-1
131 cmds_=$($cmd $1 --list-cmds)
132 prev_skip_opts=""
133 while [ $i -ge 0 ]; do
134 if [[ ${words[i]} == "$1" ]]; then
135 return
136 fi
137 for cmd_ in $cmds_; do
138 if [[ ${words[i]} == "$cmd_" ]]; then
139 prev_skip_opts=${words[i]}
140 return
141 fi
142 done
143 ((i--))
144 done
145}
146
147__perf_main ()
148{
149 local cmd
150
151 cmd=${words[0]}
152 COMPREPLY=()
153
154 # Skip options backward and find the last perf command
155 __perf_prev_skip_opts
156 # List perf subcommands or long options
157 if [ -z $prev_skip_opts ]; then
158 if [[ $cur == --* ]]; then
159 cmds=$($cmd --list-opts)
160 else
161 cmds=$($cmd --list-cmds)
162 fi
163 __perfcomp "$cmds" "$cur"
164 # List possible events for -e option
165 elif [[ $prev == @("-e"|"--event") &&
166 $prev_skip_opts == @(record|stat|top) ]]; then
167
168 local cur1=${COMP_WORDS[COMP_CWORD]}
169 local raw_evts
170 local arr s tmp result cpu_evts
171
172 raw_evts=$($cmd list --raw-dump hw sw cache tracepoint pmu sdt)
173 # aarch64 doesn't have /sys/bus/event_source/devices/cpu/events
174 if [[ `uname -m` != aarch64 ]]; then
175 cpu_evts=$(ls /sys/bus/event_source/devices/cpu/events)
176 fi
177
178 if [[ "$cur1" == */* && ${cur1#*/} =~ ^[A-Z] ]]; then
179 OLD_IFS="$IFS"
180 IFS=" "
181 # Expansion of spaces to array is deliberate.
182 # shellcheck disable=SC2206
183 arr=($raw_evts)
184 IFS="$OLD_IFS"
185
186 for s in "${arr[@]}"
187 do
188 if [[ "$s" == *cpu/* ]]; then
189 tmp=${s#*cpu/}
190 result=$result" ""cpu/"${tmp^^}
191 else
192 result=$result" "$s
193 fi
194 done
195
196 evts=${result}" "${cpu_evts}
197 else
198 evts=${raw_evts}" "${cpu_evts}
199 fi
200
201 if [[ "$cur1" == , ]]; then
202 __perfcomp_colon "$evts" ""
203 else
204 __perfcomp_colon "$evts" "$cur1"
205 fi
206 elif [[ $prev == @("--pfm-events") &&
207 $prev_skip_opts == @(record|stat|top) ]]; then
208 local evts
209 evts=$($cmd list --raw-dump pfm)
210 __perfcomp "$evts" "$cur"
211 elif [[ $prev == @("-M"|"--metrics") &&
212 $prev_skip_opts == @(stat) ]]; then
213 local metrics
214 metrics=$($cmd list --raw-dump metric metricgroup)
215 __perfcomp "$metrics" "$cur"
216 else
217 # List subcommands for perf commands
218 if [[ $prev_skip_opts == @(kvm|kmem|mem|lock|sched|
219 |data|help|script|test|timechart|trace) ]]; then
220 subcmds=$($cmd $prev_skip_opts --list-cmds)
221 __perfcomp_colon "$subcmds" "$cur"
222 fi
223 # List long option names
224 if [[ $cur == --* ]]; then
225 subcmd=$prev_skip_opts
226 __perf_prev_skip_opts $subcmd
227 subcmd=$subcmd" "$prev_skip_opts
228 opts=$($cmd $subcmd --list-opts)
229 __perfcomp "$opts" "$cur"
230 fi
231 fi
232}
233
234if [[ -n ${ZSH_VERSION-} ]]; then
235 autoload -U +X compinit && compinit
236
237 __perfcomp ()
238 {
239 emulate -L zsh
240
241 local c IFS=$' \t\n'
242 local -a array
243
244 for c in ${=1}; do
245 case $c in
246 --*=*|*.) ;;
247 *) c="$c " ;;
248 esac
249 array[${#array[@]}+1]="$c"
250 done
251
252 compset -P '*[=:]'
253 compadd -Q -S '' -a -- array && _ret=0
254 }
255
256 __perfcomp_colon ()
257 {
258 emulate -L zsh
259
260 local cur_="${2-$cur}"
261 local c IFS=$' \t\n'
262 local -a array
263
264 if [[ "$cur_" == *:* ]]; then
265 local colon_word=${cur_%"${cur_##*:}"}
266 fi
267
268 for c in ${=1}; do
269 case $c in
270 --*=*|*.) ;;
271 *) c="$c " ;;
272 esac
273 array[$#array+1]=${c#"$colon_word"}
274 done
275
276 compset -P '*[=:]'
277 compadd -Q -S '' -a -- array && _ret=0
278 }
279
280 _perf ()
281 {
282 local _ret=1 cur cword prev
283 cur=${words[CURRENT]}
284 prev=${words[CURRENT-1]}
285 let cword=CURRENT-1
286 emulate ksh -c __perf_main
287 let _ret && _default && _ret=0
288 # _ret is only assigned 0 or 1, disable inaccurate analysis.
289 # shellcheck disable=SC2152
290 return _ret
291 }
292
293 compdef _perf perf
294 return
295fi
296
297type perf &>/dev/null &&
298_perf()
299{
300 if [[ "$COMP_WORDBREAKS" != *,* ]]; then
301 COMP_WORDBREAKS="${COMP_WORDBREAKS},"
302 export COMP_WORDBREAKS
303 fi
304
305 if [[ "$COMP_WORDBREAKS" == *:* ]]; then
306 COMP_WORDBREAKS="${COMP_WORDBREAKS/:/}"
307 export COMP_WORDBREAKS
308 fi
309
310 local cur words cword prev
311 if [ $preload_get_comp_words_by_ref = "true" ]; then
312 _get_comp_words_by_ref -n =:, cur words cword prev
313 else
314 __perf_get_comp_words_by_ref -n =:, cur words cword prev
315 fi
316 __perf_main
317} &&
318
319complete -o bashdefault -o default -o nospace -F _perf perf 2>/dev/null \
320 || complete -o default -o nospace -F _perf perf
1# perf bash and zsh completion
2
3# Taken from git.git's completion script.
4__my_reassemble_comp_words_by_ref()
5{
6 local exclude i j first
7 # Which word separators to exclude?
8 exclude="${1//[^$COMP_WORDBREAKS]}"
9 cword_=$COMP_CWORD
10 if [ -z "$exclude" ]; then
11 words_=("${COMP_WORDS[@]}")
12 return
13 fi
14 # List of word completion separators has shrunk;
15 # re-assemble words to complete.
16 for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do
17 # Append each nonempty word consisting of just
18 # word separator characters to the current word.
19 first=t
20 while
21 [ $i -gt 0 ] &&
22 [ -n "${COMP_WORDS[$i]}" ] &&
23 # word consists of excluded word separators
24 [ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ]
25 do
26 # Attach to the previous token,
27 # unless the previous token is the command name.
28 if [ $j -ge 2 ] && [ -n "$first" ]; then
29 ((j--))
30 fi
31 first=
32 words_[$j]=${words_[j]}${COMP_WORDS[i]}
33 if [ $i = $COMP_CWORD ]; then
34 cword_=$j
35 fi
36 if (($i < ${#COMP_WORDS[@]} - 1)); then
37 ((i++))
38 else
39 # Done.
40 return
41 fi
42 done
43 words_[$j]=${words_[j]}${COMP_WORDS[i]}
44 if [ $i = $COMP_CWORD ]; then
45 cword_=$j
46 fi
47 done
48}
49
50# Define preload_get_comp_words_by_ref="false", if the function
51# __perf_get_comp_words_by_ref() is required instead.
52preload_get_comp_words_by_ref="true"
53
54if [ $preload_get_comp_words_by_ref = "true" ]; then
55 type _get_comp_words_by_ref &>/dev/null ||
56 preload_get_comp_words_by_ref="false"
57fi
58[ $preload_get_comp_words_by_ref = "true" ] ||
59__perf_get_comp_words_by_ref()
60{
61 local exclude cur_ words_ cword_
62 if [ "$1" = "-n" ]; then
63 exclude=$2
64 shift 2
65 fi
66 __my_reassemble_comp_words_by_ref "$exclude"
67 cur_=${words_[cword_]}
68 while [ $# -gt 0 ]; do
69 case "$1" in
70 cur)
71 cur=$cur_
72 ;;
73 prev)
74 prev=${words_[$cword_-1]}
75 ;;
76 words)
77 words=("${words_[@]}")
78 ;;
79 cword)
80 cword=$cword_
81 ;;
82 esac
83 shift
84 done
85}
86
87# Define preload__ltrim_colon_completions="false", if the function
88# __perf__ltrim_colon_completions() is required instead.
89preload__ltrim_colon_completions="true"
90
91if [ $preload__ltrim_colon_completions = "true" ]; then
92 type __ltrim_colon_completions &>/dev/null ||
93 preload__ltrim_colon_completions="false"
94fi
95[ $preload__ltrim_colon_completions = "true" ] ||
96__perf__ltrim_colon_completions()
97{
98 if [[ "$1" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then
99 # Remove colon-word prefix from COMPREPLY items
100 local colon_word=${1%"${1##*:}"}
101 local i=${#COMPREPLY[*]}
102 while [[ $((--i)) -ge 0 ]]; do
103 COMPREPLY[$i]=${COMPREPLY[$i]#"$colon_word"}
104 done
105 fi
106}
107
108__perfcomp ()
109{
110 COMPREPLY=( $( compgen -W "$1" -- "$2" ) )
111}
112
113__perfcomp_colon ()
114{
115 __perfcomp "$1" "$2"
116 if [ $preload__ltrim_colon_completions = "true" ]; then
117 __ltrim_colon_completions $cur
118 else
119 __perf__ltrim_colon_completions $cur
120 fi
121}
122
123__perf_prev_skip_opts ()
124{
125 local i cmd_ cmds_
126
127 let i=cword-1
128 cmds_=$($cmd $1 --list-cmds)
129 prev_skip_opts=()
130 while [ $i -ge 0 ]; do
131 if [[ ${words[i]} == $1 ]]; then
132 return
133 fi
134 for cmd_ in $cmds_; do
135 if [[ ${words[i]} == $cmd_ ]]; then
136 prev_skip_opts=${words[i]}
137 return
138 fi
139 done
140 ((i--))
141 done
142}
143
144__perf_main ()
145{
146 local cmd
147
148 cmd=${words[0]}
149 COMPREPLY=()
150
151 # Skip options backward and find the last perf command
152 __perf_prev_skip_opts
153 # List perf subcommands or long options
154 if [ -z $prev_skip_opts ]; then
155 if [[ $cur == --* ]]; then
156 cmds=$($cmd --list-opts)
157 else
158 cmds=$($cmd --list-cmds)
159 fi
160 __perfcomp "$cmds" "$cur"
161 # List possible events for -e option
162 elif [[ $prev == @("-e"|"--event") &&
163 $prev_skip_opts == @(record|stat|top) ]]; then
164 evts=$($cmd list --raw-dump)
165 __perfcomp_colon "$evts" "$cur"
166 else
167 # List subcommands for perf commands
168 if [[ $prev_skip_opts == @(kvm|kmem|mem|lock|sched|
169 |data|help|script|test|timechart|trace) ]]; then
170 subcmds=$($cmd $prev_skip_opts --list-cmds)
171 __perfcomp_colon "$subcmds" "$cur"
172 fi
173 # List long option names
174 if [[ $cur == --* ]]; then
175 subcmd=$prev_skip_opts
176 __perf_prev_skip_opts $subcmd
177 subcmd=$subcmd" "$prev_skip_opts
178 opts=$($cmd $subcmd --list-opts)
179 __perfcomp "$opts" "$cur"
180 fi
181 fi
182}
183
184if [[ -n ${ZSH_VERSION-} ]]; then
185 autoload -U +X compinit && compinit
186
187 __perfcomp ()
188 {
189 emulate -L zsh
190
191 local c IFS=$' \t\n'
192 local -a array
193
194 for c in ${=1}; do
195 case $c in
196 --*=*|*.) ;;
197 *) c="$c " ;;
198 esac
199 array[${#array[@]}+1]="$c"
200 done
201
202 compset -P '*[=:]'
203 compadd -Q -S '' -a -- array && _ret=0
204 }
205
206 __perfcomp_colon ()
207 {
208 emulate -L zsh
209
210 local cur_="${2-$cur}"
211 local c IFS=$' \t\n'
212 local -a array
213
214 if [[ "$cur_" == *:* ]]; then
215 local colon_word=${cur_%"${cur_##*:}"}
216 fi
217
218 for c in ${=1}; do
219 case $c in
220 --*=*|*.) ;;
221 *) c="$c " ;;
222 esac
223 array[$#array+1]=${c#"$colon_word"}
224 done
225
226 compset -P '*[=:]'
227 compadd -Q -S '' -a -- array && _ret=0
228 }
229
230 _perf ()
231 {
232 local _ret=1 cur cword prev
233 cur=${words[CURRENT]}
234 prev=${words[CURRENT-1]}
235 let cword=CURRENT-1
236 emulate ksh -c __perf_main
237 let _ret && _default && _ret=0
238 return _ret
239 }
240
241 compdef _perf perf
242 return
243fi
244
245type perf &>/dev/null &&
246_perf()
247{
248 local cur words cword prev
249 if [ $preload_get_comp_words_by_ref = "true" ]; then
250 _get_comp_words_by_ref -n =: cur words cword prev
251 else
252 __perf_get_comp_words_by_ref -n =: cur words cword prev
253 fi
254 __perf_main
255} &&
256
257complete -o bashdefault -o default -o nospace -F _perf perf 2>/dev/null \
258 || complete -o default -o nospace -F _perf perf