mirror of
git://sourceware.org/git/lvm2.git
synced 2024-12-26 03:22:12 +03:00
fcbef05aae
Hmm rpmlint suggest fsf is using a different address these days, so lets keep it up-to-date
630 lines
14 KiB
Plaintext
630 lines
14 KiB
Plaintext
# Copyright (C) 2011 Red Hat, Inc. All rights reserved.
|
|
# This file is part of LVM2.
|
|
|
|
# This copyrighted material is made available to anyone wishing to use,
|
|
# modify, copy, or redistribute it subject to the terms and conditions
|
|
# of the GNU Lesser General Public License v.2.1.
|
|
|
|
# You should have received a copy of the GNU Lesser General Public License
|
|
# along with this program; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
#
|
|
# Author(s):
|
|
# Jonathan Brassow <jbrassow@redhat.com>
|
|
#
|
|
# Copy this file to ~/.gdbinit or <working_dir>/.gdbinit
|
|
|
|
printf "\n\n"
|
|
printf "Loading commands:\n"
|
|
printf " - dm_list_size <list ptr>\n"
|
|
printf " - pv_dev_name <PV ptr>\n"
|
|
printf " - first_seg <LV ptr>\n"
|
|
printf " - lv_status <LV ptr>\n"
|
|
printf " - lv_status_r <LV ptr>\n"
|
|
printf " - lv_is_mirrored <LV ptr>\n"
|
|
printf " - seg_item <seg ptr> <index>\n"
|
|
printf " - seg_status <seg ptr>\n"
|
|
printf " - segs_using_this_lv <seg ptr>\n"
|
|
printf " - seg_pvs <list ptr>\n"
|
|
printf " - \n"
|
|
printf "Use 'help <command>' for more info\n"
|
|
printf "\n\n"
|
|
printf "Popular breakpoints:\n"
|
|
printf "break _alloc_image_components\n"
|
|
printf "run --repair --use-policies vg/lv\n"
|
|
printf "\n\n"
|
|
|
|
set follow-fork-mode child
|
|
|
|
# Conventions:
|
|
# foo : function named 'foo' available to user
|
|
# __foo : an internal function
|
|
#
|
|
# External functions should have a corresponding 'document'
|
|
# section. Internal functions should have leading comments
|
|
|
|
|
|
|
|
define dm_list_size
|
|
set $_DLS_list_head = (struct dm_list *)$arg0
|
|
set $_DLS_list = $_DLS_list_head->n
|
|
set $_DLS_size = 0
|
|
|
|
while (($_DLS_list != $_DLS_list_head) && ($_DLS_size < 100))
|
|
set $_DLS_list = $_DLS_list->n
|
|
set $_DLS_size++
|
|
end
|
|
|
|
printf "%d list items\n", $_DLS_size
|
|
end
|
|
|
|
document dm_list_size
|
|
Returns the number of elements in the dm_list
|
|
|
|
Usage: dm_list_size <list ptr>
|
|
end
|
|
|
|
define pv_dev_name
|
|
set $_PDN_pv = (struct physical_volume *)$arg0
|
|
set $_PDN_dev = $_PDN_pv->dev
|
|
set $_PDN_strl = (struct str_list *)$_PDN_dev->aliases.n
|
|
|
|
printf "%s\n", $_PDN_strl->str
|
|
end
|
|
|
|
document pv_dev_name
|
|
Print the name of the PV for the given PV pointer
|
|
|
|
Usage: pv_dev_name <PV ptr>
|
|
end
|
|
|
|
define seg_pvs
|
|
set $_SP_list_head = (struct dm_list *)$arg0
|
|
set $_SP_list = $_SP_list_head->n
|
|
|
|
while (($_SP_list != $_SP_list_head) && ($_SP_size < 100))
|
|
set $_SP_spv = (struct seg_pvs *)$_SP_list
|
|
|
|
printf "* Can't print PV list\n"
|
|
|
|
set $_SP_list = $_SP_list->n
|
|
end
|
|
|
|
printf "%d list items\n", $_SP_size
|
|
end
|
|
|
|
document seg_pvs
|
|
Print the elements of a seg_pvs list
|
|
|
|
Usage: seg_pvs <list ptr>
|
|
end
|
|
|
|
#
|
|
# __first_seg <return> <LV>
|
|
define __first_seg
|
|
set $arg0 = 0x0
|
|
set $_FS_lv = (struct logical_volume *)$arg1
|
|
|
|
if ($_FS_lv->segments.n != &$_FS_lv->segments)
|
|
set $arg0 = (struct lv_segment *)$_FS_lv->segments.n
|
|
end
|
|
end
|
|
|
|
define first_seg
|
|
set $_seg = 0
|
|
set $_lv=(struct logical_volume *)$arg0
|
|
|
|
__first_seg $_seg $_lv
|
|
|
|
if ($_seg)
|
|
p $_seg
|
|
else
|
|
printf "No segments (list empty)\n"
|
|
end
|
|
end
|
|
|
|
document first_seg
|
|
Returns the pointer to the first segment of an LV
|
|
|
|
Usage: first_seg <LV ptr>
|
|
|
|
WARNING: If the list pointer in 'struct lv_segment' moves,
|
|
this function will be wrong.
|
|
end
|
|
|
|
#
|
|
# __seg_type <return> <seg> <index>
|
|
define __seg_type
|
|
set $arg0 = 0x0
|
|
set $_ST_seg = (struct lv_segment *)$arg1
|
|
set $_ST_index= $arg2
|
|
set $_ST_area = $_ST_seg->areas[$_ST_index]
|
|
set $_ST_type = $_ST_area.type
|
|
|
|
set $arg0 = $_ST_type
|
|
end
|
|
|
|
#
|
|
# __seg_item <return> <seg> <index>
|
|
define __seg_item
|
|
set $arg0 = 0x0
|
|
set $_SI_seg = (struct lv_segment *)$arg1
|
|
set $_SI_index= $arg2
|
|
|
|
if ($_SI_index < $_SI_seg->area_count)
|
|
set $_SI_area = $_SI_seg->areas[$_SI_index]
|
|
set $_SI_type = $_SI_area.type
|
|
|
|
if ($_SI_type == AREA_PV)
|
|
set $arg0 = $_SI_area.u.pv.pvseg->pv
|
|
else
|
|
if ($_SI_type == AREA_LV)
|
|
set $arg0 = $_SI_area.u.lv.lv
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
#
|
|
# __seg_metaitem <return> <seg> <index>
|
|
define __seg_metaitem
|
|
set $arg0 = 0x0
|
|
set $_SMI_seg = (struct lv_segment *)$arg1
|
|
set $_SMI_index= $arg2
|
|
|
|
if (($_SMI_index < $_SMI_seg->area_count) && $_SMI_seg->meta_areas)
|
|
set $_SMI_area = $_SMI_seg->meta_areas[$_SMI_index]
|
|
set $_SMI_type = $_SMI_area.type
|
|
|
|
if ($_SMI_type == AREA_PV)
|
|
set $arg0 = $_SMI_area.u.pv.pvseg->pv
|
|
else
|
|
if ($_SMI_type == AREA_LV)
|
|
set $arg0 = $_SMI_area.u.lv.lv
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
define seg_item
|
|
set $_item = 0x0
|
|
|
|
__seg_item $_item $arg0 $arg1
|
|
if ($_item)
|
|
p $_item
|
|
else
|
|
printf "AREA_UNASSIGNED or invalid\n"
|
|
end
|
|
end
|
|
|
|
define seg_metaitem
|
|
set $_metaitem = 0x0
|
|
|
|
__seg_metaitem $_metaitem $arg0 $arg1
|
|
if ($_metaitem)
|
|
p $_metaitem
|
|
else
|
|
printf "AREA_UNASSIGNED or invalid\n"
|
|
end
|
|
end
|
|
|
|
document seg_item
|
|
Returns the pointer to the LV or PV for the indexed area of a segment
|
|
|
|
Usage: seg_item <struct lv_segment *> <index>
|
|
|
|
Example - Getting to the sub-lv of a mirror:
|
|
(gdb) p lv->name
|
|
$1 = 0x712548 "lv"
|
|
|
|
(gdb) first_seg lv
|
|
$2 = (struct lv_segment *) 0x7128b8
|
|
|
|
(gdb) seg_item $2 0
|
|
$3 = (struct logical_volume *) 0x712688
|
|
|
|
(gdb) p $3->name
|
|
$4 = 0x712770 "lv_mimage_0"
|
|
end
|
|
|
|
define __status
|
|
set $_s_status = $arg0->status
|
|
|
|
# Constants defined in metadata-exported.h
|
|
|
|
# if ($_s_status & RAID)
|
|
if ($_s_status & 0x0000000100000000LU)
|
|
set $_s_status = $_s_status & ~0x0000000100000000LU
|
|
printf " RAID"
|
|
end
|
|
# if ($_s_status & RAID_META)
|
|
if ($_s_status & 0x0000000200000000LU)
|
|
set $_s_status = $_s_status & ~0x0000000200000000LU
|
|
printf " RAID_META"
|
|
end
|
|
# if ($_s_status & RAID_IMAGE)
|
|
if ($_s_status & 0x0000000400000000LU)
|
|
set $_s_status = $_s_status & ~0x0000000400000000LU
|
|
printf " RAID_IMAGE"
|
|
end
|
|
# if ($_s_status & MIRRORED)
|
|
if ($_s_status & 0x00008000U)
|
|
set $_s_status = $_s_status & ~0x00008000U
|
|
printf " MIRRORED"
|
|
end
|
|
# if ($_s_status & MIRROR_LOG)
|
|
if ($_s_status & 0x00020000U)
|
|
set $_s_status = $_s_status & ~0x00020000U
|
|
printf " MIRROR_LOG"
|
|
end
|
|
# if ($_s_status & MIRROR_IMAGE)
|
|
if ($_s_status & 0x00040000U)
|
|
set $_s_status = $_s_status & ~0x00040000U
|
|
printf " MIRROR_IMAGE"
|
|
end
|
|
# if ($_s_status & VISIBLE_LV)
|
|
if ($_s_status & 0x00000040U)
|
|
printf " VISIBLE_LV"
|
|
set $_s_status = $_s_status & ~0x00000040U
|
|
else
|
|
printf " *HIDDEN_LV*"
|
|
end
|
|
# if ($_s_status & FIXED_MINOR)
|
|
if ($_s_status & 0x00000080U)
|
|
set $_s_status = $_s_status & ~0x00000080U
|
|
printf " FIXED_MINOR"
|
|
end
|
|
# if ($_s_status & LVM_READ)
|
|
if ($_s_status & 0x00000100U)
|
|
set $_s_status = $_s_status & ~0x00000100U
|
|
printf " LVM_READ"
|
|
end
|
|
# if ($_s_status & LVM_WRITE)
|
|
if ($_s_status & 0x00000200U)
|
|
set $_s_status = $_s_status & ~0x00000200U
|
|
printf " LVM_WRITE"
|
|
end
|
|
# if ($_s_status & SNAPSHOT)
|
|
if ($_s_status & 0x00001000U)
|
|
set $_s_status = $_s_status & ~0x00001000U
|
|
printf " SNAPSHOT"
|
|
end
|
|
# if ($_s_status & PVMOVE)
|
|
if ($_s_status & 0x00002000U)
|
|
set $_s_status = $_s_status & ~0x00002000U
|
|
printf " PVMOVE"
|
|
end
|
|
# if ($_s_status & LOCKED)
|
|
if ($_s_status & 0x00004000U)
|
|
set $_s_status = $_s_status & ~0x00004000U
|
|
printf " LOCKED"
|
|
end
|
|
# if ($_s_status & LV_NOTSYNCED)
|
|
if ($_s_status & 0x00080000U)
|
|
set $_s_status = $_s_status & ~0x00080000U
|
|
printf " LV_NOTSYNCED"
|
|
end
|
|
# if ($_s_status & CONVERTING)
|
|
if ($_s_status & 0x00400000U)
|
|
set $_s_status = $_s_status & ~0x00400000U
|
|
printf " CONVERTING"
|
|
end
|
|
# if ($_s_status & LV_REBUILD)
|
|
if ($_s_status & 0x100000U)
|
|
set $_s_status = $_s_status & ~0x100000U
|
|
printf " LV_REBUILD"
|
|
end
|
|
# if ($_s_status & PARTIAL_LV)
|
|
if ($_s_status & 0x1000000U)
|
|
set $_s_status = $_s_status & ~0x1000000U
|
|
printf " PARTIAL_LV"
|
|
end
|
|
# if ($_s_status & MERGING)
|
|
if ($_s_status & 0x10000000U)
|
|
set $_s_status = $_s_status & ~0x10000000U
|
|
printf " MERGING"
|
|
end
|
|
# if ($_s_status & LV_WRITEMOSTLY)
|
|
if ($_s_status & 0x10000000000U)
|
|
set $_s_status = $_s_status & ~0x10000000000U
|
|
printf " LV_WRITEMOSTLY"
|
|
end
|
|
|
|
if ($_s_status)
|
|
printf " 0x%x", $_s_status
|
|
end
|
|
end
|
|
|
|
#
|
|
# __print_indent <num indents> [No marks]
|
|
define __print_indent
|
|
set $_PI_indent = $arg0
|
|
set $_PI_lead_mark = 0
|
|
|
|
while ($_PI_indent)
|
|
if ($_PI_indent == 1)
|
|
if ($argc > 1)
|
|
if ($_PI_lead_mark)
|
|
printf " "
|
|
else
|
|
printf "| "
|
|
end
|
|
else
|
|
printf "|-----> "
|
|
end
|
|
else
|
|
printf "| "
|
|
set $_PI_lead_mark = 1
|
|
end
|
|
set $_PI_indent--
|
|
end
|
|
end
|
|
|
|
define lv_status
|
|
# Use __lv because we don't want to overwrite higher functions
|
|
set $__lv = (struct logical_volume *)$arg0
|
|
|
|
if ($argc == 2)
|
|
__print_indent $arg1
|
|
end
|
|
printf "%s->status:", $__lv->name
|
|
__status $__lv
|
|
printf "\n"
|
|
end
|
|
|
|
document lv_status
|
|
Display the flags that are set on an LV.
|
|
|
|
Usage: lv_status <LV ptr>
|
|
end
|
|
|
|
define seg_status
|
|
set $_seg=(struct lv_segment *)$arg0
|
|
|
|
if ($argc == 2)
|
|
__print_indent $arg1 1
|
|
end
|
|
printf "[ (%s) seg->status:", $_seg->lv->name
|
|
__status $_seg
|
|
printf " ]\n"
|
|
end
|
|
|
|
document seg_status
|
|
Display the flags that are set on an lv_segment.
|
|
|
|
Usage: seg_status <(struct lv_segment *)>
|
|
end
|
|
|
|
#
|
|
# get_only_segment_using_this_lv <return> <LV>
|
|
define __get_only_segment_using_this_lv
|
|
set $arg0 = 0x0
|
|
set $_lv=(struct logical_volume *)$arg1
|
|
set $_seg_list_head = &$_lv->segs_using_this_lv
|
|
set $_s = $_lv->segs_using_this_lv.n
|
|
set $_i = 0
|
|
|
|
while (($_s != $_seg_list_head) && ($_i < 100))
|
|
set $_seg_list = (struct seg_list *)$_s
|
|
set $_seg = (struct lv_segment *)$_seg_list->seg
|
|
|
|
set $_i++
|
|
set $_s = $_s->n
|
|
end
|
|
|
|
if ($_i > 1)
|
|
printf "More than %s using %s\n", ($_i > 99) ? "100 segments" : "one segment", $_lv->name
|
|
end
|
|
if ($_i == 1)
|
|
set $arg0 = $_seg
|
|
end
|
|
end
|
|
|
|
define segs_using_this_lv
|
|
set $_lv=(struct logical_volume *)$arg0
|
|
set $_seg_list_head = &$_lv->segs_using_this_lv
|
|
set $_s = $_lv->segs_using_this_lv.n
|
|
set $_i = 0
|
|
|
|
if ($_s != $_seg_list_head)
|
|
printf "Segments using %s\n", $_lv->name
|
|
else
|
|
printf "No segments using %s\n", $_lv->name
|
|
end
|
|
while ($_s != $_seg_list_head)
|
|
set $_seg_list = (struct seg_list *)$_s
|
|
set $_seg = (struct lv_segment *)$_seg_list->seg
|
|
printf " %d) seg: %p", $_i, $_seg
|
|
if ($_seg->lv < 0x200)
|
|
printf " [BAD LV POINTER FROM THIS SEG]\n"
|
|
else
|
|
printf " [seg found in %s]\n", $_seg->lv->name
|
|
end
|
|
set $_i++
|
|
set $_s = $_s->n
|
|
end
|
|
end
|
|
|
|
document segs_using_this_lv
|
|
Display the segments (and their associated LV) using an LV
|
|
|
|
Usage: segs_using_this_lv <LV ptr>
|
|
|
|
Example:
|
|
(gdb) lv_is_mirrored lv
|
|
lv is mirrored ('core' log)
|
|
|
|
(gdb) segs_using_this_lv lv
|
|
No segments using lv
|
|
|
|
(gdb) first_seg lv
|
|
$1 = (struct lv_segment *) 0x92d360
|
|
|
|
(gdb) seg_item $1 0
|
|
$2 = (struct logical_volume *) 0x928f58
|
|
|
|
(gdb) segs_using_this_lv $2
|
|
Segments using lv_mimage_0
|
|
0) seg: 0x92d360 [seg found in lv]
|
|
end
|
|
|
|
#
|
|
# __next_area_index <return> <seg> <seg_item>
|
|
define __next_area_index
|
|
set $arg0 = 0x0
|
|
set $_seg = (struct lv_segment *)$arg1
|
|
set $_item = 0x0
|
|
set $_i = 0
|
|
|
|
__seg_item $_item $_seg $_i
|
|
while ($_item && ($_item != $arg2))
|
|
set $_i++
|
|
__seg_item $_item $_seg $_i
|
|
end
|
|
|
|
# $_i points to current, now get next (if there)
|
|
set $_i++
|
|
__seg_item $_item $_seg $_i
|
|
|
|
if ($_item)
|
|
set $arg0 = $_i
|
|
end
|
|
end
|
|
|
|
#
|
|
# __lv_status_r <LV>
|
|
# Decend tree, printing LV and seg status as we go. This
|
|
# performs a depth first approach (but can't come up)
|
|
#
|
|
# or
|
|
#
|
|
# __lv_status_r <sub_lv> <seg using sub_lv>
|
|
# Try continuing decent of tree by first shifting to the
|
|
# next 'area' in the seg ($arg1). If no more areas, then
|
|
# try going to the next segment.
|
|
define __lv_status_r
|
|
if ($argc == 1)
|
|
set $_lv=(struct logical_volume *)$arg0
|
|
set $_seg_list_head = &$_lv->segments
|
|
set $_s = $_lv->segments.n
|
|
set $_area_index = 0
|
|
|
|
# printf "\n"
|
|
lv_status $_lv $indent
|
|
else
|
|
set $_seg = (struct lv_segment *)$arg1
|
|
|
|
__next_area_index $_area_index $_seg $arg0
|
|
|
|
# Don't fuck this up. We need the next two lines here.
|
|
set $_lv=(struct logical_volume *)$_seg->lv
|
|
set $_seg_list_head = &$_lv->segments
|
|
set $_s = (struct dm_list *)$_seg
|
|
|
|
if (!$_area_index)
|
|
set $_s = $_s->n
|
|
end
|
|
end
|
|
|
|
if ($_s == $_seg_list_head)
|
|
if ($argc == 1)
|
|
__print_indent $indent 1
|
|
printf "[ No segments for %s ]\n", $_lv->name
|
|
end
|
|
__get_only_segment_using_this_lv $_seg $_lv
|
|
|
|
if ($_seg && $indent)
|
|
set $indent--
|
|
__lv_status_r $_lv $_seg
|
|
end
|
|
else
|
|
set $_seg = (struct lv_segment *)$_s
|
|
set $_type = 0x0
|
|
|
|
if (!$_area_index)
|
|
seg_status $_seg $indent
|
|
end
|
|
__seg_type $_type $_seg $_area_index
|
|
if ($_type == AREA_LV)
|
|
set $indent++
|
|
|
|
__seg_metaitem $_lv $_seg $_area_index
|
|
if ($_lv)
|
|
set $rindent = $indent
|
|
set $rseg = $_seg
|
|
set $rarea_index = $_area_index
|
|
set $rlv = $_lv
|
|
|
|
__lv_status_r $_lv
|
|
|
|
set $indent = $rindent
|
|
set $_seg = $rseg
|
|
set $_area_index = $rarea_index
|
|
set $_lv = $rlv
|
|
end
|
|
|
|
__seg_item $_lv $_seg $_area_index
|
|
__lv_status_r $_lv
|
|
else
|
|
if ($_seg->log_lv)
|
|
set $indent++
|
|
set $_log_seg = 0x0
|
|
|
|
__first_seg $_log_seg $_seg->log_lv
|
|
lv_status $_seg->log_lv $indent
|
|
seg_status $_log_seg $indent
|
|
|
|
set $indent--
|
|
end
|
|
__get_only_segment_using_this_lv $_seg $_lv
|
|
if ($_seg)
|
|
set $indent--
|
|
__lv_status_r $_lv $_seg
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
define lv_status_r
|
|
set $indent = 0
|
|
__lv_status_r $arg0
|
|
end
|
|
|
|
document lv_status_r
|
|
Display the status flags of an LV and its sub_lvs.
|
|
|
|
Usage: lv_status_r <LV ptr>
|
|
|
|
This function is useful for checking that all the LVs that
|
|
compose a logical volume have the correct flags set (and also
|
|
their associated lv_segments)
|
|
end
|
|
|
|
define lv_is_mirrored
|
|
set $_lv=(struct logical_volume *)$arg0
|
|
set $_fs=(struct lv_segment *)$_lv->segments.n
|
|
set $_log_lv=(struct logical_volume *)$_fs->log_lv
|
|
|
|
# if ($_lv->status & MIRRORED)
|
|
if ($_lv->status & 0x00008000U)
|
|
printf "%s is mirrored (", $_lv->name
|
|
if ($_log_lv)
|
|
if ($_log_lv->status & 0x00008000U)
|
|
printf "'mirrored' log)\n"
|
|
else
|
|
printf "'disk' log)\n"
|
|
end
|
|
else
|
|
printf "'core' log)\n"
|
|
end
|
|
else
|
|
printf "%s is not mirrored\n", $_lv->name
|
|
end
|
|
end
|
|
|
|
document lv_is_mirrored
|
|
Report whether the given LV is mirrored (and its log type).
|
|
|
|
Usage: lv_is_mirrored <LV ptr>
|
|
end
|