linux/tools/bpf/bpftool/bash-completion/bpftool

# bpftool(8) bash completion                               -*- shell-script -*-
#
# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
# Copyright (C) 2017-2018 Netronome Systems, Inc.
#
# Author: Quentin Monnet <quentin.monnet@netronome.com>

# 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.
_bpftool_once_attr()
{
    local w idx found
    for w in $*; do
        found=0
        for (( idx=3; idx < ${#words[@]}-1; idx++ )); do
            if [[ $w == ${words[idx]} ]]; then
                found=1
                break
            fi
        done
        [[ $found -eq 0 ]] && \
            COMPREPLY+=( $( compgen -W "$w" -- "$cur" ) )
    done
}

# Takes a list of words as argument; if any of those words is present on the
# command line, return 0. Otherwise, return 1.
_bpftool_search_list()
{
    local w idx
    for w in $*; do
        for (( idx=3; idx < ${#words[@]}-1; idx++ )); do
            [[ $w == ${words[idx]} ]] && return 0
        done
    done
    return 1
}

# 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.
_bpftool_one_of_list()
{
    _bpftool_search_list $* && return 1
    COMPREPLY+=( $( compgen -W "$*" -- "$cur" ) )
}

_bpftool_get_map_ids()
{
    COMPREPLY+=( $( compgen -W "$( bpftool -jp map  2>&1 | \
        command sed -n 's/.*"id": \(.*\),$/\1/p' )" -- "$cur" ) )
}

# Takes map type and adds matching map ids to the list of suggestions.
_bpftool_get_map_ids_for_type()
{
    local type="$1"
    COMPREPLY+=( $( compgen -W "$( bpftool -jp map  2>&1 | \
        command grep -C2 "$type" | \
        command sed -n 's/.*"id": \(.*\),$/\1/p' )" -- "$cur" ) )
}

_bpftool_get_map_names()
{
    COMPREPLY+=( $( compgen -W "$( bpftool -jp map  2>&1 | \
        command sed -n 's/.*"name": \(.*\),$/\1/p' )" -- "$cur" ) )
}

# Takes map type and adds matching map names to the list of suggestions.
_bpftool_get_map_names_for_type()
{
    local type="$1"
    COMPREPLY+=( $( compgen -W "$( bpftool -jp map  2>&1 | \
        command grep -C2 "$type" | \
        command sed -n 's/.*"name": \(.*\),$/\1/p' )" -- "$cur" ) )
}

_bpftool_get_prog_ids()
{
    COMPREPLY+=( $( compgen -W "$( bpftool -jp prog 2>&1 | \
        command sed -n 's/.*"id": \(.*\),$/\1/p' )" -- "$cur" ) )
}

_bpftool_get_prog_tags()
{
    COMPREPLY+=( $( compgen -W "$( bpftool -jp prog 2>&1 | \
        command sed -n 's/.*"tag": "\(.*\)",$/\1/p' )" -- "$cur" ) )
}

_bpftool_get_prog_names()
{
    COMPREPLY+=( $( compgen -W "$( bpftool -jp prog 2>&1 | \
        command sed -n 's/.*"name": "\(.*\)",$/\1/p' )" -- "$cur" ) )
}

_bpftool_get_btf_ids()
{
    COMPREPLY+=( $( compgen -W "$( bpftool -jp btf 2>&1 | \
        command sed -n 's/.*"id": \(.*\),$/\1/p' )" -- "$cur" ) )
}

_bpftool_get_link_ids()
{
    COMPREPLY+=( $( compgen -W "$( bpftool -jp link 2>&1 | \
        command sed -n 's/.*"id": \(.*\),$/\1/p' )" -- "$cur" ) )
}

_bpftool_get_obj_map_names()
{
    local obj

    obj=$1

    maps=$(objdump -j maps -t $obj 2>/dev/null | \
        command awk '/g     . maps/ {print $NF}')

    COMPREPLY+=( $( compgen -W "$maps" -- "$cur" ) )
}

_bpftool_get_obj_map_idxs()
{
    local obj

    obj=$1

    nmaps=$(objdump -j maps -t $obj 2>/dev/null | grep -c 'g     . maps')

    COMPREPLY+=( $( compgen -W "$(seq 0 $((nmaps - 1)))" -- "$cur" ) )
}

_sysfs_get_netdevs()
{
    COMPREPLY+=( $( compgen -W "$( ls /sys/class/net 2>/dev/null )" -- \
        "$cur" ) )
}

# Retrieve type of the map that we are operating on.
_bpftool_map_guess_map_type()
{
    local keyword ref
    for (( idx=3; idx < ${#words[@]}-1; idx++ )); do
        case "${words[$((idx-2))]}" in
            lookup|update)
                keyword=${words[$((idx-1))]}
                ref=${words[$((idx))]}
                ;;
            push)
                printf "stack"
                return 0
                ;;
            enqueue)
                printf "queue"
                return 0
                ;;
        esac
    done
    [[ -z $ref ]] && return 0

    local type
    type=$(bpftool -jp map show $keyword $ref | \
        command sed -n 's/.*"type": "\(.*\)",$/\1/p')
    [[ -n $type ]] && printf $type
}

_bpftool_map_update_get_id()
{
    local command="$1"

    # Is it the map to update, or a map to insert into the map to update?
    # Search for "value" keyword.
    local idx value
    for (( idx=7; idx < ${#words[@]}-1; idx++ )); do
        if [[ ${words[idx]} == "value" ]]; then
            value=1
            break
        fi
    done
    if [[ $value -eq 0 ]]; then
        case "$command" in
            push)
                _bpftool_get_map_ids_for_type stack
                ;;
            enqueue)
                _bpftool_get_map_ids_for_type queue
                ;;
            *)
                _bpftool_get_map_ids
                ;;
        esac
        return 0
    fi

    # Id to complete is for a value. It can be either prog id or map id. This
    # depends on the type of the map to update.
    local type=$(_bpftool_map_guess_map_type)
    case $type in
        array_of_maps|hash_of_maps)
            _bpftool_get_map_ids
            return 0
            ;;
        prog_array)
            _bpftool_get_prog_ids
            return 0
            ;;
        *)
            return 0
            ;;
    esac
}

_bpftool_map_update_get_name()
{
    local command="$1"

    # Is it the map to update, or a map to insert into the map to update?
    # Search for "value" keyword.
    local idx value
    for (( idx=7; idx < ${#words[@]}-1; idx++ )); do
        if [[ ${words[idx]} == "value" ]]; then
            value=1
            break
        fi
    done
    if [[ $value -eq 0 ]]; then
        case "$command" in
            push)
                _bpftool_get_map_names_for_type stack
                ;;
            enqueue)
                _bpftool_get_map_names_for_type queue
                ;;
            *)
                _bpftool_get_map_names
                ;;
        esac
        return 0
    fi

    # Name to complete is for a value. It can be either prog name or map name. This
    # depends on the type of the map to update.
    local type=$(_bpftool_map_guess_map_type)
    case $type in
        array_of_maps|hash_of_maps)
            _bpftool_get_map_names
            return 0
            ;;
        prog_array)
            _bpftool_get_prog_names
            return 0
            ;;
        *)
            return 0
            ;;
    esac
}

