Attachment 886452 Details for Bug 1087826 – trace obtained before the trace module dies with the exception included in comment 1

trace obtained before the trace module dies with the exception included in comment 1

trace.log (text/x-log), 15.64 KB, created by Martin Kolman on 2014-04-15 11:57:02 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Martin Kolman

Created: 2014-04-15 11:57:02 UTC

Size: 15.64 KB

patch

obsolete

> --- modulename: pyblock_trace, funcname: <module>
>pyblock_trace.py(1): import block
> --- modulename: __init__, funcname: <module>
>__init__.py(20): import dm
>__init__.py(22): from maps import *
> --- modulename: maps, funcname: <module>
>maps.py(20): class DeviceMapperLogSync:
> --- modulename: maps, funcname: DeviceMapperLogSync
>maps.py(20): class DeviceMapperLogSync:
>maps.py(21):     """Policy for synchronization of a DM Log"""
>maps.py(22):     def set_policy(self, policy=""):
>maps.py(29):     def get_policy(self):
>maps.py(31):     def del_policy(self):
>maps.py(33):     policy = property(get_policy, set_policy, del_policy,\
>maps.py(34):         "policy for synchronization")
>maps.py(36):     def __init__(self, policy=""):
>maps.py(40):     def __str__(self):
>maps.py(43): class DeviceMapperLog:
> --- modulename: maps, funcname: DeviceMapperLog
>maps.py(43): class DeviceMapperLog:
>maps.py(44):     """Base class for device-mapper's "logger" functionality"""
>maps.py(46):     def set_type(self, type):
>maps.py(51):     def get_type(self):
>maps.py(53):     type = property(get_type, set_type, None, "type of dm logger")
>maps.py(55):     def set_sync(self, policy):
>maps.py(61):     def get_sync(self):
>maps.py(63):     sync = property(get_sync, set_sync, None, "dm synchronization policy")
>maps.py(65):     def __init__(self, type="core", sync=DeviceMapperLogSync(), *params):
> --- modulename: maps, funcname: __init__
>maps.py(37):         self.policy = policy
>maps.py(38):         pass
>maps.py(71):     def __str__(self):
>maps.py(77): class CoreLog(DeviceMapperLog):
> --- modulename: maps, funcname: CoreLog
>maps.py(77): class CoreLog(DeviceMapperLog):
>maps.py(78):     """A device-mapper "core" logger"""
>maps.py(79):     def __init__(self, size, sync=""):
>maps.py(83): class DiskLog(DeviceMapperLog):
> --- modulename: maps, funcname: DiskLog
>maps.py(83): class DiskLog(DeviceMapperLog):
>maps.py(84):     """A device-mapper "disk" logger"""
>maps.py(85):     def __init__(self, device, size, sync=True):
>maps.py(89): class DeviceMap:
> --- modulename: maps, funcname: DeviceMap
>maps.py(89): class DeviceMap:
>maps.py(90):     """Base class for a device map"""
>maps.py(91):     def get_start(self):
>maps.py(93):     def set_start(self, value):
>maps.py(98):     start = property(get_start, set_start, None, "start address of map")
>maps.py(100):     def get_size(self):
>maps.py(102):     def set_size(self, value):
>maps.py(106):     size = property(get_size, set_size, None, "number of mapped blocks")
>maps.py(108):     def get_type(self):
>maps.py(110):     def set_type(self, value):
>maps.py(114):     type = property(get_type, set_type, None, "type of map")
>maps.py(116):     def get_parents(self):
>maps.py(118):     def set_parents(self, *parents):
>maps.py(125):     parents = property(get_parents, set_parents, None, \
>maps.py(126):                     "devices this map requires")
>maps.py(128):     def get_required_modules(self):
>maps.py(130):     required_modules = property(get_required_modules, None, None, \
>maps.py(131):                     "the kernel modules this map requires")
>maps.py(133):     def get_table(self):
>maps.py(142):     table = property(get_table, None, None, "the table for this DeviceMap")
>maps.py(144):     def get_name(self):
>maps.py(146):     def set_name(self, name):
>maps.py(150):     name = property(get_name, set_name, None, "the name of the device map")
>maps.py(152):     def get_uuid(self):
>maps.py(154):     def set_uuid(self, uuid):
>maps.py(160):     uuid = property(get_uuid, set_uuid, None, "the uuid of the device map")
>maps.py(162):     def get_map(self):
>maps.py(164):     def set_map(self, map):
>maps.py(166):     map = property(get_map, set_map, None, "the map itself")
>maps.py(168):     def __init__(self, start, size, type=None, modules=[]):
>maps.py(183):     def create(self, name=None):
>maps.py(202): class LinearDeviceMap(DeviceMap):
> --- modulename: maps, funcname: LinearDeviceMap
>maps.py(202): class LinearDeviceMap(DeviceMap):
>maps.py(203):     """map for dm-linear"""
>maps.py(204):     def __init__(self, start, size, bdev, offset):
>maps.py(212):     def _format_linear(self):
>maps.py(215): class PartitionDeviceMap(LinearDeviceMap):
> --- modulename: maps, funcname: PartitionDeviceMap
>maps.py(215): class PartitionDeviceMap(LinearDeviceMap):
>maps.py(216):     """map for a partition on a dm device"""
>maps.py(217):     def __init__(self, start, size, bdev, offset, id):
>maps.py(221): class MirrorDeviceMap(DeviceMap):
> --- modulename: maps, funcname: MirrorDeviceMap
>maps.py(221): class MirrorDeviceMap(DeviceMap):
>maps.py(222):     """map for a dm based raid1"""
>maps.py(223):     def __init__(self, start, size, *devices):
>maps.py(231):     def _format_mirror(self):
>maps.py(237): class StripeDeviceMap(DeviceMap):
> --- modulename: maps, funcname: StripeDeviceMap
>maps.py(237): class StripeDeviceMap(DeviceMap):
>maps.py(238):     """map for a dm based raid0"""
>maps.py(239):     def __init__(self, start, size, stripes, chunksize, *devices):
>maps.py(256):     def _format_stripe(self):
>maps.py(321): class MultipathDeviceMap(DeviceMap):
> --- modulename: maps, funcname: MultipathDeviceMap
>maps.py(321): class MultipathDeviceMap(DeviceMap):
>maps.py(322):     """map for a multipath device"""
>maps.py(323):     def __init__(self, start, size, paths, uuid=None):
>maps.py(332):     def _format_multipath(self):
>maps.py(339): class LVMDeviceMap(DeviceMap):
> --- modulename: maps, funcname: LVMDeviceMap
>maps.py(339): class LVMDeviceMap(DeviceMap):
>maps.py(340):     """map for lvm device"""
>maps.py(341):     pass
>maps.py(343): class MDDevice(DeviceMap):
> --- modulename: maps, funcname: MDDevice
>maps.py(343): class MDDevice(DeviceMap):
>maps.py(344):     """map for lvm device"""
>maps.py(345):     pass
>maps.py(347): class DMTable:
> --- modulename: maps, funcname: DMTable
>maps.py(347): class DMTable:
>maps.py(348):     def __init__(self):
>__init__.py(23): from device import MultiPath, RaidDev, RaidSet, BlockDev, DeviceMaps, \
> --- modulename: device, funcname: <module>
>device.py(21): import sys as _sys
>device.py(22): import os as _os
>device.py(23): import stat as _stat
>device.py(24): import string as _string
>device.py(26): def DeviceMaps():
>device.py(42): def removeDeviceMap(map):
>device.py(51): def map_dev(path):
>device.py(67): def compare_tables(t1, t2):
>device.py(115): class BlockDev:
> --- modulename: device, funcname: BlockDev
>device.py(115): class BlockDev:
>device.py(116):     def get_major(self):
>device.py(118):     def set_major(self, major):
>device.py(120):     major = property(get_major, set_major, None, "major device number")
>device.py(122):     def get_minor(self):
>device.py(124):     def set_minor(self, minor):
>device.py(126):     minor = property(get_minor, set_minor, None, "minor device number")
>device.py(128):     def get_device(self):
>device.py(130):     device = property(get_device, None, None, "device number")
>device.py(132):     def get_dmdev(self):
>device.py(134):     dmdev = property(get_dmdev, None, None, "device number formatted for dm")
>device.py(136):     def get_path(self):
>device.py(138):     def set_path(self, path):
>device.py(140):     path = property(get_path, set_path, None, "path to device node")
>device.py(142):     def get_mode(self):
>device.py(144):     def set_mode(self, mode):
>device.py(146):     mode = property(get_mode, set_mode, None, "mode for device node")
>device.py(148):     def __init__(self, path=None, major=None, minor=None, dev=None):
>device.py(172):     def FromFile(self, path):
>device.py(181):     def FromMajorMinor(self, major, minor):
>device.py(188):     def FromDev(self, dev):
>device.py(196):     def create(self, path=None, mode=None, context=None):
>device.py(213):     def output(self, *args):
>device.py(217):     def remove(self):
>device.py(224): class Device:
> --- modulename: device, funcname: Device
>device.py(224): class Device:
>device.py(225):     def get_major(self):
>device.py(227):     def set_major(self, major):
>device.py(229):     major = property(get_major, set_major, None, "major device number")
>device.py(231):     def get_minor(self):
>device.py(233):     def set_minor(self, major):
>device.py(235):     minor = property(get_major, set_major, None, "major device number")
>device.py(237):     def get_dmdev(self):
>device.py(239):     dmdev = property(get_dmdev, None, None, "device number formatted for dm")
>device.py(241):     def get_map(self):
>device.py(243):     def set_map(self, map):
>device.py(246):     map = property(get_map, set_map, None, "device map for this device")
>device.py(248):     def __init__(self, bdev=BlockDev(), map=None):
> --- modulename: device, funcname: __init__
>device.py(149):         self._BlockDev__context = None
>device.py(151):         self._BlockDev__path = None
>device.py(152):         if not path is None:
>device.py(154):         elif not (major is None and minor is None):
>device.py(156):         elif not dev is None:
>device.py(159):             import dm as _dm
>device.py(160):             self._BlockDev__device = _dm.device(0,0)
>device.py(161):             del _dm
>device.py(165):         self.parents = []
>device.py(166):         self.children = []
>device.py(168):         self.group = None
>device.py(169):         self.group_position = None
>device.py(170):         self.group_siblings = []
>device.py(254):     def FromFile(self, path):
>device.py(258): from UserDict import IterableUserDict as _IUD
>device.py(259): class MPNameCache(_IUD):
> --- modulename: device, funcname: MPNameCache
>device.py(259): class MPNameCache(_IUD):
>device.py(260):     import dm as _dm
>device.py(263):     data = {}
>device.py(264):     for map in _dm.maps():
>dm.c: 1693: not running as root returning empty list
>device.py(266):     del _dm
>device.py(268):     def __init__(self):
>device.py(272):     def new(self):
>device.py(280):     def get(self, name):
>device.py(285):     def try_get(self, name):
>device.py(291):     def put(self, name):
>device.py(296):     def rename(self, old_name, new_name):
>device.py(301): nameCache = MPNameCache()
> --- modulename: device, funcname: __init__
>device.py(269):         _IUD.__init__(self)
> --- modulename: UserDict, funcname: __init__
>UserDict.py(5):         self.data = {}
>UserDict.py(6):         if dict is not None:
>UserDict.py(8):         if len(kwargs):
>device.py(270):         self.data = MPNameCache.data
>device.py(302): del _IUD
>device.py(304): class MultiPath:
> --- modulename: device, funcname: MultiPath
>device.py(304): class MultiPath:
>device.py(305):     def __init__(self, *bdevs):
>device.py(329):     def __del__(self):
>device.py(335):     def firstDevPath(self):
>device.py(340):     def __cmp__(self, other):
>device.py(349):     def checkBdevs(self, bdevs):
>device.py(379):     def get_prefix(self):
>device.py(381):     def set_prefix(self, value):
>device.py(383):     prefix = property(get_prefix, set_prefix, None, \
>device.py(384):         "prefix for path to device nodes")
>device.py(386):     def _set_map_uuid(self, map):
>device.py(390):     def get_PedDevice(self):
>device.py(395):     PedDevice = property(get_PedDevice, None, None, "parted.PedDevice")
>device.py(397):     def get_members(self, descend=True):
>device.py(400):     members = property(get_members, None, None, "members")
>device.py(402):     def get_member_devpaths(self, descend=True):
>device.py(408):     member_devpaths = property(get_member_devpaths, None, None, "member devpaths")
>device.py(409):     def get_bdev(self):
>device.py(418):     bdev = property(get_bdev, None, None, "block.BlockDev")
>device.py(420):     def get_table(self):
>device.py(448):     table = property(get_table, None, None, "block.dm.table")
>device.py(450):     def get_map(self):
>device.py(475):     map = property(get_map, None, None, "block.dm.map")
>device.py(477):     def get_name(self):
>device.py(479):     def set_name(self, name):
>device.py(489):     name = property(get_name, set_name, None, "the name of this MultiPath")
>device.py(491):     def get_parts(self):
>device.py(496):     partitions = property(get_parts, None, None, "this device's partitions")
>device.py(498):     def output(self, *args):
>device.py(502):     def buildPartMaps(self):
>device.py(540):     def buildParts(self):
>device.py(548):     def removeMemberParts(self):
>device.py(555):     def scanMemberParts(self):
>device.py(561):     def activate(self, mknod=False):
>device.py(580):     def deactivate(self):
>device.py(600):     def display(self, space=0, printer=lambda x,y: _sys.stdout.write("%s%s\n" % (x*' ',y))):
>device.py(605): class RaidSet:
> --- modulename: device, funcname: RaidSet
>device.py(605): class RaidSet:
>device.py(606):     def __init__(self, rs, prefix="/dev/mapper/"):
>device.py(617):     def __cmp__(self, other):
>device.py(620):     def get_prefix(self):
>device.py(622):     def set_prefix(self, value):
>device.py(624):     prefix = property(get_prefix, set_prefix, None, \
>device.py(625):         "prefix for path to device nodes")
>device.py(627):     def _set_map_uuid(self, map):
>device.py(632):     def get_PedDevice(self):
>device.py(637):     PedDevice = property(get_PedDevice, None, None, "parted.PedDevice")
>device.py(639):     def get_level(self):
>device.py(647):     level = property(get_level, None, None, "raid level")
>device.py(649):     def get_members(self, descend=True):
>device.py(664):     members = property(get_members, None, None, "members")
>device.py(666):     def get_member_devpaths(self, descend=True):
>device.py(670):     member_devpaths = property(get_member_devpaths, None, None, "member devpaths")
>device.py(672):     def get_spares(self, descend=True):
>device.py(693):     spares = property(get_spares, None, None, "spares")
>device.py(695):     def get_bdev(self):
>device.py(703):     bdev = property(get_bdev, None, None, "block.BlockDev")
>device.py(705):     def get_map(self):
>device.py(723):     map = property(get_map, None, None, "block.dm.map")
>device.py(725):     def get_name(self):
>device.py(727):     def set_name(self, name):
>device.py(739):     name = property(get_name, set_name, None, "this name of this RaidSet")
>device.py(741):     def get_parts(self):
>device.py(744):     partitions = property(get_parts, None, None, "this device's partitions")
>device.py(746):     def get_valid(self):
>device.py(756):     valid = property(get_valid, None, None, "test a raidset for validity")
>device.py(758):     def output(self, *args):
>device.py(762):     def buildParts(self):
>device.py(809):     def removeMemberParts(self):
>device.py(816):     def scanMemberParts(self):
>device.py(823):     def activate(self, degradedOk=False, mknod=False, mkparts=True):
>device.py(848):     def deactivate(self):
>device.py(872):     def display(self, space=0, printer=lambda x,y: _sys.stdout.write("%s%s\n" % (x*' ',y))):
>device.py(877): class RaidDev:
> --- modulename: device, funcname: RaidDev
>device.py(877): class RaidDev:
>device.py(878):     def __init__(self, rd, prefix=None):
>device.py(883):     def get_prefix(self):
>device.py(888):     prefix = property(get_prefix, None, None, "prefix for device node path")
>device.py(890):     def get_bdev(self):
>device.py(895):     bdev = property(get_bdev, None, None, "block.BlockDev")
>device.py(897):     def get_PedDevice(self):
>device.py(902):     PedDevice = property(get_PedDevice, None, None, "parted.PedDevice")
>device.py(904):     def get_devpath(self):
>device.py(906):     devpath = property(get_devpath, None, None, "path relative to /dev")
>device.py(908):     def get_valid(self):
>device.py(913):     valid = property(get_valid, None, None, "test a raiddev for validity")
>device.py(915):     def __cmp__(self, other):
>device.py(970):     def removeParts(self):
>device.py(974):     def scanParts(self):
>device.py(977):     def display(self, space=0, printer=lambda x,y: _sys.stdout.write("%s%s\n" % (x*' ',y))):
>__init__.py(26): _log_ignore = False
>__init__.py(27): _verbose = dm.log_warn
>__init__.py(29): def dm_log(level, file, line, message):
>__init__.py(44): dm.set_logger(dm_log)
>__init__.py(45): del dm_log
>__init__.py(47): import dmraid

Actions: View

Attachments on bug 1087826: 886452