File Manager

X7ROOT File Manager

Current Path: /usr/share/bash-completion/completions

usr / share / bash-completion / completions /

📁 ..
📄 2to3(918 B)
📄 7z(3.8 KB)
📄 7za(3.8 KB)
📄 _cal(886 B)
📄 _chfn(238 B)
📄 _chsh(646 B)
📄 _dmesg(940 B)
📄 _eject(799 B)
📄 _hexdump(702 B)
📄 _hwclock(609 B)
📄 _ionice(1.24 KB)
📄 _look(449 B)
📄 _mock(2.03 KB)
📄 _modules(2.49 KB)
📄 _newgrp(432 B)
📄 _nmcli(6.14 KB)
📄 _renice(772 B)
📄 _repomanage(610 B)
📄 _reptyr(551 B)
📄 _rfkill(937 B)
📄 _rtcwake(873 B)
📄 _runuser(241 B)
📄 _su(989 B)
📄 _svn(8.71 KB)
📄 _svnadmin(2.28 KB)
📄 _svnlook(1.95 KB)
📄 _udevadm(2.13 KB)
📄 _write(239 B)
📄 _yum(4.42 KB)
📄 a2x(898 B)
📄 abook(1.19 KB)
📄 aclocal(850 B)
📄 aclocal-1.10(850 B)
📄 aclocal-1.11(850 B)
📄 aclocal-1.12(850 B)
📄 aclocal-1.13(850 B)
📄 aclocal-1.14(850 B)
📄 aclocal-1.15(850 B)
📄 acpi(446 B)
📄 adb(1.65 KB)
📄 add_members(765 B)
📄 addpart(447 B)
📄 alias(489 B)
📄 alpine(881 B)
📄 alternatives(2.47 KB)
📄 animate(8.9 KB)
📄 ant(2.52 KB)
📄 apache2ctl(382 B)
📄 appdata-validate(796 B)
📄 apropos(2.66 KB)
📄 apt-build(1.43 KB)
📄 apt-cache(1.97 KB)
📄 apt-get(2.52 KB)
📄 aptitude(2.99 KB)
📄 arch(1.06 KB)
📄 arm-koji(6.22 KB)
📄 arping(596 B)
📄 arpspoof(562 B)
📄 asciidoc(1.14 KB)
📄 asciidoc.py(1.14 KB)
📄 aspell(3.31 KB)
📄 autoconf(953 B)
📄 autoheader(1015 B)
📄 automake(874 B)
📄 automake-1.10(874 B)
📄 automake-1.11(874 B)
📄 automake-1.12(874 B)
📄 automake-1.13(874 B)
📄 automake-1.14(874 B)
📄 automake-1.15(874 B)
📄 autoreconf(1015 B)
📄 autorpm(350 B)
📄 autoscan(733 B)
📄 autossh(11.54 KB)
📄 autoupdate(733 B)
📄 avctrl(475 B)
📄 badblocks(714 B)
📄 bind(856 B)
📄 bk(433 B)
📄 blkdiscard(639 B)
📄 blkid(2.04 KB)
📄 blkzone(971 B)
📄 blockdev(726 B)
📄 bootctl(1.89 KB)
📄 brctl(1.02 KB)
📄 btdownloadcurses.py(1.04 KB)
📄 btdownloadgui.py(1.04 KB)
📄 btdownloadheadless.py(1.04 KB)
📄 bts(4.23 KB)
📄 busctl(7.83 KB)
📄 bzip2(1.06 KB)
📄 c++(2.17 KB)
📄 cal(426 B)
📄 cancel(293 B)
📄 cardctl(382 B)
📄 cc(2.17 KB)
📄 ccache(1015 B)
📄 cdrecord(3.54 KB)
📄 cfagent(423 B)
📄 cfdisk(546 B)
📄 cfrun(1.26 KB)
📄 chage(580 B)
📄 change_pw(531 B)
📄 chcpu(1.47 KB)
📄 check_db(376 B)
📄 check_perms(321 B)
📄 checksec(742 B)
📄 chfn(445 B)
📄 chgrp(951 B)
📄 chkconfig(909 B)
📄 chmem(501 B)
📄 chown(1.09 KB)
📄 chpasswd(601 B)
📄 chronyc(1.53 KB)
📄 chrpath(522 B)
📄 chrt(920 B)
📄 chsh(504 B)
📄 ci(893 B)
📄 ciptool(9.53 KB)
📄 civclient(702 B)
📄 civserver(477 B)
📄 cksfv(521 B)
📄 cleanarch(354 B)
📄 clisp(670 B)
📄 clone_member(542 B)
📄 clzip(1.12 KB)
📄 co(893 B)
📄 col(460 B)
📄 colcrt(484 B)
📄 colormake(6.07 KB)
📄 colrm(509 B)
📄 column(725 B)
📄 compare(8.9 KB)
📄 compgen(1.44 KB)
📄 complete(1.44 KB)
📄 composite(8.9 KB)
📄 config_list(582 B)
📄 configure(1.16 KB)
📄 conjure(8.9 KB)
📄 convert(8.9 KB)
📄 coredumpctl(3.63 KB)
📄 cpan2dist(1.2 KB)
📄 cpio(2.85 KB)
📄 cppcheck(2.55 KB)
📄 cpupower(3.42 KB)
📄 createdb(4.5 KB)
📄 createuser(4.5 KB)
📄 crontab(1.16 KB)
📄 cryptsetup(2.77 KB)
📄 ctrlaltdel(335 B)
📄 curl(2.9 KB)
📄 cvs(11.58 KB)
📄 cvsps(1.47 KB)
📄 dcop(383 B)
📄 dd(1.25 KB)
📄 declare(1.27 KB)
📄 deja-dup(699 B)
📄 delpart(526 B)
📄 desktop-file-validate(476 B)
📄 devlink(26.76 KB)
📄 dfutool(9.53 KB)
📄 dhclient(591 B)
📄 dict(1.83 KB)
📄 display(8.9 KB)
📄 dmesg(1.15 KB)
📄 dnf(9.97 KB)
📄 dnsspoof(504 B)
📄 dot(1.26 KB)
📄 dpkg(3.18 KB)
📄 dpkg-deb(3.18 KB)
📄 dpkg-query(3.18 KB)
📄 dpkg-reconfigure(3.18 KB)
📄 dpkg-source(3.21 KB)
📄 dracut(3.5 KB)
📄 dropdb(4.5 KB)
📄 dropuser(4.5 KB)
📄 dselect(666 B)
📄 dsniff(516 B)
📄 dumpdb(373 B)
📄 dumpe2fs(520 B)
📄 e2freefrag(462 B)
📄 e2label(292 B)
📄 edquota(3.62 KB)
📄 eject(1.16 KB)
📄 eog(652 B)
📄 ether-wake(531 B)
📄 ethtool(23.51 KB)
📄 evince(952 B)
📄 explodepkg(152 B)
📄 export(1.59 KB)
📄 f77(2.17 KB)
📄 f95(2.17 KB)
📄 faillog(629 B)
📄 fallocate(721 B)
📄 fbgs(1.54 KB)
📄 fbi(1.79 KB)
📄 fdformat(566 B)
📄 fdisk(1.79 KB)
📄 feh(4.05 KB)
📄 file(734 B)
📄 file-roller(1.07 KB)
📄 filebucket(9.55 KB)
📄 filefrag(354 B)
📄 filesnarf(451 B)
📄 fincore(916 B)
📄 find(3.84 KB)
📄 find_member(537 B)
📄 findfs(695 B)
📄 findmnt(3.08 KB)
📄 firewall-cmd(10.36 KB)
📄 flake8(812 B)
📄 flock(874 B)
📄 freebsd-update(587 B)
📄 freeciv-gtk2(702 B)
📄 freeciv-sdl(702 B)
📄 freeciv-server(477 B)
📄 freeciv-xaw(702 B)
📄 fsck(787 B)
📄 fsck.cramfs(684 B)
📄 fsck.minix(383 B)
📄 fsfreeze(524 B)
📄 fstrim(677 B)
📄 function(1.27 KB)
📄 fusermount(649 B)
📄 g++(2.17 KB)
📄 g4(1.45 KB)
📄 g77(2.17 KB)
📄 g95(2.17 KB)
📄 gapplication(1.36 KB)
📄 gcc(2.17 KB)
📄 gcj(2.17 KB)
📄 gcl(617 B)
📄 gdb(1.61 KB)
📄 gdbus(935 B)
📄 genaliases(324 B)
📄 gendiff(267 B)
📄 genisoimage(869 B)
📄 getent(1.95 KB)
📄 getopt(815 B)
📄 gfortran(2.17 KB)
📄 gkrellm(916 B)
📄 gkrellm2(916 B)
📄 gm(858 B)
📄 gmake(6.07 KB)
📄 gmplayer(11.09 KB)
📄 gnatmake(1017 B)
📄 gnokii(6.81 KB)
📄 gnome-mplayer(962 B)
📄 gnumake(6.07 KB)
📄 gpasswd(605 B)
📄 gpc(2.17 KB)
📄 gpg(1.25 KB)
📄 gpg2(1.31 KB)
📄 gphoto2(1.37 KB)
📄 gprof(1.85 KB)
📄 groupadd(611 B)
📄 groupdel(121 B)
📄 groupmems(611 B)
📄 groupmod(686 B)
📄 growisofs(896 B)
📄 grpck(345 B)
📄 grub(11.41 KB)
📄 gsettings(2.76 KB)
📄 gzip(1.15 KB)
📄 hciattach(9.53 KB)
📄 hciconfig(9.53 KB)
📄 hcitool(9.53 KB)
📄 hd(702 B)
📄 hddtemp(866 B)
📄 hexdump(1007 B)
📄 hid2hci(350 B)
📄 host(1.97 KB)
📄 hostname(479 B)
📄 hostnamectl(2.23 KB)
📄 hping(766 B)
📄 hping2(766 B)
📄 hping3(766 B)
📄 htop(797 B)
📄 htpasswd(920 B)
📄 hwclock(938 B)
📄 iconv(847 B)
📄 id(441 B)
📄 identify(8.9 KB)
📄 idn(653 B)
📄 ifdown(387 B)
📄 ifstatus(387 B)
📄 iftop(508 B)
📄 ifup(387 B)
📄 import(8.9 KB)
📄 info(1.88 KB)
📄 inject(510 B)
📄 insmod(521 B)
📄 insmod.static(521 B)
📄 installpkg(737 B)
📄 interdiff(762 B)
📄 invoke-rc.d(1.2 KB)
📄 ionice(1.13 KB)
📄 ip(10.34 KB)
📄 ipcmk(576 B)
📄 ipcrm(1.39 KB)
📄 ipcs(514 B)
📄 iperf(1.68 KB)
📄 ipmitool(5.73 KB)
📄 ipsec(3.15 KB)
📄 iptables(2.23 KB)
📄 ipv6calc(1.35 KB)
📄 iscsiadm(1.86 KB)
📄 isosize(529 B)
📄 isql(354 B)
📄 iwconfig(2.77 KB)
📄 iwlist(617 B)
📄 iwpriv(743 B)
📄 iwspy(488 B)
📄 jar(501 B)
📄 jarsigner(1.62 KB)
📄 java(8.41 KB)
📄 javac(8.41 KB)
📄 javadoc(8.41 KB)
📄 javaws(774 B)
📄 journalctl(5.75 KB)
📄 jpegoptim(865 B)
📄 jps(594 B)
📄 jshint(894 B)
📄 k3b(1.13 KB)
📄 kcov(1.56 KB)
📄 kernel-install(1.77 KB)
📄 kill(579 B)
📄 killall(762 B)
📄 kldload(477 B)
📄 kldunload(369 B)
📄 kmod(3.16 KB)
📄 koji(6.22 KB)
📄 kplayer(11.09 KB)
📄 ktutil(2.93 KB)
📄 l2ping(9.53 KB)
📄 larch(1.94 KB)
📄 last(949 B)
📄 lastlog(566 B)
📄 lbzip2(1.06 KB)
📄 ldapadd(4.37 KB)
📄 ldapcompare(4.37 KB)
📄 ldapdelete(4.37 KB)
📄 ldapmodify(4.37 KB)
📄 ldapmodrdn(4.37 KB)
📄 ldappasswd(4.37 KB)
📄 ldapsearch(4.37 KB)
📄 ldapvi(1.35 KB)
📄 ldapwhoami(4.37 KB)
📄 ldattach(1.44 KB)
📄 lftp(634 B)
📄 lftpget(309 B)
📄 lilo(1.17 KB)
📄 links(989 B)
📄 lintian(5.14 KB)
📄 lintian-info(5.14 KB)
📄 lisp(635 B)
📄 list_admins(387 B)
📄 list_lists(471 B)
📄 list_members(858 B)
📄 list_owners(413 B)
📄 localectl(3.65 KB)
📄 logger(1.52 KB)
📄 loginctl(4.15 KB)
📄 look(683 B)
📄 losetup(1.68 KB)
📄 lpq(602 B)
📄 lpr(914 B)
📄 lrzip(1.1 KB)
📄 lsblk(1.92 KB)
📄 lscpu(1018 B)
📄 lsinitrd(1.94 KB)
📄 lsipc(1.28 KB)
📄 lslocks(1.04 KB)
📄 lslogins(1.66 KB)
📄 lsmcli(18.54 KB)
📄 lsmem(1.03 KB)
📄 lsns(1.14 KB)
📄 lsof(1.36 KB)
📄 lua(434 B)
📄 luac(486 B)
📄 luseradd(999 B)
📄 luserdel(474 B)
📄 lusermod(999 B)
📄 lvchange(19.51 KB)
📄 lvcreate(19.51 KB)
📄 lvdisplay(19.51 KB)
📄 lvextend(19.51 KB)
📄 lvm(19.51 KB)
📄 lvmdiskscan(19.51 KB)
📄 lvreduce(19.51 KB)
📄 lvremove(19.51 KB)
📄 lvrename(19.51 KB)
📄 lvresize(19.51 KB)
📄 lvs(19.51 KB)
📄 lvscan(19.51 KB)
📄 lz4(1.18 KB)
📄 lz4c(1.18 KB)
📄 lzip(1.12 KB)
📄 lzma(1.01 KB)
📄 lzop(1.45 KB)
📄 macof(429 B)
📄 mailmanctl(469 B)
📄 mailsnarf(451 B)
📄 make(6.07 KB)
📄 makepkg(534 B)
📄 man(2.66 KB)
📄 mc(842 B)
📄 mcookie(599 B)
📄 mcrypt(1.81 KB)
📄 mdadm(4.39 KB)
📄 mdecrypt(1.81 KB)
📄 mdtool(2.08 KB)
📄 medusa(682 B)
📄 mencoder(11.09 KB)
📄 mesg(412 B)
📄 micropython(1.63 KB)
📄 mii-diag(657 B)
📄 mii-tool(847 B)
📄 minicom(1005 B)
📄 mkfs(638 B)
📄 mkfs.cramfs(821 B)
📄 mkfs.minix(714 B)
📄 mkinitrd(1.19 KB)
📄 mkisofs(869 B)
📄 mkswap(841 B)
📄 mktemp(669 B)
📄 mmsitepass(330 B)
📄 modinfo(1.07 KB)
📄 modprobe(3.35 KB)
📄 mogrify(8.9 KB)
📄 monodevelop(446 B)
📄 montage(8.9 KB)
📄 more(528 B)
📄 mount(1.92 KB)
📄 mount.linux(10.36 KB)
📄 mountpoint(487 B)
📄 mplayer(11.09 KB)
📄 mplayer2(11.09 KB)
📄 mr(2.46 KB)
📄 msgsnarf(451 B)
📄 msynctool(1.33 KB)
📄 mtr(1.88 KB)
📄 mtx(1.16 KB)
📄 munin-node-configure(755 B)
📄 munin-run(651 B)
📄 munin-update(651 B)
📄 munindoc(322 B)
📄 mussh(1.16 KB)
📄 mutt(4.23 KB)
📄 muttng(4.23 KB)
📄 mysql(2.47 KB)
📄 mysqladmin(1.55 KB)
📄 namei(500 B)
📄 nc(1.07 KB)
📄 ncal(886 B)
📄 ncftp(629 B)
📄 nethogs(564 B)
📄 newlist(575 B)
📄 newusers(677 B)
📄 ngrep(779 B)
📄 nmap(1.8 KB)
📄 nmcli(3.75 KB)
📄 nsenter(1.14 KB)
📄 nslookup(1.97 KB)
📄 ntpdate(720 B)
📄 nvme(30.86 KB)
📄 openssl(10.08 KB)
📄 opera(1.36 KB)
📄 optipng(1.16 KB)
📄 p11-kit(520 B)
📄 p4(1.45 KB)
📄 pack200(2.17 KB)
📄 partx(1.22 KB)
📄 passwd(497 B)
📄 patch(1.71 KB)
📄 pbzip2(1.06 KB)
📄 pccardctl(382 B)
📄 pdftotext(932 B)
📄 pdlzip(1.12 KB)
📄 perl(3.43 KB)
📄 perldoc(3.43 KB)
📄 pgrep(1.18 KB)
📄 phing(2.52 KB)
📄 pidof(510 B)
📄 pigz(1.15 KB)
📄 pine(881 B)
📄 pinfo(1.88 KB)
📄 ping(1.79 KB)
📄 ping6(1.79 KB)
📄 pip3(286 B)
📄 pivot_root(387 B)
📄 pkg-config(1.27 KB)
📄 pkg-get(2.09 KB)
📄 pkg_deinstall(502 B)
📄 pkg_delete(502 B)
📄 pkg_info(502 B)
📄 pkgadd(1.7 KB)
📄 pkgrm(1.05 KB)
📄 pkgtool(850 B)
📄 pkgutil(3.92 KB)
📄 pkill(1.18 KB)
📄 plague-client(415 B)
📄 plzip(1.12 KB)
📄 pm-hibernate(323 B)
📄 pm-is-supported(336 B)
📄 pm-powersave(282 B)
📄 pm-suspend(323 B)
📄 pm-suspend-hybrid(323 B)
📄 pmake(6.07 KB)
📄 pngfix(799 B)
📄 portablectl(3.89 KB)
📄 portinstall(915 B)
📄 portsnap(493 B)
📄 portupgrade(479 B)
📄 postalias(1009 B)
📄 postcat(933 B)
📄 postconf(850 B)
📄 postfix(675 B)
📄 postmap(1009 B)
📄 postsuper(1.71 KB)
📄 povray(1.94 KB)
📄 ppc-koji(6.22 KB)
📄 prelink(915 B)
📄 prlimit(1.3 KB)
📄 protoc(1.49 KB)
📄 psql(4.5 KB)
📄 puppet(9.55 KB)
📄 puppetca(9.55 KB)
📄 puppetd(9.55 KB)
📄 puppetdoc(9.55 KB)
📄 puppetmasterd(9.55 KB)
📄 puppetqd(9.55 KB)
📄 puppetrun(9.55 KB)
📄 pvchange(19.51 KB)
📄 pvcreate(19.51 KB)
📄 pvdisplay(19.51 KB)
📄 pvmove(19.51 KB)
📄 pvremove(19.51 KB)
📄 pvs(19.51 KB)
📄 pvscan(19.51 KB)
📄 pwck(342 B)
📄 pwd(453 B)
📄 pwdx(485 B)
📄 pwgen(586 B)
📄 pxz(1.56 KB)
📄 py.test(1.74 KB)
📄 py.test-2(1.74 KB)
📄 py.test-3(1.74 KB)
📄 pydoc(989 B)
📄 pydoc3(989 B)
📄 pyflakes(445 B)
📄 pylint(2.34 KB)
📄 pypy(1.63 KB)
📄 pypy3(1.63 KB)
📄 python(1.63 KB)
📄 python2(1.63 KB)
📄 python3(1.63 KB)
📄 pyvenv(428 B)
📄 pyvenv-3.4(428 B)
📄 pyvenv-3.5(428 B)
📄 qdbus(383 B)
📄 qemu(3.28 KB)
📄 qemu-kvm(3.28 KB)
📄 qemu-system-i386(3.28 KB)
📄 qemu-system-x86_64(3.28 KB)
📄 qrunner(393 B)
📄 querybts(1.06 KB)
📄 quota(3.62 KB)
📄 quotacheck(3.62 KB)
📄 quotaoff(3.62 KB)
📄 quotaon(3.62 KB)
📄 ralsh(9.55 KB)
📄 raw(482 B)
📄 rcs(893 B)
📄 rcsdiff(893 B)
📄 rdesktop(1.66 KB)
📄 rdict(1.83 KB)
📄 readprofile(679 B)
📄 remove_members(571 B)
📄 removepkg(555 B)
📄 rename(655 B)
📄 renice(784 B)
📄 reportbug(3.14 KB)
📄 repquota(3.62 KB)
📄 resizepart(568 B)
📄 resolvconf(428 B)
📄 resolvectl(6.9 KB)
📄 rev(432 B)
📄 rfcomm(9.53 KB)
📄 rfkill(929 B)
📄 ri(3.65 KB)
📄 rlog(893 B)
📄 rmlist(365 B)
📄 rmmod(523 B)
📄 route(792 B)
📄 rpcdebug(1002 B)
📄 rpm(10.1 KB)
📄 rpm2targz(370 B)
📄 rpm2tgz(370 B)
📄 rpm2txz(370 B)
📄 rpmbuild(10.1 KB)
📄 rpmbuild-md5(10.1 KB)
📄 rpmcheck(514 B)
📄 rrdtool(440 B)
📄 rsync(3.43 KB)
📄 rtcwake(1.06 KB)
📄 runuser(864 B)
📄 s390-koji(6.22 KB)
📄 sbcl(677 B)
📄 sbcl-mt(677 B)
📄 sbopkg(1.72 KB)
📄 scp(11.54 KB)
📄 screen(2.2 KB)
📄 script(667 B)
📄 scriptreplay(625 B)
📄 sdptool(9.53 KB)
📄 setarch(790 B)
📄 setpriv(2.31 KB)
📄 setquota(3.62 KB)
📄 setsebool(1.77 KB)
📄 setsid(440 B)
📄 setterm(2.53 KB)
📄 sfdisk(1.96 KB)
📄 sftp(11.54 KB)
📄 sh(874 B)
📄 sidedoor(11.54 KB)
📄 sitecopy(1.29 KB)
📄 slackpkg(3.34 KB)
📄 slapt-get(2.37 KB)
📄 slapt-src(1.85 KB)
📄 slogin(11.54 KB)
📄 smartctl(4.47 KB)
📄 smbcacls(6.96 KB)
📄 smbclient(6.96 KB)
📄 smbcquotas(6.96 KB)
📄 smbget(6.96 KB)
📄 smbpasswd(6.96 KB)
📄 smbtar(6.96 KB)
📄 smbtree(6.96 KB)
📄 snownews(367 B)
📄 sparc-koji(6.22 KB)
📄 spovray(1.94 KB)
📄 sqlite3(599 B)
📄 ss(1.01 KB)
📄 ssh(11.54 KB)
📄 ssh-add(434 B)
📄 ssh-copy-id(485 B)
📄 ssh-keygen(1.51 KB)
📄 sshfs(591 B)
📄 sshmitm(365 B)
📄 sshow(428 B)
📄 strace(3.37 KB)
📄 stream(8.9 KB)
📄 strings(1.1 KB)
📄 su(864 B)
📄 sudo(1.28 KB)
📄 sudoedit(1.28 KB)
📄 svcadm(4.95 KB)
📄 svk(8.66 KB)
📄 swaplabel(635 B)
📄 swapoff(743 B)
📄 swapon(1.49 KB)
📄 sync_members(734 B)
📄 synclient(602 B)
📄 sysbench(4.04 KB)
📄 sysctl(804 B)
📄 syspurpose(720 B)
📄 systemctl(13.26 KB)
📄 systemd-analyze(6.63 KB)
📄 systemd-cat(1.87 KB)
📄 systemd-cgls(2.29 KB)
📄 systemd-cgtop(2.05 KB)
📄 systemd-delta(1.91 KB)
📄 systemd-detect-virt(1.33 KB)
📄 systemd-path(1.86 KB)
📄 systemd-resolve(3.11 KB)
📄 systemd-run(4.75 KB)
📄 tar(18.8 KB)
📄 taskset(1.18 KB)
📄 tcpdump(1011 B)
📄 tcpkill(441 B)
📄 tcpnice(434 B)
📄 tightvncviewer(3.09 KB)
📄 timedatectl(2.91 KB)
📄 timeout(932 B)
📄 tipc(7.16 KB)
📄 tracepath(456 B)
📄 tracepath6(456 B)
📄 trust(1.99 KB)
📄 tshark(2.95 KB)
📄 tune2fs(1.61 KB)
📄 tuned-adm(604 B)
📄 typeset(1.27 KB)
📄 udevadm(3.68 KB)
📄 ul(655 B)
📄 umount(512 B)
📄 umount.linux(4.37 KB)
📄 unace(480 B)
📄 unpack200(1.22 KB)
📄 unrar(614 B)
📄 unshare(809 B)
📄 unshunt(351 B)
📄 update-alternatives(2.47 KB)
📄 update-rc.d(2.13 KB)
📄 upgradepkg(811 B)
📄 urlsnarf(437 B)
📄 useradd(1.15 KB)
📄 userdel(539 B)
📄 usermod(1.27 KB)
📄 utmpdump(475 B)
📄 uuidgen(657 B)
📄 uuidparse(727 B)
📄 valgrind(3.42 KB)
📄 vgcfgbackup(19.51 KB)
📄 vgcfgrestore(19.51 KB)
📄 vgchange(19.51 KB)
📄 vgck(19.51 KB)
📄 vgconvert(19.51 KB)
📄 vgcreate(19.51 KB)
📄 vgdisplay(19.51 KB)
📄 vgexport(19.51 KB)
📄 vgextend(19.51 KB)
📄 vgimport(19.51 KB)
📄 vgmerge(19.51 KB)
📄 vgmknodes(19.51 KB)
📄 vgreduce(19.51 KB)
📄 vgremove(19.51 KB)
📄 vgrename(19.51 KB)
📄 vgs(19.51 KB)
📄 vgscan(19.51 KB)
📄 vgsplit(19.51 KB)
📄 vigr(432 B)
📄 vipw(432 B)
📄 vmstat(708 B)
📄 vncviewer(3.09 KB)
📄 vpnc(1.65 KB)
📄 wall(634 B)
📄 watch(1.13 KB)
📄 wdctl(1.34 KB)
📄 webmitm(365 B)
📄 wget(6.47 KB)
📄 whatis(2.66 KB)
📄 whereis(535 B)
📄 wine(509 B)
📄 wipefs(1.16 KB)
📄 withlist(413 B)
📄 wodim(3.54 KB)
📄 wol(1.11 KB)
📄 write(431 B)
📄 wsimport(1.1 KB)
📄 wtf(928 B)
📄 wvdial(1.25 KB)
📄 xfreerdp(1.05 KB)
📄 xgamma(2.01 KB)
📄 xhost(367 B)
📄 xm(7.41 KB)
📄 xmllint(1.04 KB)
📄 xmlwf(699 B)
📄 xmms(663 B)
📄 xmodmap(486 B)
📄 xpovray(1.94 KB)
📄 xrandr(2.14 KB)
📄 xrdb(510 B)
📄 xsltproc(1.22 KB)
📄 xvnc4viewer(3.09 KB)
📄 xxd(471 B)
📄 xz(1.56 KB)
📄 xzdec(739 B)
📄 ypcat(768 B)
📄 ypmatch(768 B)
📄 yum-arch(360 B)
📄 zopfli(689 B)
📄 zopflipng(930 B)
📄 zramctl(1.24 KB)

