SkidSec WebShell

Server Address : 172.31.38.4

Web Server : Apache/2.4.58 (Ubuntu)

Uname : Linux ip-172-31-38-4 6.14.0-1017-aws #17~24.04.1-Ubuntu SMP Wed Nov 5 10:48:17 UTC 2025 x86_64

PHP Version : 7.4.33

#!/usr/bin/python3 # SPDX-License-Identifier: GPL-2.0-or-later # Copyright (C) 2018-2024 Oracle. All rights reserved. # # Author: Darrick J. Wong <djwong@kernel.org> # Run online scrubbers in parallel, but avoid thrashing. import subprocess import json import threading import time import sys import os import argparse import signal from io import TextIOWrapper retcode = 0 terminate = False def DEVNULL(): '''Return /dev/null in subprocess writable format.''' try: from subprocess import DEVNULL return DEVNULL except ImportError: return open(os.devnull, 'wb') def find_mounts(): '''Map mountpoints to physical disks.''' def find_xfs_mounts(bdev, fs, lastdisk): '''Attach lastdisk to each fs found under bdev.''' if bdev['fstype'] == 'xfs' and bdev['mountpoint'] is not None: mnt = bdev['mountpoint'] if mnt in fs: fs[mnt].add(lastdisk) else: fs[mnt] = set([lastdisk]) if 'children' not in bdev: return for child in bdev['children']: find_xfs_mounts(child, fs, lastdisk) fs = {} cmd=['lsblk', '-o', 'NAME,KNAME,TYPE,FSTYPE,MOUNTPOINT', '-J'] result = subprocess.Popen(cmd, stdout=subprocess.PIPE) result.wait() if result.returncode != 0: return fs sarray = [x.decode(sys.stdout.encoding) for x in result.stdout.readlines()] output = ' '.join(sarray) bdevdata = json.loads(output) # The lsblk output had better be in disks-then-partitions order for bdev in bdevdata['blockdevices']: lastdisk = bdev['kname'] find_xfs_mounts(bdev, fs, lastdisk) return fs def backtick(cmd): '''Generator function that yields lines of a program's stdout.''' p = subprocess.Popen(cmd, stdout = subprocess.PIPE) for line in TextIOWrapper(p.stdout, encoding="utf-8"): yield line.strip() def remove_killfunc(killfuncs, fn): '''Ensure fn is not in killfuncs.''' try: killfuncs.remove(fn) except: pass def run_killable(cmd, stdout, killfuncs): '''Run a killable program. Returns program retcode or -1 if we can't start it.''' try: proc = subprocess.Popen(cmd, stdout = stdout) killfuncs.add(proc.terminate) proc.wait() remove_killfunc(killfuncs, proc.terminate) return proc.returncode except: return -1 # systemd doesn't like unit instance names with slashes in them, so it # replaces them with dashes when it invokes the service. Filesystem paths # need a special --path argument so that dashes do not get mangled. def path_to_serviceunit(path): '''Convert a pathname into a systemd service unit name.''' cmd = ['systemd-escape', '--template', 'xfs_scrub@.service', '--path', path] try: proc = subprocess.Popen(cmd, stdout = subprocess.PIPE) proc.wait() for line in proc.stdout: return line.decode(sys.stdout.encoding).strip() except: return None def systemctl_stop(unitname): '''Stop a systemd unit.''' cmd = ['systemctl', 'stop', unitname] x = subprocess.Popen(cmd) x.wait() def systemctl_start(unitname, killfuncs): '''Start a systemd unit and wait for it to complete.''' stop_fn = None cmd = ['systemctl', 'start', unitname] try: proc = subprocess.Popen(cmd, stdout = DEVNULL()) stop_fn = lambda: systemctl_stop(unitname) killfuncs.add(stop_fn) proc.wait() ret = proc.returncode except: if stop_fn is not None: remove_killfunc(killfuncs, stop_fn) return -1 if ret != 1: remove_killfunc(killfuncs, stop_fn) return ret # If systemctl-start returns 1, it's possible that the service failed # or that dbus/systemd restarted and the client program lost its # connection -- according to the systemctl man page, 1 means "unit not # failed". # # Either way, we switch to polling the service status to try to wait # for the service to end. As of systemd 249, the is-active command # returns any of the following states: active, reloading, inactive, # failed, activating, deactivating, or maintenance. Apparently these # strings are not localized. while True: try: for l in backtick(['systemctl', 'is-active', unitname]): if l == 'failed': remove_killfunc(killfuncs, stop_fn) return 1 if l == 'inactive': remove_killfunc(killfuncs, stop_fn) return 0 except: remove_killfunc(killfuncs, stop_fn) return -1 time.sleep(1) def run_scrub(mnt, cond, running_devs, mntdevs, killfuncs): '''Run a scrub process.''' global retcode, terminate print("Scrubbing %s..." % mnt) sys.stdout.flush() try: if terminate: return # Try it the systemd way unitname = path_to_serviceunit(path) if unitname is not None: ret = systemctl_start(unitname, killfuncs) if ret == 0 or ret == 1: print("Scrubbing %s done, (err=%d)" % (mnt, ret)) sys.stdout.flush() retcode |= ret return if terminate: return # Invoke xfs_scrub manually cmd = ['/usr/sbin/xfs_scrub'] cmd += '-b -n'.split() cmd += [mnt] ret = run_killable(cmd, None, killfuncs) if ret >= 0: print("Scrubbing %s done, (err=%d)" % (mnt, ret)) sys.stdout.flush() retcode |= ret return if terminate: return print("Unable to start scrub tool.") sys.stdout.flush() finally: running_devs -= mntdevs cond.acquire() cond.notify() cond.release() def signal_scrubs(signum, cond): '''Handle termination signals by killing xfs_scrub children.''' global debug, terminate if debug: print('Signal handler called with signal', signum) sys.stdout.flush() terminate = True cond.acquire() cond.notify() cond.release() def wait_for_termination(cond, killfuncs): '''Wait for a child thread to terminate. Returns True if we should abort the program, False otherwise.''' global debug, terminate if debug: print('waiting for threads to terminate') sys.stdout.flush() cond.acquire() try: cond.wait() except KeyboardInterrupt: terminate = True cond.release() if not terminate: return False print("Terminating...") sys.stdout.flush() while len(killfuncs) > 0: fn = killfuncs.pop() fn() return True def main(): '''Find mounts, schedule scrub runs.''' def thr(mnt, devs): a = (mnt, cond, running_devs, devs, killfuncs) thr = threading.Thread(target = run_scrub, args = a) thr.start() global retcode, terminate parser = argparse.ArgumentParser( \ description = "Scrub all mounted XFS filesystems.") parser.add_argument("-V", help = "Report version and exit.", \ action = "store_true") args = parser.parse_args() if args.V: print("xfs_scrub_all version 6.6.0") sys.exit(0) fs = find_mounts() # Tail the journal if we ourselves aren't a service... journalthread = None if 'SERVICE_MODE' not in os.environ: try: cmd=['journalctl', '--no-pager', '-q', '-S', 'now', \ '-f', '-u', 'xfs_scrub@*', '-o', \ 'cat'] journalthread = subprocess.Popen(cmd) except: pass # Schedule scrub jobs... running_devs = set() killfuncs = set() cond = threading.Condition() signal.signal(signal.SIGINT, lambda s, f: signal_scrubs(s, cond)) signal.signal(signal.SIGTERM, lambda s, f: signal_scrubs(s, cond)) while len(fs) > 0: if len(running_devs) == 0: mnt, devs = fs.popitem() running_devs.update(devs) thr(mnt, devs) poppers = set() for mnt in fs: devs = fs[mnt] can_run = True for dev in devs: if dev in running_devs: can_run = False break if can_run: running_devs.update(devs) poppers.add(mnt) thr(mnt, devs) for p in poppers: fs.pop(p) # Wait for one thread to finish if wait_for_termination(cond, killfuncs): break # Wait for the rest of the threads to finish while len(killfuncs) > 0: wait_for_termination(cond, killfuncs) if journalthread is not None: journalthread.terminate() # See the service mode comments in xfs_scrub.c for why we do this. if 'SERVICE_MODE' in os.environ: time.sleep(2) if retcode != 0: retcode = 1 sys.exit(retcode) if __name__ == '__main__': main()