| # tc(8) completion -*- shell-script -*- |
| # Copyright 2016 6WIND S.A. |
| # Copyright 2016 Quentin Monnet <quentin.monnet@6wind.com> |
| |
| QDISC_KIND=' choke codel bfifo pfifo pfifo_head_drop fq fq_codel gred hhf \ |
| mqprio multiq netem pfifo_fast pie fq_pie red rr sfb sfq tbf atm \ |
| cbq drr dsmark hfsc htb prio qfq ' |
| FILTER_KIND=' basic bpf cgroup flow flower fw route rsvp tcindex u32 matchall ' |
| ACTION_KIND=' gact mirred bpf sample ' |
| |
| # Takes a list of words in argument; each one of them is added to COMPREPLY if |
| # it is not already present on the command line. Returns no value. |
| _tc_once_attr() |
| { |
| local w subcword found |
| for w in $*; do |
| found=0 |
| for (( subcword=3; subcword < ${#words[@]}-1; subcword++ )); do |
| if [[ $w == ${words[subcword]} ]]; then |
| found=1 |
| break |
| fi |
| done |
| [[ $found -eq 0 ]] && \ |
| COMPREPLY+=( $( compgen -W "$w" -- "$cur" ) ) |
| done |
| } |
| |
| # Takes a list of words in argument; each one of them is added to COMPREPLY if |
| # it is not already present on the command line from the provided index. Returns |
| # no value. |
| _tc_once_attr_from() |
| { |
| local w subcword found from=$1 |
| shift |
| for w in $*; do |
| found=0 |
| for (( subcword=$from; subcword < ${#words[@]}-1; subcword++ )); do |
| if [[ $w == ${words[subcword]} ]]; then |
| found=1 |
| break |
| fi |
| done |
| [[ $found -eq 0 ]] && \ |
| COMPREPLY+=( $( compgen -W "$w" -- "$cur" ) ) |
| done |
| } |
| |
| # Takes a list of words in argument; adds them all to COMPREPLY if none of them |
| # is already present on the command line. Returns no value. |
| _tc_one_of_list() |
| { |
| local w subcword |
| for w in $*; do |
| for (( subcword=3; subcword < ${#words[@]}-1; subcword++ )); do |
| [[ $w == ${words[subcword]} ]] && return 1 |
| done |
| done |
| COMPREPLY+=( $( compgen -W "$*" -- "$cur" ) ) |
| } |
| |
| # Takes a list of words in argument; adds them all to COMPREPLY if none of them |
| # is already present on the command line from the provided index. Returns no |
| # value. |
| _tc_one_of_list_from() |
| { |
| local w subcword from=$1 |
| shift |
| for w in $*; do |
| for (( subcword=$from; subcword < ${#words[@]}-1; subcword++ )); do |
| [[ $w == ${words[subcword]} ]] && return 1 |
| done |
| done |
| COMPREPLY+=( $( compgen -W "$*" -- "$cur" ) ) |
| } |
| |
| # Returns "$cur ${cur}arg1 ${cur}arg2 ..." |
| _tc_expand_units() |
| { |
| [[ $cur =~ ^[0-9]+ ]] || return 1 |
| local value=${cur%%[^0-9]*} |
| [[ $cur == $value ]] && echo $cur |
| echo ${@/#/$value} |
| } |
| |
| # Complete based on given word, usually $prev (or possibly the word before), |
| # for when an argument or an option name has but a few possible arguments (so |
| # tc does not take particular commands into account here). |
| # Returns 0 is completion should stop after running this function, 1 otherwise. |
| _tc_direct_complete() |
| { |
| case $1 in |
| # Command options |
| dev) |
| _available_interfaces |
| return 0 |
| ;; |
| classid) |
| return 0 |
| ;; |
| estimator) |
| local list=$( _tc_expand_units 'secs' 'msecs' 'usecs' ) |
| COMPREPLY+=( $( compgen -W "$list" -- "$cur" ) ) |
| return 0 |
| ;; |
| handle) |
| return 0 |
| ;; |
| parent|flowid) |
| local i iface ids cmd |
| for (( i=3; i < ${#words[@]}-2; i++ )); do |
| [[ ${words[i]} == dev ]] && iface=${words[i+1]} |
| break |
| done |
| for cmd in qdisc class; do |
| if [[ -n $iface ]]; then |
| ids+=$( tc $cmd show dev $iface 2>/dev/null | \ |
| cut -d\ -f 3 )" " |
| else |
| ids+=$( tc $cmd show 2>/dev/null | cut -d\ -f 3 ) |
| fi |
| done |
| [[ $ids != " " ]] && \ |
| COMPREPLY+=( $( compgen -W "$ids" -- "$cur" ) ) |
| return 0 |
| ;; |
| protocol) # list comes from lib/ll_proto.c |
| COMPREPLY+=( $( compgen -W ' 802.1Q 802.1ad 802_2 802_3 LLDP aarp \ |
| all aoe arp atalk atmfate atmmpoa ax25 bpq can control cust \ |
| ddcmp dec diag dna_dl dna_rc dna_rt econet ieeepup ieeepupat \ |
| ip ipv4 ipv6 ipx irda lat localtalk loop mobitex ppp_disc \ |
| ppp_mp ppp_ses ppptalk pup pupat rarp sca snap tipc tr_802_2 \ |
| wan_ppp x25' -- "$cur" ) ) |
| return 0 |
| ;; |
| prio) |
| return 0 |
| ;; |
| stab) |
| COMPREPLY+=( $( compgen -W 'mtu tsize mpu overhead |
| linklayer' -- "$cur" ) ) |
| ;; |
| |
| # Qdiscs and classes options |
| alpha|bands|beta|buckets|corrupt|debug|decrement|default|\ |
| default_index|depth|direct_qlen|divisor|duplicate|ewma|flow_limit|\ |
| flows|hh_limit|increment|indices|linklayer|non_hh_weight|num_tc|\ |
| penalty_burst|penalty_rate|prio|priomap|probability|queues|r2q|\ |
| reorder|vq|vqs) |
| return 0 |
| ;; |
| setup) |
| COMPREPLY+=( $( compgen -W 'vqs' -- "$cur" ) ) |
| return 0 |
| ;; |
| hw) |
| COMPREPLY+=( $( compgen -W '1 0' -- "$cur" ) ) |
| return 0 |
| ;; |
| distribution) |
| COMPREPLY+=( $( compgen -W 'uniform normal pareto |
| paretonormal' -- "$cur" ) ) |
| return 0 |
| ;; |
| loss) |
| COMPREPLY+=( $( compgen -W 'random state gmodel' -- "$cur" ) ) |
| return 0 |
| ;; |
| |
| # Qdiscs and classes options options |
| gap|gmodel|state) |
| return 0 |
| ;; |
| |
| # Filters options |
| map) |
| COMPREPLY+=( $( compgen -W 'key' -- "$cur" ) ) |
| return 0 |
| ;; |
| hash) |
| COMPREPLY+=( $( compgen -W 'keys' -- "$cur" ) ) |
| return 0 |
| ;; |
| indev) |
| _available_interfaces |
| return 0 |
| ;; |
| eth_type) |
| COMPREPLY+=( $( compgen -W 'ipv4 ipv6' -- "$cur" ) ) |
| return 0 |
| ;; |
| ip_proto) |
| COMPREPLY+=( $( compgen -W 'tcp udp' -- "$cur" ) ) |
| return 0 |
| ;; |
| |
| # Filters options options |
| key|keys) |
| [[ ${words[@]} =~ graft ]] && return 1 |
| COMPREPLY+=( $( compgen -W 'src dst proto proto-src proto-dst iif \ |
| priority mark nfct nfct-src nfct-dst nfct-proto-src \ |
| nfct-proto-dst rt-classid sk-uid sk-gid vlan-tag rxhash' -- \ |
| "$cur" ) ) |
| return 0 |
| ;; |
| |
| # BPF options - used for filters, actions, and exec |
| export|bytecode|bytecode-file|object-file) |
| _filedir |
| return 0 |
| ;; |
| object-pinned|graft) # Pinned object is probably under /sys/fs/bpf/ |
| [[ -n "$cur" ]] && _filedir && return 0 |
| COMPREPLY=( $( compgen -G "/sys/fs/bpf/*" -- "$cur" ) ) || _filedir |
| compopt -o nospace |
| return 0 |
| ;; |
| section) |
| if (type objdump > /dev/null 2>&1) ; then |
| local fword objfile section_list |
| for (( fword=3; fword < ${#words[@]}-3; fword++ )); do |
| if [[ ${words[fword]} == object-file ]]; then |
| objfile=${words[fword+1]} |
| break |
| fi |
| done |
| section_list=$( objdump -h $objfile 2>/dev/null | \ |
| sed -n 's/^ *[0-9]\+ \([^ ]*\) *.*/\1/p' ) |
| COMPREPLY+=( $( compgen -W "$section_list" -- "$cur" ) ) |
| fi |
| return 0 |
| ;; |
| import|run) |
| _filedir |
| return 0 |
| ;; |
| type) |
| COMPREPLY+=( $( compgen -W 'cls act' -- "$cur" ) ) |
| return 0 |
| ;; |
| |
| # Actions options |
| random) |
| _tc_one_of_list 'netrand determ' |
| return 0 |
| ;; |
| |
| # Units for option arguments |
| bandwidth|maxrate|peakrate|rate) |
| local list=$( _tc_expand_units 'bit' \ |
| 'kbit' 'kibit' 'kbps' 'kibps' \ |
| 'mbit' 'mibit' 'mbps' 'mibps' \ |
| 'gbit' 'gibit' 'gbps' 'gibps' \ |
| 'tbit' 'tibit' 'tbps' 'tibps' ) |
| COMPREPLY+=( $( compgen -W "$list" -- "$cur" ) ) |
| ;; |
| admit_bytes|avpkt|burst|cell|initial_quantum|limit|max|min|mtu|mpu|\ |
| overhead|quantum|redflowlist) |
| local list=$( _tc_expand_units \ |
| 'b' 'kbit' 'k' 'mbit' 'm' 'gbit' 'g' ) |
| COMPREPLY+=( $( compgen -W "$list" -- "$cur" ) ) |
| ;; |
| db|delay|evict_timeout|interval|latency|perturb|rehash|reset_timeout|\ |
| target|tupdate) |
| local list=$( _tc_expand_units 'secs' 'msecs' 'usecs' ) |
| COMPREPLY+=( $( compgen -W "$list" -- "$cur" ) ) |
| ;; |
| esac |
| return 1 |
| } |
| |
| # Complete with options names for qdiscs. Each qdisc has its own set of options |
| # and it seems we cannot really parse it from anywhere, so we add it manually |
| # in this function. |
| # Returns 0 is completion should stop after running this function, 1 otherwise. |
| _tc_qdisc_options() |
| { |
| case $1 in |
| choke) |
| _tc_once_attr 'limit bandwidth ecn min max burst' |
| return 0 |
| ;; |
| codel) |
| _tc_once_attr 'limit target interval' |
| _tc_one_of_list 'ecn noecn' |
| return 0 |
| ;; |
| bfifo|pfifo|pfifo_head_drop) |
| _tc_once_attr 'limit' |
| return 0 |
| ;; |
| fq) |
| _tc_once_attr 'limit flow_limit quantum initial_quantum maxrate \ |
| buckets' |
| _tc_one_of_list 'pacing nopacing' |
| return 0 |
| ;; |
| fq_codel) |
| _tc_once_attr 'limit flows target interval quantum' |
| _tc_one_of_list 'ecn noecn' |
| return 0 |
| ;; |
| gred) |
| _tc_once_attr 'setup vqs default grio vq prio limit min max avpkt \ |
| burst probability bandwidth ecn harddrop' |
| return 0 |
| ;; |
| hhf) |
| _tc_once_attr 'limit quantum hh_limit reset_timeout admit_bytes \ |
| evict_timeout non_hh_weight' |
| return 0 |
| ;; |
| mqprio) |
| _tc_once_attr 'num_tc map queues hw' |
| return 0 |
| ;; |
| netem) |
| _tc_once_attr 'delay distribution corrupt duplicate loss ecn \ |
| reorder rate' |
| return 0 |
| ;; |
| pie) |
| _tc_once_attr 'limit target tupdate alpha beta' |
| _tc_one_of_list 'bytemode nobytemode' |
| _tc_one_of_list 'ecn noecn' |
| _tc_one_of_list 'dq_rate_estimator no_dq_rate_estimator' |
| return 0 |
| ;; |
| fq_pie) |
| _tc_once_attr 'limit flows target tupdate \ |
| alpha beta quantum memory_limit ecn_prob' |
| _tc_one_of_list 'ecn noecn' |
| _tc_one_of_list 'bytemode nobytemode' |
| _tc_one_of_list 'dq_rate_estimator no_dq_rate_estimator' |
| return 0 |
| ;; |
| red) |
| _tc_once_attr 'limit min max avpkt burst adaptive probability \ |
| bandwidth ecn harddrop' |
| return 0 |
| ;; |
| rr|prio) |
| _tc_once_attr 'bands priomap multiqueue' |
| return 0 |
| ;; |
| sfb) |
| _tc_once_attr 'rehash db limit max target increment decrement \ |
| penalty_rate penalty_burst' |
| return 0 |
| ;; |
| sfq) |
| _tc_once_attr 'limit perturb quantum divisor flows depth headdrop \ |
| redflowlimit min max avpkt burst probability ecn harddrop' |
| return 0 |
| ;; |
| tbf) |
| _tc_once_attr 'limit burst rate mtu peakrate latency overhead \ |
| linklayer' |
| return 0 |
| ;; |
| cbq) |
| _tc_once_attr 'bandwidth avpkt mpu cell ewma' |
| return 0 |
| ;; |
| dsmark) |
| _tc_once_attr 'indices default_index set_tc_index' |
| return 0 |
| ;; |
| hfsc) |
| _tc_once_attr 'default' |
| return 0 |
| ;; |
| htb) |
| _tc_once_attr 'default r2q direct_qlen debug' |
| return 0 |
| ;; |
| multiq|pfifo_fast|atm|drr|qfq) |
| return 0 |
| ;; |
| esac |
| return 1 |
| } |
| |
| # Complete with options names for BPF filters or actions. |
| # Returns 0 is completion should stop after running this function, 1 otherwise. |
| _tc_bpf_options() |
| { |
| [[ ${words[${#words[@]}-3]} == object-file ]] && \ |
| _tc_once_attr 'section export' |
| [[ ${words[${#words[@]}-5]} == object-file ]] && \ |
| [[ ${words[${#words[@]}-3]} =~ (section|export) ]] && \ |
| _tc_once_attr 'section export' |
| _tc_one_of_list 'bytecode bytecode-file object-file object-pinned' |
| _tc_once_attr 'verbose index direct-action action classid' |
| return 0 |
| } |
| |
| # Complete with options names for filter actions. |
| # This function is recursive, thus allowing multiple actions statement to be |
| # parsed. |
| # Returns 0 is completion should stop after running this function, 1 otherwise. |
| _tc_filter_action_options() |
| { |
| for ((acwd=$1; acwd < ${#words[@]}-1; acwd++)); |
| do |
| if [[ action == ${words[acwd]} ]]; then |
| _tc_filter_action_options $((acwd+1)) && return 0 |
| fi |
| done |
| |
| local action acwd |
| for ((acwd=$1; acwd < ${#words[@]}-1; acwd++)); do |
| if [[ $ACTION_KIND =~ ' '${words[acwd]}' ' ]]; then |
| _tc_one_of_list_from $acwd action |
| _tc_action_options $acwd && return 0 |
| fi |
| done |
| _tc_one_of_list_from $acwd $ACTION_KIND |
| return 0 |
| } |
| |
| # Complete with options names for filters. |
| # Returns 0 is completion should stop after running this function, 1 otherwise. |
| _tc_filter_options() |
| { |
| |
| for ((acwd=$1; acwd < ${#words[@]}-1; acwd++)); |
| do |
| if [[ action == ${words[acwd]} ]]; then |
| _tc_filter_action_options $((acwd+1)) && return 0 |
| fi |
| done |
| |
| filter=${words[$1]} |
| case $filter in |
| basic) |
| _tc_once_attr 'match action classid' |
| return 0 |
| ;; |
| bpf) |
| _tc_bpf_options |
| return 0 |
| ;; |
| cgroup) |
| _tc_once_attr 'match action' |
| return 0 |
| ;; |
| flow) |
| local i |
| for (( i=5; i < ${#words[@]}-1; i++ )); do |
| if [[ ${words[i]} =~ ^keys?$ ]]; then |
| _tc_direct_complete 'key' |
| COMPREPLY+=( $( compgen -W 'or and xor rshift addend' -- \ |
| "$cur" ) ) |
| break |
| fi |
| done |
| _tc_once_attr 'map hash divisor baseclass match action' |
| return 0 |
| ;; |
| matchall) |
| _tc_once_attr 'action classid skip_sw skip_hw' |
| return 0 |
| ;; |
| flower) |
| _tc_once_attr 'action classid indev dst_mac src_mac eth_type \ |
| ip_proto dst_ip src_ip dst_port src_port' |
| return 0 |
| ;; |
| fw) |
| _tc_once_attr 'action classid' |
| return 0 |
| ;; |
| route) |
| _tc_one_of_list 'from fromif' |
| _tc_once_attr 'to classid action' |
| return 0 |
| ;; |
| rsvp) |
| _tc_once_attr 'ipproto session sender classid action tunnelid \ |
| tunnel flowlabel spi/ah spi/esp u8 u16 u32' |
| [[ ${words[${#words[@]}-3]} == tunnel ]] && \ |
| COMPREPLY+=( $( compgen -W 'skip' -- "$cur" ) ) |
| [[ ${words[${#words[@]}-3]} =~ u(8|16|32) ]] && \ |
| COMPREPLY+=( $( compgen -W 'mask' -- "$cur" ) ) |
| [[ ${words[${#words[@]}-3]} == mask ]] && \ |
| COMPREPLY+=( $( compgen -W 'at' -- "$cur" ) ) |
| return 0 |
| ;; |
| tcindex) |
| _tc_once_attr 'hash mask shift classid action' |
| _tc_one_of_list 'pass_on fall_through' |
| return 0 |
| ;; |
| u32) |
| _tc_once_attr 'match link classid action offset ht hashkey sample' |
| COMPREPLY+=( $( compgen -W 'ip ip6 udp tcp icmp u8 u16 u32 mark \ |
| divisor' -- "$cur" ) ) |
| return 0 |
| ;; |
| esac |
| return 1 |
| } |
| |
| # Complete with options names for actions. |
| # Returns 0 is completion should stop after running this function, 1 otherwise. |
| _tc_action_options() |
| { |
| local from=$1 |
| local action=${words[from]} |
| case $action in |
| bpf) |
| _tc_bpf_options |
| return 0 |
| ;; |
| mirred) |
| _tc_one_of_list_from $from 'ingress egress' |
| _tc_one_of_list_from $from 'mirror redirect' |
| _tc_once_attr_from $from 'index dev' |
| return 0 |
| ;; |
| sample) |
| _tc_once_attr_from $from 'rate' |
| _tc_once_attr_from $from 'trunc' |
| _tc_once_attr_from $from 'group' |
| return 0 |
| ;; |
| gact) |
| _tc_one_of_list_from $from 'reclassify drop continue pass' |
| _tc_once_attr_from $from 'random' |
| return 0 |
| ;; |
| esac |
| return 1 |
| } |
| |
| # Complete with options names for exec. |
| # Returns 0 is completion should stop after running this function, 1 otherwise. |
| _tc_exec_options() |
| { |
| case $1 in |
| import) |
| [[ ${words[${#words[@]}-3]} == import ]] && \ |
| _tc_once_attr 'run' |
| return 0 |
| ;; |
| graft) |
| COMPREPLY+=( $( compgen -W 'key type' -- "$cur" ) ) |
| [[ ${words[${#words[@]}-3]} == object-file ]] && \ |
| _tc_once_attr 'type' |
| _tc_bpf_options |
| return 0 |
| ;; |
| esac |
| return 1 |
| } |
| |
| # Main completion function |
| # Logic is as follows: |
| # 1. Check if previous word is a global option; if so, propose arguments. |
| # 2. Check if current word is a global option; if so, propose completion. |
| # 3. Check for the presence of a main command (qdisc|class|filter|...). If |
| # there is one, first call _tc_direct_complete to see if previous word is |
| # waiting for a particular completion. If so, propose completion and exit. |
| # 4. Extract main command and -- if available -- its subcommand |
| # (add|delete|show|...). |
| # 5. Propose completion based on main and sub- command in use. Additional |
| # functions may be called for qdiscs, classes or filter options. |
| _tc() |
| { |
| local cur prev words cword |
| _init_completion || return |
| |
| case $prev in |
| -V|-Version) |
| return 0 |
| ;; |
| -b|-batch|-cf|-conf) |
| _filedir |
| return 0 |
| ;; |
| -force) |
| COMPREPLY=( $( compgen -W '-batch' -- "$cur" ) ) |
| return 0 |
| ;; |
| -nm|name) |
| [[ -r /etc/iproute2/tc_cls ]] || \ |
| COMPREPLY=( $( compgen -W '-conf' -- "$cur" ) ) |
| return 0 |
| ;; |
| -n|-net|-netns) |
| local nslist=$( ip netns list 2>/dev/null ) |
| COMPREPLY+=( $( compgen -W "$nslist" -- "$cur" ) ) |
| return 0 |
| ;; |
| -tshort) |
| _tc_once_attr '-statistics' |
| COMPREPLY+=( $( compgen -W 'monitor' -- "$cur" ) ) |
| return 0 |
| ;; |
| -timestamp) |
| _tc_once_attr '-statistics -tshort' |
| COMPREPLY+=( $( compgen -W 'monitor' -- "$cur" ) ) |
| return 0 |
| ;; |
| esac |
| |
| # Search for main commands |
| local subcword cmd subcmd |
| for (( subcword=1; subcword < ${#words[@]}-1; subcword++ )); do |
| [[ ${words[subcword]} == -b?(atch) ]] && return 0 |
| [[ -n $cmd ]] && subcmd=${words[subcword]} && break |
| [[ ${words[subcword]} != -* && \ |
| ${words[subcword-1]} != -@(n?(et?(ns))|c?(on)f) ]] && \ |
| cmd=${words[subcword]} |
| done |
| |
| if [[ -z $cmd ]]; then |
| case $cur in |
| -*) |
| local c='-Version -statistics -details -raw -pretty \ |
| -iec -graphe -batch -name -netns -timestamp' |
| [[ $cword -eq 1 ]] && c+=' -force' |
| COMPREPLY=( $( compgen -W "$c" -- "$cur" ) ) |
| return 0 |
| ;; |
| *) |
| COMPREPLY=( $( compgen -W "help $( tc help 2>&1 | \ |
| command sed \ |
| -e '/OBJECT := /!d' \ |
| -e 's/.*{//' \ |
| -e 's/}.*//' \ |
| -e \ 's/|//g' )" -- "$cur" ) ) |
| return 0 |
| ;; |
| esac |
| fi |
| |
| [[ $subcmd == help ]] && return 0 |
| |
| # For this set of commands we may create COMPREPLY just by analysing the |
| # previous word, if it expects for a specific list of options or values. |
| if [[ $cmd =~ (qdisc|class|filter|action|exec) ]]; then |
| _tc_direct_complete $prev && return 0 |
| if [[ ${words[${#words[@]}-3]} == estimator ]]; then |
| local list=$( _tc_expand_units 'secs' 'msecs' 'usecs' ) |
| COMPREPLY+=( $( compgen -W "$list" -- "$cur" ) ) && return 0 |
| fi |
| fi |
| |
| # Completion depends on main command and subcommand in use. |
| case $cmd in |
| qdisc) |
| case $subcmd in |
| add|change|replace|link|del|delete) |
| if [[ $(($cword-$subcword)) -eq 1 ]]; then |
| COMPREPLY=( $( compgen -W 'dev' -- "$cur" ) ) |
| return 0 |
| fi |
| local qdisc qdwd |
| for ((qdwd=$subcword; qdwd < ${#words[@]}-1; qdwd++)); do |
| if [[ $QDISC_KIND =~ ' '${words[qdwd]}' ' ]]; then |
| qdisc=${words[qdwd]} |
| _tc_qdisc_options $qdisc && return 0 |
| fi |
| done |
| _tc_one_of_list $QDISC_KIND |
| _tc_one_of_list 'root ingress parent clsact' |
| _tc_once_attr 'handle estimator stab' |
| ;; |
| show) |
| _tc_once_attr 'dev' |
| _tc_one_of_list 'ingress clsact' |
| _tc_once_attr '-statistics -details -raw -pretty -iec \ |
| -graph -name' |
| ;; |
| help) |
| return 0 |
| ;; |
| *) |
| [[ $cword -eq $subcword ]] && \ |
| COMPREPLY=( $( compgen -W 'help add delete change \ |
| replace link show' -- "$cur" ) ) |
| ;; |
| esac |
| ;; |
| |
| class) |
| case $subcmd in |
| add|change|replace|del|delete) |
| if [[ $(($cword-$subcword)) -eq 1 ]]; then |
| COMPREPLY=( $( compgen -W 'dev' -- "$cur" ) ) |
| return 0 |
| fi |
| local qdisc qdwd |
| for ((qdwd=$subcword; qdwd < ${#words[@]}-1; qdwd++)); do |
| if [[ $QDISC_KIND =~ ' '${words[qdwd]}' ' ]]; then |
| qdisc=${words[qdwd]} |
| _tc_qdisc_options $qdisc && return 0 |
| fi |
| done |
| _tc_one_of_list $QDISC_KIND |
| _tc_one_of_list 'root parent' |
| _tc_once_attr 'classid' |
| ;; |
| show) |
| _tc_once_attr 'dev' |
| _tc_one_of_list 'root parent' |
| _tc_once_attr '-statistics -details -raw -pretty -iec \ |
| -graph -name' |
| ;; |
| help) |
| return 0 |
| ;; |
| *) |
| [[ $cword -eq $subcword ]] && \ |
| COMPREPLY=( $( compgen -W 'help add delete change \ |
| replace show' -- "$cur" ) ) |
| ;; |
| esac |
| ;; |
| |
| filter) |
| case $subcmd in |
| add|change|replace|del|delete) |
| if [[ $(($cword-$subcword)) -eq 1 ]]; then |
| COMPREPLY=( $( compgen -W 'dev' -- "$cur" ) ) |
| return 0 |
| fi |
| local filter fltwd |
| for ((fltwd=$subcword; fltwd < ${#words[@]}-1; fltwd++)); |
| do |
| if [[ $FILTER_KIND =~ ' '${words[fltwd]}' ' ]]; then |
| _tc_filter_options $fltwd && return 0 |
| fi |
| done |
| _tc_one_of_list $FILTER_KIND |
| _tc_one_of_list 'root ingress egress parent' |
| _tc_once_attr 'handle estimator pref protocol' |
| ;; |
| show) |
| _tc_once_attr 'dev' |
| _tc_one_of_list 'root ingress egress parent' |
| _tc_once_attr '-statistics -details -raw -pretty -iec \ |
| -graph -name' |
| ;; |
| help) |
| return 0 |
| ;; |
| *) |
| [[ $cword -eq $subcword ]] && \ |
| COMPREPLY=( $( compgen -W 'help add delete change \ |
| replace show' -- "$cur" ) ) |
| ;; |
| esac |
| ;; |
| |
| action) |
| case $subcmd in |
| add|change|replace) |
| local action acwd |
| for ((acwd=$subcword; acwd < ${#words[@]}-1; acwd++)); do |
| if [[ $ACTION_KIND =~ ' '${words[acwd]}' ' ]]; then |
| _tc_action_options $acwd && return 0 |
| fi |
| done |
| _tc_one_of_list $ACTION_KIND |
| ;; |
| get|del|delete) |
| _tc_once_attr 'index' |
| ;; |
| lst|list|flush|show) |
| _tc_one_of_list $ACTION_KIND |
| ;; |
| *) |
| [[ $cword -eq $subcword ]] && \ |
| COMPREPLY=( $( compgen -W 'help add delete change \ |
| replace show list flush action' -- "$cur" ) ) |
| ;; |
| esac |
| ;; |
| |
| monitor) |
| COMPREPLY=( $( compgen -W 'help' -- "$cur" ) ) |
| ;; |
| |
| exec) |
| case $subcmd in |
| bpf) |
| local excmd exwd EXEC_KIND=' import debug graft ' |
| for ((exwd=$subcword; exwd < ${#words[@]}-1; exwd++)); do |
| if [[ $EXEC_KIND =~ ' '${words[exwd]}' ' ]]; then |
| excmd=${words[exwd]} |
| _tc_exec_options $excmd && return 0 |
| fi |
| done |
| _tc_one_of_list $EXEC_KIND |
| ;; |
| *) |
| [[ $cword -eq $subcword ]] && \ |
| COMPREPLY=( $( compgen -W 'bpf' -- "$cur" ) ) |
| ;; |
| esac |
| ;; |
| esac |
| } && |
| complete -F _tc tc |
| |
| # ex: ts=4 sw=4 et filetype=sh |