_bpftool()
{
    local cur prev words objword
    _init_completion || return

    # Deal with options
    if [[ ${words[cword]} == -* ]]; then
        local c='--version --json --pretty --bpffs --mapcompat --debug \
	       --use-loader --base-btf --legacy'
        COMPREPLY=( $( compgen -W "$c" -- "$cur" ) )
        return 0
    fi

    # Deal with simplest keywords
    case $prev in
        help|hex|opcodes|visual|linum)
            return 0
            ;;
        tag)
            _bpftool_get_prog_tags
            return 0
            ;;
        dev)
            _sysfs_get_netdevs
            return 0
            ;;
        file|pinned|-B|--base-btf)
            _filedir
            return 0
            ;;
        batch)
            COMPREPLY=( $( compgen -W 'file' -- "$cur" ) )
            return 0
            ;;
    esac

    # Remove all options so completions don't have to deal with them.
    local i
    for (( i=1; i < ${#words[@]}; )); do
        if [[ ${words[i]::1} == - ]] &&
            [[ ${words[i]} != "-B" ]] && [[ ${words[i]} != "--base-btf" ]]; then
            words=( "${words[@]:0:i}" "${words[@]:i+1}" )
            [[ $i -le $cword ]] && cword=$(( cword - 1 ))
        else
            i=$(( ++i ))
        fi
    done
    cur=${words[cword]}
    prev=${words[cword - 1]}
    pprev=${words[cword - 2]}

    local object=${words[1]} command=${words[2]}

    if [[ -z $object || $cword -eq 1 ]]; then
        case $cur in
            *)
                COMPREPLY=( $( compgen -W "$( bpftool help 2>&1 | \
                    command sed \
                    -e '/OBJECT := /!d' \
                    -e 's/.*{//' \
                    -e 's/}.*//' \
                    -e 's/|//g' )" -- "$cur" ) )
                COMPREPLY+=( $( compgen -W 'batch help' -- "$cur" ) )
                return 0
                ;;
        esac
    fi

    [[ $command == help ]] && return 0

    # Completion depends on object and command in use
    case $object in
        prog)
            # Complete id and name, only for subcommands that use prog (but no
            # map) ids/names.
            case $command in
                show|list|dump|pin)
                    case $prev in
                        id)
                            _bpftool_get_prog_ids
                            return 0
                            ;;
                        name)
                            _bpftool_get_prog_names
                            return 0
                            ;;
                    esac
                    ;;
            esac

            local PROG_TYPE='id pinned tag name'
            local MAP_TYPE='id pinned name'
            local METRIC_TYPE='cycles instructions l1d_loads llc_misses \
                itlb_misses dtlb_misses'
            case $command in
                show|list)
                    [[ $prev != "$command" ]] && return 0
                    COMPREPLY=( $( compgen -W "$PROG_TYPE" -- "$cur" ) )
                    return 0
                    ;;
                dump)
                    case $prev in
                        $command)
                            COMPREPLY+=( $( compgen -W "xlated jited" -- \
                                "$cur" ) )
                            return 0
                            ;;
                        xlated|jited)
                            COMPREPLY=( $( compgen -W "$PROG_TYPE" -- \
                                "$cur" ) )
                            return 0
                            ;;
                        *)
                            _bpftool_once_attr 'file'
                            if _bpftool_search_list 'xlated'; then
                                COMPREPLY+=( $( compgen -W 'opcodes visual linum' -- \
                                    "$cur" ) )
                            else
                                COMPREPLY+=( $( compgen -W 'opcodes linum' -- \
                                    "$cur" ) )
                            fi
                            return 0
                            ;;
                    esac
                    ;;
                pin)
                    if [[ $prev == "$command" ]]; then
                        COMPREPLY=( $( compgen -W "$PROG_TYPE" -- "$cur" ) )
                    else
                        _filedir
                    fi
                    return 0
                    ;;
                attach|detach)
                    case $cword in
                        3)
                            COMPREPLY=( $( compgen -W "$PROG_TYPE" -- "$cur" ) )
                            return 0
                            ;;
                        4)
                            case $prev in
                                id)
                                    _bpftool_get_prog_ids
                                    ;;
                                name)
                                    _bpftool_get_prog_names
                                    ;;
                                pinned)
                                    _filedir
                                    ;;
                            esac
                            return 0
                            ;;
                        5)
                            local BPFTOOL_PROG_ATTACH_TYPES='sk_msg_verdict \
                                sk_skb_verdict sk_skb_stream_verdict sk_skb_stream_parser \
                                flow_dissector'
                            COMPREPLY=( $( compgen -W "$BPFTOOL_PROG_ATTACH_TYPES" -- "$cur" ) )
                            return 0
                            ;;
                        6)
                            COMPREPLY=( $( compgen -W "$MAP_TYPE" -- "$cur" ) )
                            return 0
                            ;;
                        7)
                            case $prev in
                                id)
                                    _bpftool_get_map_ids
                                    ;;
                                name)
                                    _bpftool_get_map_names
                                    ;;
                                pinned)
                                    _filedir
                                    ;;
                            esac
                            return 0
                            ;;
                    esac
                    ;;
                load|loadall)
                    local obj

                    # Propose "load/loadall" to complete "bpftool prog load",
                    # or bash tries to complete "load" as a filename below.
                    if [[ ${#words[@]} -eq 3 ]]; then
                        COMPREPLY=( $( compgen -W "load loadall" -- "$cur" ) )
                        return 0
                    fi

                    if [[ ${#words[@]} -lt 6 ]]; then
                        _filedir
                        return 0
                    fi

                    obj=${words[3]}

                    if [[ ${words[-4]} == "map" ]]; then
                        COMPREPLY=( $( compgen -W "id pinned" -- "$cur" ) )
                        return 0
                    fi
                    if [[ ${words[-3]} == "map" ]]; then
                        if [[ ${words[-2]} == "idx" ]]; then
                            _bpftool_get_obj_map_idxs $obj
                        elif [[ ${words[-2]} == "name" ]]; then
                            _bpftool_get_obj_map_names $obj
                        fi
                        return 0
                    fi
                    if [[ ${words[-2]} == "map" ]]; then
                        COMPREPLY=( $( compgen -W "idx name" -- "$cur" ) )
                        return 0
                    fi

                    case $prev in
                        type)
                            local BPFTOOL_PROG_LOAD_TYPES='socket kprobe \
                                kretprobe classifier flow_dissector \
                                action tracepoint raw_tracepoint \
                                xdp perf_event cgroup/skb cgroup/sock \
                                cgroup/dev lwt_in lwt_out lwt_xmit \
                                lwt_seg6local sockops sk_skb sk_msg \
                                lirc_mode2 cgroup/bind4 cgroup/bind6 \
                                cgroup/connect4 cgroup/connect6 \
                                cgroup/getpeername4 cgroup/getpeername6 \
                                cgroup/getsockname4 cgroup/getsockname6 \
                                cgroup/sendmsg4 cgroup/sendmsg6 \
                                cgroup/recvmsg4 cgroup/recvmsg6 \
                                cgroup/post_bind4 cgroup/post_bind6 \
                                cgroup/sysctl cgroup/getsockopt \
                                cgroup/setsockopt cgroup/sock_release struct_ops \
                                fentry fexit freplace sk_lookup'
                            COMPREPLY=( $( compgen -W "$BPFTOOL_PROG_LOAD_TYPES" -- "$cur" ) )
                            return 0
                            ;;
                        id)
                            _bpftool_get_map_ids
                            return 0
                            ;;
                        name)
                            _bpftool_get_map_names
                            return 0
                            ;;
                        pinned|pinmaps)
                            _filedir
                            return 0
                            ;;
                        *)
                            COMPREPLY=( $( compgen -W "map" -- "$cur" ) )
                            _bpftool_once_attr 'type'
                            _bpftool_once_attr 'dev'
                            _bpftool_once_attr 'pinmaps'
                            return 0
                            ;;
                    esac
                    ;;
                tracelog)
                    return 0
                    ;;
                profile)
                    case $cword in
                        3)
                            COMPREPLY=( $( compgen -W "$PROG_TYPE" -- "$cur" ) )
                            return 0
                            ;;
                        4)
                            case $prev in
                                id)
                                    _bpftool_get_prog_ids
                                    ;;
                                name)
                                    _bpftool_get_prog_names
                                    ;;
                                pinned)
                                    _filedir
                                    ;;
                            esac
                            return 0
                            ;;
                        5)
                            COMPREPLY=( $( compgen -W "$METRIC_TYPE duration" -- "$cur" ) )
                            return 0
                            ;;
                        6)
                            case $prev in
                                duration)
                                    return 0
                                    ;;
                                *)
                                    COMPREPLY=( $( compgen -W "$METRIC_TYPE" -- "$cur" ) )
                                    return 0
                                    ;;
                            esac
                            return 0
                            ;;
                        *)
                            COMPREPLY=( $( compgen -W "$METRIC_TYPE" -- "$cur" ) )
                            return 0
                            ;;
                    esac
                    ;;
                run)
                    if [[ ${#words[@]} -eq 4 ]]; then
                        COMPREPLY=( $( compgen -W "$PROG_TYPE" -- "$cur" ) )
                        return 0
                    fi
                    case $prev in
                        id)
                            _bpftool_get_prog_ids
                            return 0
                            ;;
                        name)
                            _bpftool_get_prog_names
                            return 0
                            ;;
                        data_in|data_out|ctx_in|ctx_out)
                            _filedir
                            return 0
                            ;;
                        repeat|data_size_out|ctx_size_out)
                            return 0
                            ;;
                        *)
                            _bpftool_once_attr 'data_in data_out data_size_out \
                                ctx_in ctx_out ctx_size_out repeat'
                            return 0
                            ;;
                    esac
                    ;;
                *)
                    [[ $prev == $object ]] && \
                        COMPREPLY=( $( compgen -W 'dump help pin attach detach \
                            load loadall show list tracelog run profile' -- "$cur" ) )
                    ;;
            esac
            ;;
        struct_ops)
            local STRUCT_OPS_TYPE='id name'
            case $command in
                show|list|dump|unregister)
                    case $prev in
                        $command)
                            COMPREPLY=( $( compgen -W "$STRUCT_OPS_TYPE" -- "$cur" ) )
                            ;;
                        id)
                            _bpftool_get_map_ids_for_type struct_ops
                            ;;
                        name)
                            _bpftool_get_map_names_for_type struct_ops
                            ;;
                    esac
                    return 0
                    ;;
                register)
                    _filedir
                    return 0
                    ;;
                *)
                    [[ $prev == $object ]] && \
                        COMPREPLY=( $( compgen -W 'register unregister show list dump help' \
                            -- "$cur" ) )
                    ;;
            esac
            ;;
        iter)
            case $command in
                pin)
                    case $prev in
                        $command)
                            _filedir
                            ;;
                        id)
                            _bpftool_get_map_ids
                            ;;
                        name)
                            _bpftool_get_map_names
                            ;;
                        pinned)
                            _filedir
                            ;;
                        *)
                            _bpftool_one_of_list $MAP_TYPE
                            ;;
                    esac
                    return 0
                    ;;
                *)
                    [[ $prev == $object ]] && \
                        COMPREPLY=( $( compgen -W 'pin help' \
                            -- "$cur" ) )
                    ;;
            esac
            ;;
        map)
            local MAP_TYPE='id pinned name'
            case $command in
                show|list|dump|peek|pop|dequeue|freeze)
                    case $prev in
                        $command)
                            COMPREPLY=( $( compgen -W "$MAP_TYPE" -- "$cur" ) )
                            return 0
                            ;;
                        id)
                            case "$command" in
                                peek)
                                    _bpftool_get_map_ids_for_type stack
                                    _bpftool_get_map_ids_for_type queue
                                    ;;
                                pop)
                                    _bpftool_get_map_ids_for_type stack
                                    ;;
                                dequeue)
                                    _bpftool_get_map_ids_for_type queue
                                    ;;
                                *)
                                    _bpftool_get_map_ids
                                    ;;
                            esac
                            return 0
                            ;;
                        name)
                            case "$command" in
                                peek)
                                    _bpftool_get_map_names_for_type stack
                                    _bpftool_get_map_names_for_type queue
                                    ;;
                                pop)
                                    _bpftool_get_map_names_for_type stack
                                    ;;
                                dequeue)
                                    _bpftool_get_map_names_for_type queue
                                    ;;
                                *)
                                    _bpftool_get_map_names
                                    ;;
                            esac
                            return 0
                            ;;
                        *)
                            return 0
                            ;;
                    esac
                    ;;
                create)
                    case $prev in
                        $command)
                            _filedir
                            return 0
                            ;;
                        type)
                            local BPFTOOL_MAP_CREATE_TYPES="$(bpftool feature list_builtins map_types 2>/dev/null | \
                                grep -v '^unspec$')"
                            COMPREPLY=( $( compgen -W "$BPFTOOL_MAP_CREATE_TYPES" -- "$cur" ) )
                            return 0
                            ;;
                        key|value|flags|entries)
                            return 0
                            ;;
                        inner_map)
                            COMPREPLY=( $( compgen -W "$MAP_TYPE" -- "$cur" ) )
                            return 0
                            ;;
                        id)
                            _bpftool_get_map_ids
                            ;;
                        name)
                            case $pprev in
                                inner_map)
                                    _bpftool_get_map_names
                                    ;;
                                *)
                                    return 0
                                    ;;
                            esac
                            ;;
                        *)
                            _bpftool_once_attr 'type'
                            _bpftool_once_attr 'key'
                            _bpftool_once_attr 'value'
                            _bpftool_once_attr 'entries'
                            _bpftool_once_attr 'name'
                            _bpftool_once_attr 'flags'
                            if _bpftool_search_list 'array_of_maps' 'hash_of_maps'; then
                                _bpftool_once_attr 'inner_map'
                            fi
                            _bpftool_once_attr 'dev'
                            return 0
                            ;;
                    esac
                    ;;
                lookup|getnext|delete)
                    case $prev in
                        $command)
                            COMPREPLY=( $( compgen -W "$MAP_TYPE" -- "$cur" ) )
                            return 0
                            ;;
                        id)
                            _bpftool_get_map_ids
                            return 0
                            ;;
                        name)
                            _bpftool_get_map_names
                            return 0
                            ;;
                        key)
                            COMPREPLY+=( $( compgen -W 'hex' -- "$cur" ) )
                            ;;
                        *)
                            case $(_bpftool_map_guess_map_type) in
                                queue|stack)
                                    return 0
                                    ;;
                            esac

                            _bpftool_once_attr 'key'
                            return 0
                            ;;
                    esac
                    ;;
                update|push|enqueue)
                    case $prev in
                        $command)
                            COMPREPLY=( $( compgen -W "$MAP_TYPE" -- "$cur" ) )
                            return 0
                            ;;
                        id)
                            _bpftool_map_update_get_id $command
                            return 0
                            ;;
                        name)
                            _bpftool_map_update_get_name $command
                            return 0
                            ;;
                        key)
                            COMPREPLY+=( $( compgen -W 'hex' -- "$cur" ) )
                            ;;
                        value)
                            # We can have bytes, or references to a prog or a
                            # map, depending on the type of the map to update.
                            case "$(_bpftool_map_guess_map_type)" in
                                array_of_maps|hash_of_maps)
                                    local MAP_TYPE='id pinned name'
                                    COMPREPLY+=( $( compgen -W "$MAP_TYPE" \
                                        -- "$cur" ) )
                                    return 0
                                    ;;
                                prog_array)
                                    local PROG_TYPE='id pinned tag name'
                                    COMPREPLY+=( $( compgen -W "$PROG_TYPE" \
                                        -- "$cur" ) )
                                    return 0
                                    ;;
                                *)
                                    COMPREPLY+=( $( compgen -W 'hex' \
                                        -- "$cur" ) )
                                    return 0
                                    ;;
                            esac
                            return 0
                            ;;
                        *)
                            case $(_bpftool_map_guess_map_type) in
                                queue|stack)
                                    _bpftool_once_attr 'value'
                                    return 0;
                                    ;;
                            esac

                            _bpftool_once_attr 'key'
                            local UPDATE_FLAGS='any exist noexist'
                            for (( idx=3; idx < ${#words[@]}-1; idx++ )); do
                                if [[ ${words[idx]} == 'value' ]]; then
                                    # 'value' is present, but is not the last
                                    # word i.e. we can now have UPDATE_FLAGS.
                                    _bpftool_one_of_list "$UPDATE_FLAGS"
                                    return 0
                                fi
                            done
                            for (( idx=3; idx < ${#words[@]}-1; idx++ )); do
                                if [[ ${words[idx]} == 'key' ]]; then
                                    # 'key' is present, but is not the last
                                    # word i.e. we can now have 'value'.
                                    _bpftool_once_attr 'value'
                                    return 0
                                fi
                            done

                            return 0
                            ;;
                    esac
                    ;;
                pin)
                    case $prev in
                        $command)
                            COMPREPLY=( $( compgen -W "$MAP_TYPE" -- "$cur" ) )
                            ;;
                        id)
                            _bpftool_get_map_ids
                            ;;
                        name)
                            _bpftool_get_map_names
                            ;;
                    esac
                    return 0
                    ;;
                event_pipe)
                    case $prev in
                        $command)
                            COMPREPLY=( $( compgen -W "$MAP_TYPE" -- "$cur" ) )
                            return 0
                            ;;
                        id)
                            _bpftool_get_map_ids_for_type perf_event_array
                            return 0
                            ;;
                        name)
                            _bpftool_get_map_names_for_type perf_event_array
                            return 0
                            ;;
                        cpu)
                            return 0
                            ;;
                        index)
                            return 0
                            ;;
                        *)
                            _bpftool_once_attr 'cpu'
                            _bpftool_once_attr 'index'
                            return 0
                            ;;
                    esac
                    ;;
                *)
                    [[ $prev == $object ]] && \
                        COMPREPLY=( $( compgen -W 'delete dump getnext help \
                            lookup pin event_pipe show list update create \
                            peek push enqueue pop dequeue freeze' -- \
                            "$cur" ) )
                    ;;
            esac
            ;;
        btf)
            local PROG_TYPE='id pinned tag name'
            local MAP_TYPE='id pinned name'
            case $command in
                dump)
                    case $prev in
                        $command)
                            COMPREPLY+=( $( compgen -W "id map prog file" -- \
                                "$cur" ) )
                            return 0
                            ;;
                        prog)
                            COMPREPLY=( $( compgen -W "$PROG_TYPE" -- "$cur" ) )
                            return 0
                            ;;
                        map)
                            COMPREPLY=( $( compgen -W "$MAP_TYPE" -- "$cur" ) )
                            return 0
                            ;;
                        id)
                            case $pprev in
                                prog)
                                    _bpftool_get_prog_ids
                                    ;;
                                map)
                                    _bpftool_get_map_ids
                                    ;;
                                $command)
                                    _bpftool_get_btf_ids
                                    ;;
                            esac
                            return 0
                            ;;
                        name)
                            case $pprev in
                                prog)
                                    _bpftool_get_prog_names
                                    ;;
                                map)
                                    _bpftool_get_map_names
                                    ;;
                            esac
                            return 0
                            ;;
                        format)
                            COMPREPLY=( $( compgen -W "c raw" -- "$cur" ) )
                            ;;
                        *)
                            # emit extra options
                            case ${words[3]} in
                                id|file)
                                    _bpftool_once_attr 'format'
                                    ;;
                                map|prog)
                                    if [[ ${words[3]} == "map" ]] && [[ $cword == 6 ]]; then
                                        COMPREPLY+=( $( compgen -W "key value kv all" -- "$cur" ) )
                                    fi
                                    _bpftool_once_attr 'format'
                                    ;;
                                *)
                                    ;;
                            esac
                            return 0
                            ;;
                    esac
                    ;;
                show|list)
                    case $prev in
                        $command)
                            COMPREPLY+=( $( compgen -W "id" -- "$cur" ) )
                            ;;
                        id)
                            _bpftool_get_btf_ids
                            ;;
                    esac
                    return 0
                    ;;
                *)
                    [[ $prev == $object ]] && \
                        COMPREPLY=( $( compgen -W 'dump help show list' \
                            -- "$cur" ) )
                    ;;
            esac
            ;;
        gen)
            case $command in
                object)
                    _filedir
                    return 0
                    ;;
                skeleton)
                    case $prev in
                        $command)
                            _filedir
                            return 0
                            ;;
                        *)
                            _bpftool_once_attr 'name'
                            return 0
                            ;;
                    esac
                    ;;
                subskeleton)
                    case $prev in
                        $command)
                            _filedir
                            return 0
                            ;;
                        *)
                            _bpftool_once_attr 'name'
                            return 0
                            ;;
                    esac
                    ;;
                min_core_btf)
                    _filedir
                    return 0
                    ;;
                *)
                    [[ $prev == $object ]] && \
                        COMPREPLY=( $( compgen -W 'object skeleton subskeleton help min_core_btf' -- "$cur" ) )
                    ;;
            esac
            ;;
        cgroup)
            case $command in
                show|list|tree)
                    case $cword in
                        3)
                            _filedir
                            ;;
                        4)
                            COMPREPLY=( $( compgen -W 'effective' -- "$cur" ) )
                            ;;
                    esac
                    return 0
                    ;;
                attach|detach)
                    local BPFTOOL_CGROUP_ATTACH_TYPES="$(bpftool feature list_builtins attach_types 2>/dev/null | \
                        grep '^cgroup_')"
                    local ATTACH_FLAGS='multi override'
                    local PROG_TYPE='id pinned tag name'
                    # Check for $prev = $command first
                    if [ $prev = $command ]; then
                        _filedir
                        return 0
                    # Then check for attach type. This is done outside of the
                    # "case $prev in" to avoid writing the whole list of attach
                    # types again as pattern to match (where we cannot reuse
                    # our variable).
                    elif [[ $BPFTOOL_CGROUP_ATTACH_TYPES =~ $prev ]]; then
                            COMPREPLY=( $( compgen -W "$PROG_TYPE" -- \
                                "$cur" ) )
                            return 0
                    fi
                    # case/esac for the other cases
                    case $prev in
                        id)
                            _bpftool_get_prog_ids
                            return 0
                            ;;
                        *)
                            if ! _bpftool_search_list "$BPFTOOL_CGROUP_ATTACH_TYPES"; then
                                COMPREPLY=( $( compgen -W \
                                    "$BPFTOOL_CGROUP_ATTACH_TYPES" -- "$cur" ) )
                            elif [[ "$command" == "attach" ]]; then
                                # We have an attach type on the command line,
                                # but it is not the previous word, or
                                # "id|pinned|tag|name" (we already checked for
                                # that). This should only leave the case when
                                # we need attach flags for "attach" commamnd.
                                _bpftool_one_of_list "$ATTACH_FLAGS"
                            fi
                            return 0
                            ;;
                    esac
                    ;;
                *)
                    [[ $prev == $object ]] && \
                        COMPREPLY=( $( compgen -W 'help attach detach \
                            show list tree' -- "$cur" ) )
                    ;;
            esac
            ;;
        perf)
            case $command in
                *)
                    [[ $prev == $object ]] && \
                        COMPREPLY=( $( compgen -W 'help \
                            show list' -- "$cur" ) )
                    ;;
            esac
            ;;
        net)
            local PROG_TYPE='id pinned tag name'
            local ATTACH_TYPES='xdp xdpgeneric xdpdrv xdpoffload'
            case $command in
                show|list)
                    [[ $prev != "$command" ]] && return 0
                    COMPREPLY=( $( compgen -W 'dev' -- "$cur" ) )
                    return 0
                    ;;
                attach)
                    case $cword in
                        3)
                            COMPREPLY=( $( compgen -W "$ATTACH_TYPES" -- "$cur" ) )
                            return 0
                            ;;
                        4)
                            COMPREPLY=( $( compgen -W "$PROG_TYPE" -- "$cur" ) )
                            return 0
                            ;;
                        5)
                            case $prev in
                                id)
                                    _bpftool_get_prog_ids
                                    ;;
                                name)
                                    _bpftool_get_prog_names
                                    ;;
                                pinned)
                                    _filedir
                                    ;;
                            esac
                            return 0
                            ;;
                        6)
                            COMPREPLY=( $( compgen -W 'dev' -- "$cur" ) )
                            return 0
                            ;;
                        8)
                            _bpftool_once_attr 'overwrite'
                            return 0
                            ;;
                    esac
                    ;;
                detach)
                    case $cword in
                        3)
                            COMPREPLY=( $( compgen -W "$ATTACH_TYPES" -- "$cur" ) )
                            return 0
                            ;;
                        4)
                            COMPREPLY=( $( compgen -W 'dev' -- "$cur" ) )
                            return 0
                            ;;
                    esac
                    ;;
                *)
                    [[ $prev == $object ]] && \
                        COMPREPLY=( $( compgen -W 'help \
                            show list attach detach' -- "$cur" ) )
                    ;;
            esac
            ;;
        feature)
            case $command in
                probe)
                    [[ $prev == "prefix" ]] && return 0
                    if _bpftool_search_list 'macros'; then
                        _bpftool_once_attr 'prefix'
                    else
                        COMPREPLY+=( $( compgen -W 'macros' -- "$cur" ) )
                    fi
                    _bpftool_one_of_list 'kernel dev'
                    _bpftool_once_attr 'full unprivileged'
                    return 0
                    ;;
                list_builtins)
                    [[ $prev != "$command" ]] && return 0
                    COMPREPLY=( $( compgen -W 'prog_types map_types \
                        attach_types link_types helpers' -- "$cur" ) )
                    ;;
                *)
                    [[ $prev == $object ]] && \
                        COMPREPLY=( $( compgen -W 'help list_builtins probe' -- "$cur" ) )
                    ;;
            esac
            ;;
        link)
            case $command in
                show|list|pin|detach)
                    case $prev in
                        id)
                            _bpftool_get_link_ids
                            return 0
                            ;;
                    esac
                    ;;
            esac

            local LINK_TYPE='id pinned'
            case $command in
                show|list)
                    [[ $prev != "$command" ]] && return 0
                    COMPREPLY=( $( compgen -W "$LINK_TYPE" -- "$cur" ) )
                    return 0
                    ;;
                pin|detach)
                    if [[ $prev == "$command" ]]; then
                        COMPREPLY=( $( compgen -W "$LINK_TYPE" -- "$cur" ) )
                    else
                        _filedir
                    fi
                    return 0
                    ;;
                *)
                    [[ $prev == $object ]] && \
                        COMPREPLY=( $( compgen -W 'help pin show list' -- "$cur" ) )
                    ;;
            esac
            ;;
    esac
} &&
complete -F _bpftool bpftool

# ex: ts=4 sw=4 et filetype=sh