Editing: devlink

# bash completion for devlink(8)                          -*- shell-script -*-

# Get all the optional commands for devlink
_devlink_get_optional_commands()
{
    local object=$1; shift

local filter_options=""
    local options="$(devlink $object help 2>&1 \
        | command sed -n -e "s/^.*devlink $object //p" \
        | cut -d " " -f 1)"

# Remove duplicate options from "devlink $OBJECT help" command
    local opt
    for opt in $options; do
        if [[ $filter_options =~ $opt ]]; then
            continue
        else
            filter_options="$filter_options $opt"
        fi
    done

echo $filter_options
}

# Complete based on given word, for when an argument or an option name has
# but a few possible arguments.
_devlink_direct_complete()
{
    local dev port region value

case $1 in
        dev)
            value=$(devlink dev show 2>/dev/null)
            ;;
        selftests_id)
            dev=${words[4]}
            value=$(devlink -j dev selftests show 2>/dev/null \
                    | jq ".selftests[\"$dev\"][]")
            ;;
        param_name)
            dev=${words[4]}
            value=$(devlink -j dev param show 2>/dev/null \
                    | jq ".param[\"$dev\"][].name")
            ;;
        port)
            value=$(devlink -j port show 2>/dev/null \
                    | jq '.port as $ports | $ports | keys[] as $key
                    | ($ports[$key].netdev // $key)')
            ;;
        lc)
            dev=${words[3]}
            value=$(devlink -j lc show 2>/dev/null \
                    | jq ".lc[\"$dev\"]" \
                    | jq '. as $lcs | $lcs | keys[] as $key |($lcs[$key].lc)' \
                    2>/dev/null)
            ;;
        lc_type)
            dev=${words[3]}
            lc=${words[5]}
            value=$(devlink lc show $dev lc $lc -j 2>/dev/null \
                    | jq '.[][][]["supported_types"][]')
            ;;
        region)
            value=$(devlink -j region show 2>/dev/null \
                    | jq '.regions' | jq 'keys[]')
            ;;
        snapshot)
            region=${words[3]}
            value=$(devlink -j region show 2>/dev/null \
                    | jq ".regions[\"$region\"].snapshot[]")
            ;;
        trap)
            dev=${words[3]}
            value=$(devlink -j trap show 2>/dev/null \
                    | jq ".trap[\"$dev\"][].name")
            ;;
        trap_group)
            dev=${words[4]}
            value=$(devlink -j trap group show 2>/dev/null \
                    | jq ".trap_group[\"$dev\"][].name")
            ;;
        trap_policer)
            dev=${words[4]}
            value=$(devlink -j trap policer show 2>/dev/null \
                    | jq ".trap_policer[\"$dev\"][].policer")
            ;;
        health_dev)
            value=$(devlink -j health show 2>/dev/null | jq '.health' \
                    | jq 'keys[]')
            ;;
        reporter)
            dev=${words[cword - 2]}
            value=$(devlink -j health show 2>/dev/null \
                    | jq ".health[\"$dev\"][].reporter")
            ;;
        pool)
            dev=$pprev
            value=$(devlink -j sb pool show 2>/dev/null \
                    | jq ".pool[\"$dev\"][].pool")
            ;;
        port_pool)
            port=${words[5]}
            value=$(devlink -j sb port pool show 2>/dev/null \
                    | jq ".port_pool[\"$port\"][].pool")
            ;;
        tc)
            port=$pprev
            value=$(devlink -j sb tc bind show 2>/dev/null \
                    | jq ".tc_bind[\"$port\"][].tc")
            ;;
    esac

