/bash_completion_lib/include/_lvm

  1_volumegroups()
  2{
  3    COMPREPLY=( $(compgen -W "$( vgscan 2>/dev/null | \
  4        sed -n -e 's|.*Found.*"\(.*\)".*$|\1|p' )" -- $cur ) )
  5}
  6
  7_physicalvolumes()
  8{
  9    COMPREPLY=( $(compgen -W "$( pvscan 2>/dev/null | \
 10        sed -n -e 's|^.*PV \(.*\) VG.*$|\1|p' )" -- $cur ) )
 11}
 12
 13_logicalvolumes()
 14{
 15    COMPREPLY=( $(compgen -W "$( lvscan 2>/dev/null | \
 16        sed -n -e "s|^.*'\(.*\)'.*$|\1|p" )" -- $cur ) )
 17}
 18
 19_units()
 20{
 21    COMPREPLY=( $( compgen -W 'h s b k m g t H K M G T' -- $cur ) )
 22}
 23
 24_sizes()
 25{
 26    COMPREPLY=( $( compgen -W 'k K m M g G t T' -- $cur ) )
 27}
 28
 29_args()
 30{
 31    args=0
 32    if [[ "${COMP_WORDS[0]}" == lvm ]]; then
 33        offset=2
 34    else
 35        offset=1
 36    fi
 37    for (( i=$offset; i < COMP_CWORD; i++ )); do
 38        if [[ "${COMP_WORDS[i]}" != -* ]]; then
 39            args=$(($args + 1))
 40        fi
 41    done
 42}
 43
 44_pvscan()
 45{
 46    local cur
 47
 48    COMPREPLY=()
 49    cur=`_get_cword`
 50
 51    if [[ "$cur" == -* ]]; then
 52        COMPREPLY=( $( compgen -W '-d --debug -e \
 53            --exported -n --novolumegroup -h -? \
 54            --help --ignorelockingfailure -P \
 55            --partial -s --short -u --uuid -v \
 56            --verbose --version' -- $cur ) )
 57    fi
 58}
 59
 60_pvs()
 61{
 62    local cur prev
 63
 64    COMPREPLY=()
 65    cur=`_get_cword`
 66    prev=${COMP_WORDS[COMP_CWORD-1]}
 67
 68    case "$prev" in
 69        -@(o|O|-options|-sort))
 70            COMPREPLY=( $( compgen -W 'pv_fmt pv_uuid \
 71                pv_size pv_free pv_used pv_name \
 72                pv_attr pv_pe_count \
 73                pv_pe_alloc_count' -- $cur ) )
 74            return 0
 75            ;;
 76        --units)
 77            _units
 78            return 0
 79            ;;
 80    esac
 81
 82    if [[ "$cur" == -* ]]; then
 83        COMPREPLY=( $( compgen -W '--aligned -a --all -d --debug \
 84            -h -? --help --ignorelockingfailure --noheadings \
 85            --nosuffix -o --options -O --sort \
 86            --separator --unbuffered --units \
 87            -v --verbose --version' -- $cur ) )
 88    else
 89        _physicalvolumes
 90    fi
 91}
 92
 93_pvdisplay()
 94{
 95    local cur prev
 96
 97    COMPREPLY=()
 98    cur=`_get_cword`
 99    prev=${COMP_WORDS[COMP_CWORD-1]}
100
101    case "$prev" in
102        --units)
103            _units
104            return 0
105            ;;
106    esac
107
108    if [[ "$cur" == -* ]]; then
109        COMPREPLY=( $( compgen -W '-c --colon -C --columns --units \
110            -v --verbose -d --debug -h --help --version' -- $cur ) )
111    else
112        _physicalvolumes
113    fi
114}
115
116_pvchange()
117{
118    local cur prev
119
120    COMPREPLY=()
121    cur=`_get_cword`
122    prev=${COMP_WORDS[COMP_CWORD-1]}
123
124    case "$prev" in
125        -@(A|x|-autobackup|--allocatable))
126            COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
127            return 0
128            ;;
129    esac
130
131    if [[ "$cur" == -* ]]; then
132        COMPREPLY=( $( compgen -W '-a --all -A --autobackup \
133            -d --debug -h --help -t --test -u --uuid -x \
134            --allocatable -v --verbose --addtag --deltag \
135            --version' -- $cur ) )
136    else
137        _physicalvolumes
138    fi
139}
140
141_pvcreate()
142{
143    local cur prev
144
145    COMPREPLY=()
146    cur=`_get_cword`
147    prev=${COMP_WORDS[COMP_CWORD-1]}
148
149    case "$prev" in
150        --restorefile)
151            _filedir
152            return 0
153            ;;
154        -@(M|-metadatatype))
155            COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
156            return 0
157            ;;
158        --metadatacopies)
159            COMPREPLY=( $( compgen -W '0 1 2' -- $cur ) )
160            return 0
161            ;;
162        --@(metadatasize|setphysicalvolumesize))
163            _sizes
164            return 0
165            ;;
166    esac
167
168    if [[ "$cur" == -* ]]; then
169        COMPREPLY=( $( compgen -W '--restorefile -d --debug -f \
170            --force -h -? --help --labelsector -M --metadatatype \
171            --metadatacopies --metadatasize \
172            --setphysicalvolumesize -t --test -u --uuid uuid -v \
173            --verbose -y --yes --version' -- $cur ) )
174    else
175        _physicalvolumes
176    fi
177}
178
179_pvmove()
180{
181    local cur prev
182
183    COMPREPLY=()
184    cur=`_get_cword`
185    prev=${COMP_WORDS[COMP_CWORD-1]}
186
187    case "$prev" in
188        -@(A|-autobackup))
189            COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
190            return 0
191            ;;
192        -@(n|-name))
193            _logicalvolumes
194            return 0
195    esac
196
197    if [[ "$cur" == -* ]]; then
198        COMPREPLY=( $( compgen -W '--abort -A --autobackup \
199            -b --background -d --debug -f --force -h -? \
200            --help -i --interval -t --test -v --verbose \
201            --version -n --name' -- $cur ) )
202    else
203        _physicalvolumes
204    fi
205}
206
207_pvremove()
208{
209    local cur
210
211    COMPREPLY=()
212    cur=`_get_cword`
213
214    if [[ "$cur" == -* ]]; then
215        COMPREPLY=( $( compgen -W '-d --debug -f --force -h -? \
216            --help -y --yes -t --test -v --verbose \
217            --version' -- $cur ) )
218    else
219        _physicalvolumes
220    fi
221}
222
223_vgscan()
224{
225    local cur
226
227    COMPREPLY=()
228    cur=`_get_cword`
229
230    if [[ "$cur" == -* ]]; then
231        COMPREPLY=( $( compgen -W '-d --debug -h --help \
232            --ignorelockingfailure --mknodes -P \
233            --partial -v --verbose --version' -- $cur ) )
234    fi
235}
236
237_vgs()
238{
239    local cur prev
240
241    COMPREPLY=()
242    cur=`_get_cword`
243    prev=${COMP_WORDS[COMP_CWORD-1]}
244
245    case "$prev" in
246        -@(o|O|-options|-sort))
247            COMPREPLY=( $( compgen -W 'vg_fmt vg_uuid vg_name \
248                vg_attr vg_size vg_free vg_sysid \
249                vg_extent_size vg_extent_count vg_free_count \
250                max_lv max_pv pv_count lv_count snap_count \
251                vg_seqno' -- $cur ) )
252            return 0
253            ;;
254        --units)
255            _units
256            return 0
257            ;;
258    esac
259
260    if [[ "$cur" == -* ]]; then
261        COMPREPLY=( $( compgen -W '--aligned -d --debug \
262            -h --help --ignorelockingfailure --noheadings \
263            --nosuffix -o --options -O --sort -P --partial \
264            --separator --unbuffered --units \
265            -v --verbose --version' -- $cur ) )
266    else
267        _volumegroups
268    fi
269}
270
271_vgdisplay()
272{
273    local cur prev
274
275    COMPREPLY=()
276    cur=`_get_cword`
277    prev=${COMP_WORDS[COMP_CWORD-1]}
278
279    case "$prev" in
280        --units)
281            _units
282            return 0
283            ;;
284    esac
285
286    if [[ "$cur" == -* ]]; then
287        COMPREPLY=( $( compgen -W '-c --colon -C --columns --units \
288            -P --partial -A --activevolumegroups -v --verbose \
289            -d --debug -h --help --version' -- $cur ) )
290    else
291        _volumegroups
292    fi
293}
294
295_vgchange()
296{
297    local cur prev
298
299    COMPREPLY=()
300    cur=`_get_cword`
301    prev=${COMP_WORDS[COMP_CWORD-1]}
302
303    case "$prev" in
304        -@(a|A|x|-available|-autobackup|-resizeable))
305            COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
306            return 0
307            ;;
308    esac
309
310    if [[ "$cur" == -* ]]; then
311        COMPREPLY=( $( compgen -W '-A --autobackup --alloc -P \
312            --partial -d --debug -h --help --ignorelockingfailure \
313            -t --test -u --uuid -v --verbose --version -a \
314            --available -x --resizeable -l --logicalvolume \
315            --addtag --deltag' -- $cur ) )
316    else
317        _volumegroups
318    fi
319}
320
321_vgcreate()
322{
323    local cur prev
324
325    COMPREPLY=()
326    cur=`_get_cword`
327    prev=${COMP_WORDS[COMP_CWORD-1]}
328
329    case "$prev" in
330        -@(A|-autobackup))
331            COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
332            return 0
333            ;;
334        -@(M|-metadatatype))
335            COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
336            return 0
337            ;;
338        -@(s|-physicalextentsize))
339            _sizes
340            return 0
341            ;;
342    esac
343
344    if [[ "$cur" == -* ]]; then
345        COMPREPLY=( $( compgen -W '-A --autobackup --addtag \
346            --alloc -d --debug -h --help -l --maxlogicalvolumes \
347            -M --metadatatype -p --maxphysicalvolumes -s \
348            --physicalextentsize -t --test -v --verbose \
349            --version' -- $cur ) )
350    else
351        _args
352        if [ $args -eq 0 ]; then
353            _volumegroups
354        else
355            _physicalvolumes
356        fi
357    fi
358}
359
360_vgremove()
361{
362    local cur
363
364    COMPREPLY=()
365    cur=`_get_cword`
366
367    if [[ "$cur" == -* ]]; then
368        COMPREPLY=( $( compgen -W '-d --debug -h --help -t --test \
369        -v --verbose --version' -- $cur ) )
370    else
371        _volumegroups
372    fi
373}
374
375_vgrename()
376{
377    local cur prev
378
379    COMPREPLY=()
380    cur=`_get_cword`
381    prev=${COMP_WORDS[COMP_CWORD-1]}
382
383    case "$prev" in
384        -@(A|-autobackup))
385            COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
386            return 0
387            ;;
388    esac
389
390    if [[ "$cur" == -* ]]; then
391        COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -h \
392            -? --help -t --test -v --verbose --version' -- $cur ) )
393    else
394        _volumegroups
395    fi
396}
397
398_vgreduce()
399{
400    local cur prev
401
402    COMPREPLY=()
403    cur=`_get_cword`
404    prev=${COMP_WORDS[COMP_CWORD-1]}
405
406    case "$prev" in
407        -@(A|-autobackup))
408            COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
409            return 0
410            ;;
411    esac
412
413    if [[ "$cur" == -* ]]; then
414        COMPREPLY=( $( compgen -W '-a --all -A --autobackup -d \
415            --debug -h --help --removemissing -t --test -v \
416            --verbose --version' -- $cur ) )
417
418    else
419        _args
420        if [ $args -eq 0 ]; then
421            _volumegroups
422        else
423            _physicalvolumes
424        fi
425    fi
426}
427
428_vgextend()
429{
430    local cur prev
431
432    COMPREPLY=()
433    cur=`_get_cword`
434    prev=${COMP_WORDS[COMP_CWORD-1]}
435
436    case "$prev" in
437        -@(A|-autobackup))
438            COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
439            return 0
440            ;;
441        -@(L|-size))
442            _sizes
443            return 0
444            ;;
445    esac
446
447    if [[ "$cur" == -* ]]; then
448        COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -h \
449            -? --help -t --test -v --verbose --version' -- $cur ) )
450    else
451        _args
452        if [ $args -eq 0 ]; then
453            _volumegroups
454        else
455            _physicalvolumes
456        fi
457    fi
458}
459
460_vgport()
461{
462    local cur prev
463
464    COMPREPLY=()
465    cur=`_get_cword`
466
467    if [[ "$cur" == -* ]]; then
468        COMPREPLY=( $( compgen -W '-a --all -d --debug -h \
469            -? --help -v --verbose --version' -- $cur ) )
470    else
471        _volumegroups
472    fi
473}
474
475_vgck()
476{
477    local cur prev
478
479    COMPREPLY=()
480    cur=`_get_cword`
481
482    if [[ "$cur" == -* ]]; then
483        COMPREPLY=( $( compgen -W '-d --debug -h \
484            -? --help -v --verbose --version' -- $cur ) )
485    else
486        _volumegroups
487    fi
488}
489
490_vgconvert()
491{
492    local cur prev
493
494    COMPREPLY=()
495    cur=`_get_cword`
496    prev=${COMP_WORDS[COMP_CWORD-1]}
497
498    case "$prev" in
499        -@(M|-metadatatype))
500            COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
501            return 0
502            ;;
503        --metadatacopies)
504            COMPREPLY=( $( compgen -W '0 1 2' -- $cur ) )
505            return 0
506            ;;
507        --metadatasize)
508            _sizes
509            return 0
510            ;;
511    esac
512
513    if [[ "$cur" == -* ]]; then
514        COMPREPLY=( $( compgen -W '-d --debug -h --help --labelsector \ 
515            -M --metadatatype --metadatacopies --metadatasize \
516            -t --test -v --verbose --version' -- $cur ) )
517    else
518        _volumegroups
519    fi
520}
521
522_vgcfgbackup()
523{
524    local cur prev
525
526    COMPREPLY=()
527    cur=`_get_cword`
528    prev=${COMP_WORDS[COMP_CWORD-1]}
529
530    case "$prev" in
531        -@(f|-file))
532            _filedir
533            return 0
534            ;;
535    esac
536
537    if [[ "$cur" == -* ]]; then
538        COMPREPLY=( $( compgen -W '-d --debug -f --file -h --help \
539            --ignorelockingfailure -P --partial -v --verbose \
540            --version' -- $cur ) )
541    else
542        _volumegroups
543    fi
544}
545
546_vgcfgrestore()
547{
548    local cur prev
549
550    COMPREPLY=()
551    cur=`_get_cword`
552    prev=${COMP_WORDS[COMP_CWORD-1]}
553
554    case "$prev" in
555        -@(f|-file))
556            _filedir
557            return 0
558            ;;
559        -@(M|-metadatatype))
560            COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
561            return 0
562            ;;
563        -@(n|-name))
564            _volumegroups
565            return 0
566            ;;
567    esac
568
569    if [[ "$cur" == -* ]]; then
570        COMPREPLY=( $( compgen -W '-d --debug -f --file -l --list \
571            -h --help -M --Metadatatype -n --name -t --test \
572            -v --verbose --version' -- $cur ) )
573    else
574        _volumegroups
575    fi
576}
577
578_vgmerge()
579{
580    local cur prev
581
582    COMPREPLY=()
583    cur=`_get_cword`
584    prev=${COMP_WORDS[COMP_CWORD-1]}
585
586    case "$prev" in
587        -@(A|-autobackup))
588            COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
589            return 0
590            ;;
591    esac
592
593    if [[ "$cur" == -* ]]; then
594        COMPREPLY=( $( compgen -W '-A --autobackup -d --debug \
595            -h --help -l --list -t --test -v --verbose \
596            --version' -- $cur ) )
597    else
598        _volumegroups
599    fi
600}
601
602_vgsplit()
603{
604    local cur prev
605
606    COMPREPLY=()
607    cur=`_get_cword`
608    prev=${COMP_WORDS[COMP_CWORD-1]}
609
610    case "$prev" in
611        -@(A|-autobackup))
612            COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
613            return 0
614            ;;
615        -@(M|-metadatatype))
616            COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
617            return 0
618            ;;
619    esac
620
621    if [[ "$cur" == -* ]]; then
622        COMPREPLY=( $( compgen -W '-A --autobackup -d --debug \
623            -h --help -l --list -M --metadatatype -t --test \
624            -v --verbose --version' -- $cur ) )
625    else
626        _args
627        if [ $args -eq 0 -o $args -eq 1 ]; then
628            _volumegroups
629        else
630            _physicalvolumes
631        fi
632    fi
633}
634
635_vgmknodes()
636{
637    local cur
638
639    COMPREPLY=()
640    cur=`_get_cword`
641
642    if [[ "$cur" == -* ]]; then
643        COMPREPLY=( $( compgen -W '-d --debug -h --help -v --verbose \
644            --version' -- $cur ) )
645    else
646        _volumegroups
647    fi
648}
649
650_lvscan()
651{
652    local cur
653
654    COMPREPLY=()
655    cur=`_get_cword`
656
657    if [[ "$cur" == -* ]]; then
658        COMPREPLY=( $( compgen -W '-b --blockdevice -d --debug \
659            -h -? --help --ignorelockingfailure -P \
660            --partial -v --verbose --version' -- $cur ) )
661    fi
662}
663
664_lvs()
665{
666    local cur prev
667
668    COMPREPLY=()
669    cur=`_get_cword`
670    prev=${COMP_WORDS[COMP_CWORD-1]}
671
672    case "$prev" in
673        -@(o|O|-options|-sort))
674            COMPREPLY=( $( compgen -W 'lv_uuid lv_name \
675                lv_attr lv_minor lv_size seg_count \
676                origin snap_percent segtype stripes \
677                stripesize chunksize seg_start \
678                seg_size' -- $cur ) )
679            return 0
680            ;;
681        --units)
682            _units
683            return 0
684            ;;
685    esac
686
687    if [[ "$cur" == -* ]]; then
688        COMPREPLY=( $( compgen -W '--aligned -d --debug \
689            -h --help --ignorelockingfailure --noheadings \
690            --nosuffix -o --options -O --sort -P --partial \
691            --segments --separator --unbuffered --units \
692            -v --verbose --version' -- $cur ) )
693    else
694        _logicalvolumes
695    fi
696}
697
698_lvdisplay()
699{
700    local cur prev
701
702    COMPREPLY=()
703    cur=`_get_cword`
704    prev=${COMP_WORDS[COMP_CWORD-1]}
705
706    case "$prev" in
707        --units)
708            _units
709            return 0
710            ;;
711    esac
712
713    if [[ "$cur" == -* ]]; then
714        COMPREPLY=( $( compgen -W '-c --colon -C --columns --units \
715            -P --partial -m --maps -v --verbose -d --debug -h \
716            --help --version' -- $cur ) )
717    else
718        _logicalvolumes
719    fi
720}
721
722_lvchange()
723{
724    local cur prev
725
726    COMPREPLY=()
727    cur=`_get_cword`
728    prev=${COMP_WORDS[COMP_CWORD-1]}
729
730    case "$prev" in
731        -@(a|A|C|M|-available|-autobackup|-continguous|-persistent))
732            COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
733            return 0
734            ;;
735        -@(p|-permission))
736            COMPREPLY=( $( compgen -W 'r rw' -- $cur ) )
737            return 0
738            ;;
739    esac
740
741    if [[ "$cur" == -* ]]; then
742        COMPREPLY=( $( compgen -W '-A --autobackup -a --available \
743            --addtag --alloc -C --contiguous -d --debug --deltag \
744            -f --force -h --help --ignorelockingfailure -M \
745            --persistent --major major --minor minor -P --partial \
746            -p --permission -r --readahead --refresh -t --test \
747            -v --verbose --version' -- $cur ) )
748    else
749        _logicalvolumes
750    fi
751}
752
753_lvcreate()
754{
755    local cur prev
756
757    COMPREPLY=()
758    cur=`_get_cword`
759    prev=${COMP_WORDS[COMP_CWORD-1]}
760
761    case "$prev" in
762        -@(A|C|M|Z|-autobackup|-continguous|-persistent|-zero))
763            COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
764            return 0
765            ;;
766        -@(L|-size))
767            _sizes
768            return 0
769            ;;
770        -@(p|-permission))
771            COMPREPLY=( $( compgen -W 'r rw' -- $cur ) )
772            return 0
773            ;;
774        -@(n|-name))
775            _logicalvolumes
776            return 0
777            ;;
778    esac
779
780    if [[ "$cur" == -* ]]; then
781        COMPREPLY=( $( compgen -W '-A --autobackup --addtag --alloc \
782            -C --contiguous -d --debug -h -? --help -i --stripes \
783            -I --stripesize -l --extents -L --size -M --persistent \
784            --major --minor -n --name -p --permission -r \
785            --readahead -t --test --type -v --verbose -Z --zero \
786            --version' -- $cur ) )
787    else
788        _args
789        if [ $args -eq 0 ]; then
790            _volumegroups
791        else
792            _physicalvolumes
793        fi
794    fi
795}
796
797_lvremove()
798{
799    local cur prev
800
801    COMPREPLY=()
802    cur=`_get_cword`
803    prev=${COMP_WORDS[COMP_CWORD-1]}
804
805    case "$prev" in
806        -@(A|-autobackup))
807            COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
808            return 0
809            ;;
810    esac
811
812    if [[ "$cur" == -* ]]; then
813        COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -f \
814            --force -h -?  --help -t --test -v --verbose \
815            --version' -- $cur ) )
816    else
817        _logicalvolumes
818    fi
819}
820
821_lvrename()
822{
823    local cur prev
824
825    COMPREPLY=()
826    cur=`_get_cword`
827    prev=${COMP_WORDS[COMP_CWORD-1]}
828
829    case "$prev" in
830        -@(A|-autobackup))
831            COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
832            return 0
833            ;;
834    esac
835
836    if [[ "$cur" == -* ]]; then
837        COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -h \
838            -? --help -t --test -v --verbose --version' -- $cur ) )
839    else
840        _logicalvolumes
841    fi
842}
843
844_lvreduce()
845{
846    local cur prev
847
848    COMPREPLY=()
849    cur=`_get_cword`
850    prev=${COMP_WORDS[COMP_CWORD-1]}
851
852    case "$prev" in
853        -@(A|-autobackup))
854            COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
855            return 0
856            ;;
857        -@(L|-size))
858            _sizes
859            return 0
860            ;;
861    esac
862
863    if [[ "$cur" == -* ]]; then
864        COMPREPLY=( $( compgen -W '-A --autobackup -d \
865            --debug -f --force -h --help -l --extents \
866            -L --size -n --nofsck -r --resizefs -t --test \
867            -v --verbose --version' -- $cur ) )
868    else
869        _logicalvolumes
870    fi
871}
872
873_lvresize()
874{
875    local cur prev
876
877    COMPREPLY=()
878    cur=`_get_cword`
879    prev=${COMP_WORDS[COMP_CWORD-1]}
880
881    case "$prev" in
882        -@(A|-autobackup))
883            COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
884            return 0
885            ;;
886        -@(L|-size))
887            _sizes
888            return 0
889            ;;
890    esac
891
892    if [[ "$cur" == -* ]]; then
893        COMPREPLY=( $( compgen -W '-A --autobackup --alloc -d \
894            --debug -h --help -i --stripes -I --stripesize \
895            -l --extents -L --size -n --nofsck -r --resizefs \
896            -t --test --type -v --verbose --version' -- $cur ) )
897    else
898        _args
899        if [ $args -eq 0 ]; then
900            _logicalvolumes
901        else
902            _physicalvolumes
903        fi
904    fi
905}
906
907_lvextend()
908{
909    local cur prev
910
911    COMPREPLY=()
912    cur=`_get_cword`
913    prev=${COMP_WORDS[COMP_CWORD-1]}
914
915    case "$prev" in
916        -@(A|-autobackup))
917            COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
918            return 0
919            ;;
920        -@(L|-size))
921            _sizes
922            return 0
923            ;;
924    esac
925
926    if [[ "$cur" == -* ]]; then
927        COMPREPLY=( $( compgen -W '-A --autobackup --alloc -d \
928            --debug -h --help -i --stripes -I --stripesize \
929            -l --extents -L --size -n --nofsck -r --resizefs \
930            -t --test --type -v --verbose --version' -- $cur ) )
931    else
932        _args
933        if [ $args -eq 0 ]; then
934            _logicalvolumes
935        else
936            _physicalvolumes
937        fi
938    fi
939}