def is_block_device(path):
'''
Confirm device at path is a valid block device node.
:returns: boolean: True if path is a block device, False if not.
'''
return S_ISBLK(stat(path).st_mode)
def inode_type(self, inode, symtab, addr_space):
imode = inode.m('i_mode').v()
type = "UNKN"
if S_ISREG(imode):
type = "REG"
elif S_ISLNK(imode):
type = "LNK"
elif S_ISCHR(imode):
type = "CHR"
elif S_ISBLK(imode):
type = "BLK"
elif S_ISDIR(imode):
type = "DIR"
elif S_ISSOCK(imode):
type = "SOCK"
elif S_ISFIFO(imode):
type = "FIFO"
if symtab.lookup("rdwr_pipe_fops"):
i_fop_offset = inode.get_member_offset('i_fop')
if i_fop_offset > 0:
i_fop = inode.get_member('i_fop').v()
if i_fop == symtab.lookup("rdwr_pipe_fops"):
type = "PIPE"
return type
def is_block(fthing):
"""Take in a file object and checks to see if it's a block or fifo."""
if fthing is sys.stdout or fthing is sys.stdin:
return True
else:
mode = os.stat(fthing.name).st_mode
return S_ISBLK(mode) or S_ISCHR(mode)
def format_device(mode, major, minor):
if S_ISCHR(mode):
kind = 'character'
elif S_ISBLK(mode):
kind = 'block'
else:
kind = 'weird'
return 'device:%s\nmajor: %d\nminor: %d\n' % (kind, major, minor)
def checkRaidPath(self):
logging.info("# Checking for device " + self.getDevPath())
try:
mode = lstat(self.getDevPath()).st_mode
except OSError:
return False
else:
return S_ISBLK(mode)
def is_block_device(self):
"""
Whether this path is a block device.
"""
try:
return S_ISBLK(self.stat().st_mode)
except OSError as e:
if e.errno not in (ENOENT, ENOTDIR):
raise
return False
def __init__(self, device):
""" Function doc """
if not os.path.exists(device):
raise RuntimeError('Cannot find device "%s"' % device)
mode = os.stat(device).st_mode
if not S_ISBLK(mode):
raise RuntimeError('"%s" is not a valid block device' % device)
self._device = device
def filetype_str(mode):
if S_ISCHR(mode):
msg = 'character special device file'
elif S_ISBLK(mode):
msg = 'block special device file'
elif S_ISFIFO(mode):
msg = 'FIFO (named pipe)'
elif S_ISSOCK(mode):
msg = 'socket'
else:
msg = 'unknown file type'
return msg
def is_block_device(self):
"""
Whether this path is a block device.
"""
try:
return S_ISBLK(self.stat().st_mode)
except OSError as e:
if not _ignore_error(e):
raise
# Path doesn't exist or is a broken symlink
# (see https://bitbucket.org/pitrou/pathlib/issue/12/)
return False
def is_block_device(self):
"""
Whether this path is a block device.
"""
try:
return S_ISBLK(self.stat().st_mode)
except OSError as e:
# if e.errno not in (ENOENT, ENOTDIR):
if e_errno_not_in_ENOENT_ENOTDIR(e): ###
raise
# Path doesn't exist or is a broken symlink
# (see https://bitbucket.org/pitrou/pathlib/issue/12/)
return False
def isBlockDevice(self):
"""
Returns whether the underlying path is a block device.
:return: C{True} if it is a block device, C{False} otherwise
:rtype: L{bool}
"""
st = self.statinfo
if not st:
self.restat(False)
st = self.statinfo
if not st:
return False
return S_ISBLK(st.st_mode)
def is_block_device(self):
"""
Whether this path is a block device.
"""
try:
return S_ISBLK(self.stat().st_mode)
except OSError as e:
if e.errno not in _IGNORED_ERROS:
raise
# Path doesn't exist or is a broken symlink
# (see https://bitbucket.org/pitrou/pathlib/issue/12/)
return False
except ValueError:
# Non-encodable path
return False
def is_block_device(self):
"""
Whether this path is a block device.
"""
try:
return S_ISBLK(self.stat().st_mode)
except OSError as e:
if not _ignore_error(e):
raise
# Path doesn't exist or is a broken symlink
# (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
return False
except ValueError:
# Non-encodable path
return False
def file_hl_group(self, file, stat_res=None, stat_error=None):
"""Return the highlight group that `file` should be colored in."""
if stat_error is not None:
return 'Error'
if stat_res is None:
return self.file_hl_group(file, *stat_path(file))
mode = stat_res.st_mode
if not S_ISREG(mode): # Not a regular file
if S_ISLNK(mode):
if self._colors_special.get('ln') == 'target':
# TODO
# resolved = file.resolve()
# if resolved == file:
# # Don't try to resolve another time
# # TODO
# raise Exception('recursion! %s' % resolved)
return self.file_hl_group(file,
*stat_path(file, lstat=False))
else:
ansi_color = self._colors_special.get('ln')
elif S_ISCHR(mode):
ansi_color = self._colors_special.get('cd')
elif S_ISDIR(mode):
ansi_color = self._colors_special.get('di')
elif S_ISFIFO(mode):
ansi_color = self._colors_special.get('pi')
elif S_ISBLK(mode):
ansi_color = self._colors_special.get('bd')
elif S_ISSOCK(mode):
ansi_color = self._colors_special.get('so')
else:
# TODO Does this happen?
return 'Error'
elif mode & S_IXUSR: # Executable
ansi_color = self._colors_special.get('ex')
else: # Regular file
needle = file.name.lower()
for pattern, colorcode in self._colors.items():
if needle.endswith(pattern):
ansi_color = colorcode
break
else:
# TODO Could not find a target color
return None
if ansi_color is None:
return None
hl_group = 'color' + ansi_color.replace(';', '_')
return hl_group
def check_input_files(file_path, force):
"""Check the status of the file.
If the file is empty or doesn't exist AND if the file is NOT a
fifo/block/named pipe then a warning is printed and sys.exit(1) is
called
"""
mode = None
if file_path == '-':
return
try:
mode = os.stat(file_path).st_mode
except OSError:
print("ERROR: Input file %s does not exist" % file_path,
file=sys.stderr)
if not force:
print("NOTE: This can be overridden using the --force argument",
file=sys.stderr)
print("Exiting", file=sys.stderr)
sys.exit(1)
else:
return
# block devices/stdin will be nonzero
if S_ISBLK(mode) or S_ISFIFO(mode) or S_ISCHR(mode):
return
if not os.path.exists(file_path):
print("ERROR: Input file %s does not exist; exiting" % file_path,
file=sys.stderr)
if not force:
print("NOTE: This can be overridden using the --force argument",
file=sys.stderr)
sys.exit(1)
else:
if os.stat(file_path).st_size == 0:
print("ERROR: Input file %s is empty; exiting." % file_path,
file=sys.stderr)
if not force:
print(
"NOTE: This can be overridden using the --force"
" argument",
file=sys.stderr)
sys.exit(1)
def analyze(src, length=io.DEFAULT_BUFFER_SIZE):
md5 = hashlib.md5()
src = os.path.abspath(src)
try:
mode = os.stat(src).st_mode
if S_ISREG(mode):
upsert_file_metadata(src,
stat_types['REGULAR'],
size=os.path.getsize(src),
extension=os.path.splitext(src)[1])
elif S_ISDIR(mode):
upsert_file_metadata(src, stat_types['DIRECTORY'])
elif S_ISCHR(mode):
upsert_file_metadata(src, stat_types['CHAR'])
elif S_ISBLK(mode):
upsert_file_metadata(src, stat_types['BLOCK'])
elif S_ISFIFO(mode):
upsert_file_metadata(src, stat_types['FIFO'])
elif S_ISLNK(mode):
upsert_file_metadata(src, stat_types['SYMLINK'])
elif S_ISSOCK(mode):
upsert_file_metadata(src, stat_types['SOCKET'])
else:
upsert_file_metadata(src, stat_types['UNKNOWN'])
except FileNotFoundError:
mode = os.stat(src, follow_symlinks=False).st_mode
if S_ISLNK(mode):
upsert_file_metadata(src, stat_types['BROKEN_SYMLINK'])
# Just return the MD5 hash of an empty string for non-regular files
if not S_ISREG(mode):
return md5
try:
upsert_file_metadata(src,
mime_type=(magic.from_file(src, mime=True)),
mime_detail=magic.from_file(src))
with io.open(src, mode="rb") as fd:
for chunk in iter(lambda: fd.read(length), b''):
md5.update(chunk)
except OSError:
upsert_file_metadata(src, stat_types['ERROR'])
pass
return md5
def get_file_type(self, root, filename):
filepath = fpath.join(root, filename)
filemode = stat(filepath).st_mode
if S_ISREG(filemode):
return "f"
elif S_ISSOCK(filemode):
return "s"
elif S_ISFIFO(filemode):
return "p"
elif S_ISLNK(filemode):
return "l"
elif S_ISDIR(filemode):
return "d"
elif S_ISCHR(filemode):
return "c"
elif S_ISBLK(filemode):
return "b"
return "?"
def check_valid_file_exists(in_files):
"""Warn if input files are empty or missing.
In a scenario where we expect multiple input files and
are OK with some of them being empty or non-existent,
this check warns to stderr if any input file is empty
or non-existent.
"""
for in_file in in_files:
if os.path.exists(in_file):
mode = os.stat(in_file).st_mode
if os.stat(in_file).st_size > 0 or S_ISBLK(mode) or S_ISFIFO(mode):
return
else:
print('WARNING: Input file %s is empty' % in_file,
file=sys.stderr)
else:
print('WARNING: Input file %s not found' % in_file,
file=sys.stderr)
async def is_block_device(self) -> bool:
"""
Whether this path is a block device.
"""
try:
stat = await self.stat()
return S_ISBLK(stat.st_mode)
except OSError as e:
if not _ignore_error(e):
raise
# Path doesn't exist or is a broken symlink
# (see https://bitbucket.org/pitrou/pathlib/issue/12/)
return False
except ValueError:
# Non-encodable path
return False
def get_ftype_and_perm(mode):
""" Returns a tuple of whether the file is: file(regular file)/dir/slink
/char. spec/block spec/pipe/socket and the permission bits of the file.
If it does not match any of the cases below (it will return "unknown" twice)"""
if S_ISREG(mode):
return "file", S_IMODE(mode)
if S_ISDIR(mode):
return "dir", S_IMODE(mode)
if S_ISLNK(mode):
return "slink", S_IMODE(mode)
if S_ISCHR(mode):
return "character special", S_IMODE(mode)
if S_ISBLK(mode):
return "block special", S_IMODE(mode)
if S_ISFIFO(mode):
return "pipe", S_IMODE(mode)
if S_ISSOCK(mode):
return "socket", S_IMODE(mode)
return "unknown", "unknown"
def check_file_status(file_path):
"""Check the status of the file; if the file is empty or doesn't exist
AND if the file is NOT a fifo/block/named pipe then a warning is printed
and sys.exit(1) is called
"""
mode = os.stat(file_path).st_mode
# block devices will be nonzero
if S_ISBLK(mode) or S_ISFIFO(mode):
return
if not os.path.exists(file_path):
print >>sys.stderr, "ERROR: Input file %s does not exist; exiting" % \
file_path
sys.exit(1)
else:
if os.stat(file_path).st_size == 0:
print >>sys.stderr, "ERROR: Input file %s is empty; exiting." % \
file_path
sys.exit(1)
def validate_blockdev(imgsize):
blockdev = cfg.opts.primary_blockdev
try:
mode = os.stat(blockdev).st_mode
except OSError as e:
print(c.RED(e))
print(
"It looks like you passed the wrong thing to the --primary-blockdev option"
)
exit(1)
if not S_ISBLK(mode):
print(
c.RED(
"File passed as an arg to the --primary-blockdev option is not a block device"
))
print(
"This option is meant to be used to create a VM whose primary storage is a block device like /dev/sdb2"
)
exit(1)
cmd = ['lsblk', '-no', 'size', blockdev]
c.debug("Executing: {}".format(" ".join(cmd)))
try:
blksize = subprocess.check_output(cmd).strip()
except:
print(
c.RED(
"Unexpected error using lsblk to check size of --primary-blockdev device"
))
print(
"This shouldn't happen ... unless you somehow don't have util-linux and the lsblk command"
)
exit(1)
blksize = convert_size_string_to_bytes(blksize)
if imgsize > blksize:
print(
c.YELLOW(
"Aborting because block device '{}' is smaller than projected image size"
.format(blockdev)))
print("Block device size: {} MiB".format(int(blksize / 1024 / 1024)))
print("Image file size: {} MiB".format(int(imgsize / 1024 / 1024)))
exit(1)
def get_ctl(path, mode):
"""get the string to control device access for cgroup
:param path: the device file path
:param mode: either "r" or "rw"
:return: the string to control device access
"""
try:
st = os.stat(path)
except OSError as e:
log.error("Failed to get stat of {}: {}".format(path, str(e)))
raise
t = ""
if S_ISBLK(st.st_mode):
t = "b"
elif S_ISCHR(st.st_mode):
t = "c"
if t and mode in ("r", "rw"):
return "{} {}:{} {}".format(t, os.major(st.st_rdev),
os.minor(st.st_rdev), mode)
raise RuntimeError("Failed to get control string of {}".format(path))
def check_input_files(file_path, force):
"""Check the status of the file.
If the file is empty or doesn't exist AND if the file is NOT a
fifo/block/named pipe then a warning is printed and sys.exit(1) is
called
"""
mode = None
if file_path is '-':
return
try:
mode = os.stat(file_path).st_mode
except OSError:
print >>sys.stderr, "ERROR: Input file %s does not exist" % \
file_path
if not force:
print >> sys.stderr, "Exiting"
sys.exit(1)
else:
return
# block devices will be nonzero
if S_ISBLK(mode) or S_ISFIFO(mode):
return
if not os.path.exists(file_path):
print >>sys.stderr, "ERROR: Input file %s does not exist; exiting" % \
file_path
if not force:
sys.exit(1)
else:
if os.stat(file_path).st_size == 0:
print >>sys.stderr, "ERROR: Input file %s is empty; exiting." % \
file_path
if not force:
sys.exit(1)
def realdev(self):
if self.fs_type in ("none", "tmpfs", "bind"):
return
if self.device is None:
return
if self.device.startswith("LABEL=") or self.device.startswith("UUID="):
try:
_dev = utilities.devices.linux.label_to_dev(
self.device, self.svc.node.devtree)
except ex.Error as exc:
self.status_log(str(exc))
_dev = None
if _dev:
return _dev
return self.device
try:
mode = os.stat(self.device)[ST_MODE]
except:
self.log.debug("can not stat %s", self.device)
return
if os.path.exists(self.device) and S_ISBLK(mode):
dev = self.device
else:
mnt = getmount(self.device)
if self.mounts is None:
self.mounts = Mounts()
mount = self.mounts.has_param("mnt", mnt)
if mount is None:
self.log.debug("can't find dev %s mounted in %s in mnttab",
mnt, self.device)
return None
dev = mount.dev
if dev in ("tmpfs", "shm", "shmfs", "none"):
# bind mounts for ex.
return
return dev
def stat_is_special(attr):
return S_ISCHR(attr.st_mode) or S_ISBLK(attr.st_mode)
def is_up(self):
if self.device is None:
self.status_log("dev is not defined", "info")
return False
if self.mount_point is None:
self.status_log("mnt is not defined", "info")
return False
self.mounts = Mounts()
for dev in [
self.device
] + utilities.devices.linux.udevadm_query_symlink(self.device):
ret = self.mounts.has_mount(dev, self.mount_point)
if ret:
return True
# might be defined as a symlink. Linux display realpaths in /proc/mounts
ret = self.mounts.has_mount(self.device,
os.path.realpath(self.mount_point))
if ret:
return True
# might be defined as a symlink. Linux display realpaths in /proc/mounts
ret = self.mounts.has_mount(os.path.realpath(self.device),
os.path.realpath(self.mount_point))
if ret:
return True
# might be a loop device seen in mounts as its backing file
if self.device.startswith("/dev/loop"):
backfile = utilities.devices.linux.loop_to_file(self.device)
if backfile and self.mounts.has_mount(
backfile, os.path.realpath(self.mount_point)):
return True
# might be a mount by label or uuid
for dev in self.sub_devs():
ret = self.mounts.has_mount(dev, self.mount_point)
if ret:
return True
ret = self.mounts.has_mount(dev,
os.path.realpath(self.mount_point))
if ret:
return True
if dev.startswith("/dev/loop"):
backfile = utilities.devices.linux.loop_to_file(dev)
if backfile and self.mounts.has_mount(
backfile, os.path.realpath(self.mount_point)):
return True
# might be mount using a /dev/mapper/ name too
elements = self.device.split('/')
if len(elements) == 4 and elements[2] != "mapper":
dev = "/dev/mapper/%s-%s" % (elements[2].replace(
'-', '--'), elements[3].replace('-', '--'))
ret = self.mounts.has_mount(dev, self.mount_point)
if ret:
return True
ret = self.mounts.has_mount(dev,
os.path.realpath(self.mount_point))
if ret:
return True
if self.device.startswith(os.sep) and os.path.exists(self.device):
try:
fstat = os.stat(self.device)
mode = fstat[ST_MODE]
except:
self.log.debug("can not stat %s", self.device)
return False
if S_ISREG(mode):
# might be a loopback mount
devs = utilities.devices.linux.file_to_loop(self.device)
for dev in devs:
ret = self.mounts.has_mount(dev, self.mount_point)
if ret:
return True
ret = self.mounts.has_mount(
dev, os.path.realpath(self.mount_point))
if ret:
return True
elif S_ISBLK(mode):
# might be a mount using a /dev/dm-<minor> name too
if os.major(fstat.st_rdev) == self.dm_major:
dev = '/dev/dm-' + str(os.minor(fstat.st_rdev))
ret = self.mounts.has_mount(dev, self.mount_point)
if ret:
return True
ret = self.mounts.has_mount(
dev, os.path.realpath(self.mount_point))
if ret:
return True
elif S_ISDIR(mode):
try:
mnt_fstat = os.stat(self.mount_point)
mnt_ino = mnt_fstat[ST_INO]
except:
self.log.debug("can not stat %s", self.mount_point)
return False
dev_ino = fstat[ST_INO]
if dev_ino == mnt_ino:
return True
return False
def is_device(self):
mode = os.lstat(self._name).st_mode
return S_ISCHR(mode) or S_ISBLK(mode)
def isdev(self):
from stat import S_ISBLK, S_ISCHR
mode = self.__st_mode()
return S_ISBLK(mode) or S_ISCHR(mode)
def isblockdev(self):
from stat import S_ISBLK
return S_ISBLK(self.__st_mode())