COMPREPLY+=( $( compgen -W "$value" -- "$cur" ) )
    # Remove colon containing prefix from COMPREPLY items in order to avoid
    # wordbreaks with colon.
    __ltrim_colon_completions "$cur"
}

# Completion for devlink dev eswitch set
_devlink_dev_eswitch_set()
{
    local -A settings=(
        [mode]=notseen
        [inline-mode]=notseen
        [encap-mode]=notseen
    )

if [[ $cword -eq 5 ]]; then
        COMPREPLY=( $( compgen -W "mode inline-mode encap-mode" -- "$cur" ) )
    fi

# Mark seen settings
    local word
    for word in "${words[@]:5:${#words[@]}-1}"; do
        if [[ -n $word ]]; then
            if [[ "${settings[$word]}" ]]; then
                settings[$word]=seen
            fi
        fi
    done

case $prev in
        mode)
            COMPREPLY=( $( compgen -W "legacy switchdev" -- "$cur" ) )
            return
            ;;
        inline-mode)
            COMPREPLY=( $( compgen -W "none link network transport" -- \
                "$cur" ) )
            return
            ;;
        encap-mode)
            COMPREPLY=( $( compgen -W "none basic" -- "$cur" ) )
            return
            ;;
    esac

local -a comp_words=()

# Add settings not seen to completions
    local setting
    for setting in "${!settings[@]}"; do
        if [ "${settings[$setting]}" = notseen ]; then
            comp_words+=( "$setting" )
        fi
    done

COMPREPLY=( $( compgen -W "${comp_words[*]}" -- "$cur" ) )
}

# Completion for devlink dev eswitch
_devlink_dev_eswitch()
{
    case "$cword" in
        3)
            COMPREPLY=( $( compgen -W "show set" -- "$cur" ) )
            return
            ;;
        4)
            _devlink_direct_complete "dev"
            return
            ;;
    esac

case "${words[3]}" in
        set)
            _devlink_dev_eswitch_set
            return
            ;;
        show)
            return
            ;;
    esac
}

# Completion for devlink dev param set
_devlink_dev_param_set()
{
    case $cword in
        7)
            COMPREPLY=( $( compgen -W "value" -- "$cur" ) )
            return
            ;;
        8)
            # String argument
            return
            ;;
        9)
            COMPREPLY=( $( compgen -W "cmode" -- "$cur" ) )
            return
            ;;
        10)
            COMPREPLY=( $( compgen -W "runtime driverinit permanent" -- \
                "$cur" ) )
            return
            ;;
    esac
}

# Completion for devlink dev param
_devlink_dev_param()
{
    case "$cword" in
        3)
            COMPREPLY=( $( compgen -W "show set" -- "$cur" ) )
            return
            ;;
        4)
            _devlink_direct_complete "dev"
            return
            ;;
        5)
            COMPREPLY=( $( compgen -W "name" -- "$cur" ) )
            return
            ;;
        6)
            _devlink_direct_complete "param_name"
            return
            ;;
    esac

if [[ "${words[3]}" == "set" ]]; then
        _devlink_dev_param_set
    fi
}

# Completion for devlink dev reload
_devlink_dev_reload()
{
    case "$cword" in
        4)
            COMPREPLY=( $( compgen -W "netns" -- "$cur" ) )
            return
            ;;
        5)
            local nslist=$( ip netns list 2>/dev/null )
            COMPREPLY=( $( compgen -W "$nslist" -- "$cur" ) )
            return
            ;;
    esac
}

# Completion for devlink dev flash
_devlink_dev_flash()
{
    case "$cword" in
        4)
            COMPREPLY=( $( compgen -W "file" -- "$cur" ) )
            return
            ;;
        5)
            _filedir
            return
            ;;
        6)
            COMPREPLY=( $( compgen -W "component" -- "$cur" ) )
            return
            ;;
     esac
}

# Completion for devlink dev selftests
_devlink_dev_selftests()
{
    if [[ $cword -gt 5 ]]; then
            _devlink_direct_complete "selftests_id"
            return
    fi
    case "$cword" in
        3)
            COMPREPLY=( $( compgen -W "show run" -- "$cur" ) )
            return
            ;;
        4)
            _devlink_direct_complete "dev"
            return
            ;;
        5)
            COMPREPLY=( $( compgen -W "id" -- "$cur" ) )
            return
            ;;
    esac
}

# Completion for devlink dev
_devlink_dev()
{
    case $command in
        show|reload|info|flash)
            if [[ $cword -le 3 ]]; then
                _devlink_direct_complete "dev"
            elif [[ $command == "reload" || $command == "flash" ]];then
                _devlink_dev_$command
            fi
            return
            ;;
        eswitch|param|selftests)
            _devlink_dev_$command
            return
            ;;
    esac
}

# Completion for devlink port set
_devlink_port_set()
{
    case "$cword" in
        3)
            _devlink_direct_complete "port"
            return
            ;;
        4)
            COMPREPLY=( $( compgen -W "type" -- "$cur" ) )
            return
            ;;
        5)
            COMPREPLY=( $( compgen -W "eth ib auto" -- "$cur" ) )
            return
            ;;
    esac
}

# Completion for devlink port split
_devlink_port_split()
{
    case "$cword" in
        3)
            _devlink_direct_complete "port"
            return
            ;;
        4)
            COMPREPLY=( $( compgen -W "count" -- "$cur" ) )
            return
            ;;
        5)
            # Integer argument
            return
            ;;
    esac
}

# Completion for devlink port param set
_devlink_port_param_set()
{
    case $cword in
        7)
            COMPREPLY=( $( compgen -W "value" -- "$cur" ) )
            return
            ;;
        8)
            # String argument
            return
            ;;
        9)
            COMPREPLY=( $( compgen -W "cmode" -- "$cur" ) )
            return
            ;;
        10)
            COMPREPLY=( $( compgen -W "runtime driverinit permanent" -- \
                "$cur" ) )
            return
            ;;
    esac
}

# Completion for devlink port param
_devlink_port_param()
{
    case "$cword" in
        3)
            COMPREPLY=( $( compgen -W "show set" -- "$cur" ) )
            return
            ;;
        4)
            _devlink_direct_complete "port"
            return
            ;;
        5)
            COMPREPLY=( $( compgen -W "name" -- "$cur" ) )
            return
            ;;
        6)
            _devlink_direct_complete "param_name"
            return
            ;;
    esac

if [[ "${words[3]}" == "set" ]]; then
        _devlink_port_param_set
    fi
}

# Completion for devlink port
_devlink_port()
{
    case $command in
        set)
            _devlink_port_set
            return
            ;;
        split)
            _devlink_port_split
            return
            ;;
        param)
            _devlink_port_param
            return
            ;;
        show|unsplit)
            if [[ $cword -eq 3 ]]; then
                _devlink_direct_complete "port"
            fi
            return
            ;;
    esac
}

# Completion for devlink lc set
_devlink_lc_set()
{
    case "$cword" in
        3)
            _devlink_direct_complete "dev"
            return
            ;;
        4)
            COMPREPLY=( $( compgen -W "lc" -- "$cur" ) )
            ;;
        5)
            _devlink_direct_complete "lc"
            ;;
        6)
            COMPREPLY=( $( compgen -W "type notype" -- "$cur" ) )
            return
            ;;
        7)
            if [[ "$prev" == "type" ]]; then
                _devlink_direct_complete "lc_type"
            fi
    esac
}

# Completion for devlink lc show
_devlink_lc_show()
{
    case $cword in
        3)
            _devlink_direct_complete "dev"
            ;;
        4)
            COMPREPLY=( $( compgen -W "lc" -- "$cur" ) )
            ;;
        5)
            _devlink_direct_complete "lc"
            ;;
    esac
}

# Completion for devlink lc
_devlink_lc()
{
    case $command in
        set)
            _devlink_lc_set
            return
            ;;
        show)
            _devlink_lc_show
            return
            ;;
    esac
}

# Completion for devlink dpipe
_devlink_dpipe()
{
    local options="$(devlink dpipe help 2>&1 \
                     | command sed -e '/OBJECT-LIST := /!d' \
                     -e 's/.*{ //' -e 's/}.*//' -e 's/|//g' )"

if [[ $cword -eq 2 ]]; then
        COMPREPLY+=( $( compgen -W "$options" -- "$cur" ) )
    fi
}

# Completion for devlink monitor
_devlink_monitor()
{
    local options="$(devlink monitor help 2>&1 \
                     | command sed -e '/OBJECT-LIST := /!d' \
                     -e 's/.*{ //' -e 's/}.*//' -e 's/|//g' )"

if [[ $cword -eq 2 ]]; then
        COMPREPLY+=( $( compgen -W "all $options" -- "$cur" ) )
    fi
}

# Completion for the rest of devlink sb $command
_devlink_sb_command_options()
{
    local subcmd

case $command in
        pool)
            subcmd=${words[3]}
            if [[ $cword -eq 5 ]]; then
                COMPREPLY=( $( compgen -W "pool" -- "$cur" ) )
            fi
            if [[ $subcmd == "set" ]]; then
                case $cword in
                    7)
                        COMPREPLY+=( $( compgen -W "size" -- "$cur" ) )
                        ;;
                    9)
                        COMPREPLY+=( $( compgen -W "thtype" -- "$cur" ) )
                        ;;
                esac
            fi
            ;;
        port)
            subcmd=${words[4]}
            if [[ $cword -eq 6 ]]; then
                COMPREPLY+=( $( compgen -W "pool" -- "$cur" ) )
            fi
            if [[ $subcmd == "set" ]]; then
                case $cword in
                    8)
                        COMPREPLY+=( $( compgen -W "th" -- "$cur" ) )
                        ;;
                esac
            fi
            ;;
        tc)
            subcmd=${words[4]}
            case $cword in
                6)
                    COMPREPLY+=( $( compgen -W "tc" -- "$cur" ) )
                    ;;
                8)
                    COMPREPLY+=( $( compgen -W "type" -- "$cur" ) )
                    ;;
            esac
            if [[ $subcmd == "set" ]]; then
                case $cword in
                    10)
                        COMPREPLY+=( $( compgen -W "pool" -- "$cur" ) )
                        ;;
                    12)
                        COMPREPLY+=( $( compgen -W "th" -- "$cur" ) )
                        ;;
                esac
            fi
            ;;
    esac
}

# Completion for devlink sb
_devlink_sb()
{
    case $prev in
        bind)
            COMPREPLY=( $( compgen -W "set show" -- "$cur" ) )
            ;;
        occupancy)
            COMPREPLY=( $( compgen -W "show snapshot clearmax" -- "$cur" ) )
            ;;
        pool)
            if [[ $cword -eq 3 || $cword -eq 4 ]]; then
                COMPREPLY=( $( compgen -W "set show" -- "$cur" ) )
            elif [[ $command == "port" || $command == "tc" ]]; then
                _devlink_direct_complete "port_pool"
            else
                _devlink_direct_complete "pool"
            fi
            ;;
        port)
            if [[ $cword -eq 3 ]]; then
                COMPREPLY=( $( compgen -W "pool" -- "$cur" ) )
            fi
            ;;
        show|set|snapshot|clearmax)
            case $command in
                show|pool|occupancy)
                    _devlink_direct_complete "dev"
                    if [[ $command == "occupancy" && $prev == "show" ]];then
                        _devlink_direct_complete "port"
                    fi
                    ;;
                port|tc)
                    _devlink_direct_complete "port"
                    ;;
            esac
            ;;
        size)
            # Integer argument
            ;;
        thtype)
            COMPREPLY=( $( compgen -W "static dynamic" -- "$cur" ) )
            ;;
        th)
            # Integer argument
            ;;
        tc)
            if [[ $cword -eq 3 ]]; then
                COMPREPLY=( $( compgen -W "bind" -- "$cur" ) )
            else
                _devlink_direct_complete "tc"
            fi
            ;;
        type)
            COMPREPLY=( $( compgen -W "ingress egress" -- "$cur" ) )
            ;;
    esac

_devlink_sb_command_options
    return
}

# Completion for devlink resource set path argument
_devlink_resource_path()
{
    local path parents parent all_path
    local dev=${words[3]}
    local -a path

local all_path=$(
        devlink resource show $dev \
            | sed -E '# Of resource lines, keep only the name itself.
                    s/name ([^ ]*) .*/\1/
                    # Drop headers.
                    /:$/d
                    # First layer is not aligned enough, align it.
                    s/^/  /
                    # Use slashes as unary code for resource depth.
                    s,    ,/,g
                    # Separate tally count from resource name.
                    s,/*,&\t,' \
            | while read d name; do
                    while ((${#path[@]} > ${#d})); do
                        unset path[$((${#path[@]} - 1))]
                    done
                    path[$((${#d} - 1))]=$name
                    echo ${path[@]}
              done \
            | sed '# Convert paths to slash-separated
                    s,^,/,;s, ,/,g;s,$,/,'
    )
    COMPREPLY=( ${COMPREPLY[@]:-} $( compgen -W "$all_path" -- "$cur" ) )
}

# Completion for devlink resource set
_devlink_resource_set()
{
    case "$cword" in
        3)
            _devlink_direct_complete "dev"
            return
            ;;
        4)
            COMPREPLY=( $( compgen -W "path" -- "$cur" ) )
            return
            ;;
        5)
            _devlink_resource_path
            return
            ;;
        6)
            COMPREPLY=( $( compgen -W "size" -- "$cur" ) )
            return
            ;;
        7)
            # Integer argument
            return
            ;;
    esac
}

# Completion for devlink resource
_devlink_resource()
{
    case $command in
        show)
            if [[ $cword -eq 3 ]]; then
                _devlink_direct_complete "dev"
            fi
            return
            ;;
        set)
            _devlink_resource_set
            return
            ;;
    esac
}

# Completion for devlink region read
_devlink_region_read()
{
    case "$cword" in
        6)
            COMPREPLY=( $( compgen -W "address" -- "$cur" ) )
            return
            ;;
        7)
            # Address argument, for example: 0x10
            return
            ;;
        8)
            COMPREPLY=( $( compgen -W "length" -- "$cur" ) )
            return
            ;;
        9)
            # Integer argument
            return
            ;;
    esac
}

# Completion for devlink region
_devlink_region()
{
    if [[ $cword -eq 3 && $command != "help" ]]; then
            _devlink_direct_complete "region"
    fi

case $command in
        show)
            return
            ;;
        del|dump|read)
            case "$cword" in
                4)
                    COMPREPLY=( $( compgen -W "snapshot" -- "$cur" ) )
                    ;;
                5)
                    _devlink_direct_complete "snapshot"
                    ;;
            esac

if [[ $command == "read" ]]; then
                _devlink_region_read
            fi
            return
            ;;
    esac
}

# Completion reporter for devlink health
_devlink_health_reporter()
{
    local i=$1; shift

case $cword in
        $((3 + $i)))
            _devlink_direct_complete "health_dev"
            ;;
        $((4 + $i)))
            COMPREPLY=( $( compgen -W "reporter" -- "$cur" ) )
            ;;
        $((5 + $i)))
            _devlink_direct_complete "reporter"
            ;;
    esac
}

# Completion for devlink health
_devlink_health()
{
    case $command in
        show|recover|diagnose|set|test)
            _devlink_health_reporter 0
            if [[ $command == "set" ]]; then
                case $cword in
                    6)
                        COMPREPLY=( $( compgen -W "grace_period auto_recover" \
                                   -- "$cur" ) )
                        ;;
                    7)
                        case $prev in
                            grace_period)
                                # Integer argument- msec
                                ;;
                            auto_recover)
                                COMPREPLY=( $( compgen -W "true false" -- \
                                    "$cur" ) )
                                ;;
                        esac
                esac
            fi
            return
            ;;
        dump)
            if [[ $cword -eq 3 ]]; then
                COMPREPLY=( $( compgen -W "show clear" -- "$cur" ) )
            fi

_devlink_health_reporter 1
            return
            ;;
    esac
}

# Completion for action in devlink trap set
_devlink_trap_set_action()
{
    local i=$1; shift

case $cword in
        $((6 + $i)))
            COMPREPLY=( $( compgen -W "action" -- "$cur" ) )
            ;;
        $((7 + $i)))
            COMPREPLY=( $( compgen -W "trap drop mirror" -- "$cur" ) )
            ;;
    esac
}

# Completion for devlink trap group set
_devlink_trap_group_set()
{
    local -A settings=(
        [action]=notseen
        [policer]=notseen
        [nopolicer]=notseen
    )

if [[ $cword -eq 7 ]]; then
        COMPREPLY=( $( compgen -W "action policer nopolicer" -- "$cur" ) )
    fi

# Mark seen settings
    local word
    for word in "${words[@]:7:${#words[@]}-1}"; do
        if [[ -n $word ]]; then
            if [[ "${settings[$word]}" ]]; then
                settings[$word]=seen
            fi
        fi
    done

case $prev in
        action)
            COMPREPLY=( $( compgen -W "trap drop mirror" -- "$cur" ) )
            return
            ;;
        policer)
            _devlink_direct_complete "trap_policer"
            return
            ;;
    esac

local -a comp_words=()

COMPREPLY=( $( compgen -W "${comp_words[*]}" -- "$cur" ) )
}

# Completion for devlink trap group
_devlink_trap_group()
{
    case $cword in
        3)
            COMPREPLY=( $( compgen -W "set show" -- "$cur" ) )
            return
            ;;
        4)
            _devlink_direct_complete "dev"
            return
            ;;
        5)
            COMPREPLY=( $( compgen -W "group" -- "$cur" ) )
            return
            ;;
        6)
            _devlink_direct_complete "trap_group"
            return
            ;;
    esac

if [[ ${words[3]} == "set" ]]; then
        _devlink_trap_group_set
    fi
}

# Completion for devlink trap policer set
_devlink_trap_policer_set()
{
    local -A settings=(
        [rate]=notseen
        [burst]=notseen
    )

if [[ $cword -eq 7 ]]; then
        COMPREPLY=( $( compgen -W "rate burst" -- "$cur" ) )
    fi

case $prev in
        rate)
            # Integer argument
            return
            ;;
        burst)
            # Integer argument
            return
            ;;
    esac

local -a comp_words=()

COMPREPLY=( $( compgen -W "${comp_words[*]}" -- "$cur" ) )
}

# Completion for devlink trap policer
_devlink_trap_policer()
{
    case $cword in
        3)
            COMPREPLY=( $( compgen -W "set show" -- "$cur" ) )
            return
            ;;
        4)
            _devlink_direct_complete "dev"
            return
            ;;
        5)
            COMPREPLY=( $( compgen -W "policer" -- "$cur" ) )
            return
            ;;
        6)
            _devlink_direct_complete "trap_policer"
            return
            ;;
    esac

if [[ ${words[3]} == "set" ]]; then
        _devlink_trap_policer_set
    fi
}

# Completion for devlink trap
_devlink_trap()
{
    case $command in
        show|set)
            case $cword in
                3)
                    _devlink_direct_complete "dev"
                    ;;
                4)
                    COMPREPLY=( $( compgen -W "trap" -- "$cur" ) )
                    ;;
                5)
                    _devlink_direct_complete "trap"
                    ;;
            esac

if [[ $command == "set" ]]; then
                _devlink_trap_set_action 0
            fi
            return
            ;;
        group)
            _devlink_trap_$command
            return
            ;;
        policer)
            _devlink_trap_$command
            return
            ;;
    esac
}

# Complete any devlink command
_devlink()
{
    local cur prev words cword
    local opt='--Version --no-nice-names --json --pretty --verbose \
        --statistics --force --Netns --batch'
    local objects="$(devlink help 2>&1 | command sed -e '/OBJECT := /!d' \
		     -e 's/.*{//' -e 's/}.*//' -e \ 's/|//g' )"

_init_completion || return
    # Gets the word-to-complete without considering the colon as word breaks
    _get_comp_words_by_ref -n : cur prev words cword

if [[ $cword -eq 1 ]]; then
	    case $cur in
	        -*)
		        COMPREPLY=( $( compgen -W "$opt" -- "$cur" ) )
		        return 0
		        ;;
	        *)
		        COMPREPLY=( $( compgen -W "$objects" -- "$cur" ) )
		        return 0
		        ;;
	    esac
    fi

# Deal with options
    if [[ $prev == -* ]]; then
	    case $prev in
	        -V|--Version)
		        return 0
		        ;;
	        -b|--batch)
		        _filedir
		        return 0
		        ;;
	        --force)
                COMPREPLY=( $( compgen -W "--batch" -- "$cur" ) )
		        return 0
		        ;;
	        -N|--Netns)
		        local nslist=$( ip netns list 2>/dev/null )
		        COMPREPLY=( $( compgen -W "$nslist" -- "$cur" ) )
		        return 0
		        ;;
	        -j|--json)
		        COMPREPLY=( $( compgen -W "--pretty $objects" -- "$cur" ) )
		        return 0
		        ;;
            *)
                COMPREPLY=( $( compgen -W "$objects" -- "$cur" ) )
		        return 0
		        ;;
	    esac
    fi

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

local object=${words[1]}
    local command=${words[2]}
    local pprev=${words[cword - 2]}
    local prev=${words[cword - 1]}

if [[ $objects =~ $object ]]; then
        if [[ $cword -eq 2 ]]; then
            COMPREPLY=( $( compgen -W "help" -- "$cur") )
            if [[ $object != "monitor" && $object != "dpipe" ]]; then
                COMPREPLY+=( $( compgen -W \
                    "$(_devlink_get_optional_commands $object)" -- "$cur" ) )
            fi
        fi
        "_devlink_$object"
    fi

} &&
complete -F _devlink devlink

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

X7ROOT File Manager

Editing: devlink

Upload File

Create Folder