mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-22 02:33:06 +01:00
277 lines
10 KiB
Plaintext
277 lines
10 KiB
Plaintext
|
#!/usr/bin/env python
|
||
|
|
|
||
|
|
import os
|
||
|
|
import re
|
||
|
|
import sys
|
||
|
|
|
||
|
|
def _write_message(kind, message):
|
||
|
|
import inspect, os, sys
|
||
|
|
|
||
|
|
# Get the file/line where this message was generated.
|
||
|
|
f = inspect.currentframe()
|
||
|
|
# Step out of _write_message, and then out of wrapper.
|
||
|
|
f = f.f_back.f_back
|
||
|
|
file,line,_,_,_ = inspect.getframeinfo(f)
|
||
|
|
location = '%s:%d' % (os.path.basename(file), line)
|
||
|
|
|
||
|
|
print >>sys.stderr, '%s: %s: %s' % (location, kind, message)
|
||
|
|
|
||
|
|
note = lambda message: _write_message('note', message)
|
||
|
|
warning = lambda message: _write_message('warning', message)
|
||
|
|
error = lambda message: (_write_message('error', message), sys.exit(1))
|
||
|
|
|
||
|
|
def re_full_match(pattern, str):
|
||
|
|
m = re.match(pattern, str)
|
||
|
|
if m and m.end() != len(str):
|
||
|
|
m = None
|
||
|
|
return m
|
||
|
|
|
||
|
|
def parse_time(value):
|
||
|
|
minutes,value = value.split(':',1)
|
||
|
|
if '.' in value:
|
||
|
|
seconds,fseconds = value.split('.',1)
|
||
|
|
else:
|
||
|
|
seconds = value
|
||
|
|
return int(minutes) * 60 + int(seconds) + float('.'+fseconds)
|
||
|
|
|
||
|
|
def extractExecutable(command):
|
||
|
|
"""extractExecutable - Given a string representing a command line, attempt
|
||
|
|
to extract the executable path, even if it includes spaces."""
|
||
|
|
|
||
|
|
# Split into potential arguments.
|
||
|
|
args = command.split(' ')
|
||
|
|
|
||
|
|
# Scanning from the beginning, try to see if the first N args, when joined,
|
||
|
|
# exist. If so that's probably the executable.
|
||
|
|
for i in range(1,len(args)):
|
||
|
|
cmd = ' '.join(args[:i])
|
||
|
|
if os.path.exists(cmd):
|
||
|
|
return cmd
|
||
|
|
|
||
|
|
# Otherwise give up and return the first "argument".
|
||
|
|
return args[0]
|
||
|
|
|
||
|
|
class Struct:
|
||
|
|
def __init__(self, **kwargs):
|
||
|
|
self.fields = kwargs.keys()
|
||
|
|
self.__dict__.update(kwargs)
|
||
|
|
|
||
|
|
def __repr__(self):
|
||
|
|
return 'Struct(%s)' % ', '.join(['%s=%r' % (k,getattr(self,k))
|
||
|
|
for k in self.fields])
|
||
|
|
|
||
|
|
kExpectedPSFields = [('PID', int, 'pid'),
|
||
|
|
('USER', str, 'user'),
|
||
|
|
('COMMAND', str, 'command'),
|
||
|
|
('%CPU', float, 'cpu_percent'),
|
||
|
|
('TIME', parse_time, 'cpu_time'),
|
||
|
|
('VSZ', int, 'vmem_size'),
|
||
|
|
('RSS', int, 'rss')]
|
||
|
|
def getProcessTable():
|
||
|
|
import subprocess
|
||
|
|
p = subprocess.Popen(['ps', 'aux'], stdout=subprocess.PIPE,
|
||
|
|
stderr=subprocess.PIPE)
|
||
|
|
out,err = p.communicate()
|
||
|
|
res = p.wait()
|
||
|
|
if p.wait():
|
||
|
|
error('unable to get process table')
|
||
|
|
elif err.strip():
|
||
|
|
error('unable to get process table: %s' % err)
|
||
|
|
|
||
|
|
lns = out.split('\n')
|
||
|
|
it = iter(lns)
|
||
|
|
header = it.next().split()
|
||
|
|
numRows = len(header)
|
||
|
|
|
||
|
|
# Make sure we have the expected fields.
|
||
|
|
indexes = []
|
||
|
|
for field in kExpectedPSFields:
|
||
|
|
try:
|
||
|
|
indexes.append(header.index(field[0]))
|
||
|
|
except:
|
||
|
|
if opts.debug:
|
||
|
|
raise
|
||
|
|
error('unable to get process table, no %r field.' % field[0])
|
||
|
|
|
||
|
|
table = []
|
||
|
|
for i,ln in enumerate(it):
|
||
|
|
if not ln.strip():
|
||
|
|
continue
|
||
|
|
|
||
|
|
fields = ln.split(None, numRows - 1)
|
||
|
|
if len(fields) != numRows:
|
||
|
|
warning('unable to process row: %r' % ln)
|
||
|
|
continue
|
||
|
|
|
||
|
|
record = {}
|
||
|
|
for field,idx in zip(kExpectedPSFields, indexes):
|
||
|
|
value = fields[idx]
|
||
|
|
try:
|
||
|
|
record[field[2]] = field[1](value)
|
||
|
|
except:
|
||
|
|
if opts.debug:
|
||
|
|
raise
|
||
|
|
warning('unable to process %r in row: %r' % (field[0], ln))
|
||
|
|
break
|
||
|
|
else:
|
||
|
|
# Add our best guess at the executable.
|
||
|
|
record['executable'] = extractExecutable(record['command'])
|
||
|
|
table.append(Struct(**record))
|
||
|
|
|
||
|
|
return table
|
||
|
|
|
||
|
|
def getSignalValue(name):
|
||
|
|
import signal
|
||
|
|
if name.startswith('SIG'):
|
||
|
|
value = getattr(signal, name)
|
||
|
|
if value and isinstance(value, int):
|
||
|
|
return value
|
||
|
|
error('unknown signal: %r' % name)
|
||
|
|
|
||
|
|
import signal
|
||
|
|
kSignals = {}
|
||
|
|
for name in dir(signal):
|
||
|
|
if name.startswith('SIG') and name == name.upper() and name.isalpha():
|
||
|
|
kSignals[name[3:]] = getattr(signal, name)
|
||
|
|
|
||
|
|
def main():
|
||
|
|
global opts
|
||
|
|
from optparse import OptionParser, OptionGroup
|
||
|
|
parser = OptionParser("usage: %prog [options] {pid}*")
|
||
|
|
|
||
|
|
# FIXME: Add -NNN and -SIGNAME options.
|
||
|
|
|
||
|
|
parser.add_option("-s", "", dest="signalName",
|
||
|
|
help="Name of the signal to use (default=%default)",
|
||
|
|
action="store", default='INT',
|
||
|
|
choices=kSignals.keys())
|
||
|
|
parser.add_option("-l", "", dest="listSignals",
|
||
|
|
help="List known signal names",
|
||
|
|
action="store_true", default=False)
|
||
|
|
|
||
|
|
parser.add_option("-n", "--dry-run", dest="dryRun",
|
||
|
|
help="Only print the actions that would be taken",
|
||
|
|
action="store_true", default=False)
|
||
|
|
parser.add_option("-v", "--verbose", dest="verbose",
|
||
|
|
help="Print more verbose output",
|
||
|
|
action="store_true", default=False)
|
||
|
|
parser.add_option("", "--debug", dest="debug",
|
||
|
|
help="Enable debugging output",
|
||
|
|
action="store_true", default=False)
|
||
|
|
parser.add_option("", "--force", dest="force",
|
||
|
|
help="Perform the specified commands, even if it seems like a bad idea",
|
||
|
|
action="store_true", default=False)
|
||
|
|
|
||
|
|
inf = float('inf')
|
||
|
|
group = OptionGroup(parser, "Process Filters")
|
||
|
|
group.add_option("", "--name", dest="execName", metavar="REGEX",
|
||
|
|
help="Kill processes whose name matches the given regexp",
|
||
|
|
action="store", default=None)
|
||
|
|
group.add_option("", "--exec", dest="execPath", metavar="REGEX",
|
||
|
|
help="Kill processes whose executable matches the given regexp",
|
||
|
|
action="store", default=None)
|
||
|
|
group.add_option("", "--user", dest="userName", metavar="REGEX",
|
||
|
|
help="Kill processes whose user matches the given regexp",
|
||
|
|
action="store", default=None)
|
||
|
|
group.add_option("", "--min-cpu", dest="minCPU", metavar="PCT",
|
||
|
|
help="Kill processes with CPU usage >= PCT",
|
||
|
|
action="store", type=float, default=None)
|
||
|
|
group.add_option("", "--max-cpu", dest="maxCPU", metavar="PCT",
|
||
|
|
help="Kill processes with CPU usage <= PCT",
|
||
|
|
action="store", type=float, default=inf)
|
||
|
|
group.add_option("", "--min-mem", dest="minMem", metavar="N",
|
||
|
|
help="Kill processes with virtual size >= N (MB)",
|
||
|
|
action="store", type=float, default=None)
|
||
|
|
group.add_option("", "--max-mem", dest="maxMem", metavar="N",
|
||
|
|
help="Kill processes with virtual size <= N (MB)",
|
||
|
|
action="store", type=float, default=inf)
|
||
|
|
group.add_option("", "--min-rss", dest="minRSS", metavar="N",
|
||
|
|
help="Kill processes with RSS >= N",
|
||
|
|
action="store", type=float, default=None)
|
||
|
|
group.add_option("", "--max-rss", dest="maxRSS", metavar="N",
|
||
|
|
help="Kill processes with RSS <= N",
|
||
|
|
action="store", type=float, default=inf)
|
||
|
|
group.add_option("", "--min-time", dest="minTime", metavar="N",
|
||
|
|
help="Kill processes with CPU time >= N (seconds)",
|
||
|
|
action="store", type=float, default=None)
|
||
|
|
group.add_option("", "--max-time", dest="maxTime", metavar="N",
|
||
|
|
help="Kill processes with CPU time <= N (seconds)",
|
||
|
|
action="store", type=float, default=inf)
|
||
|
|
parser.add_option_group(group)
|
||
|
|
|
||
|
|
(opts, args) = parser.parse_args()
|
||
|
|
|
||
|
|
if opts.listSignals:
|
||
|
|
items = [(v,k) for k,v in kSignals.items()]
|
||
|
|
items.sort()
|
||
|
|
for i in range(0, len(items), 4):
|
||
|
|
print '\t'.join(['%2d) SIG%s' % (k,v)
|
||
|
|
for k,v in items[i:i+4]])
|
||
|
|
sys.exit(0)
|
||
|
|
|
||
|
|
# Figure out the signal to use.
|
||
|
|
signal = kSignals[opts.signalName]
|
||
|
|
signalValueName = str(signal)
|
||
|
|
if opts.verbose:
|
||
|
|
name = dict((v,k) for k,v in kSignals.items()).get(signal,None)
|
||
|
|
if name:
|
||
|
|
signalValueName = name
|
||
|
|
note('using signal %d (SIG%s)' % (signal, name))
|
||
|
|
else:
|
||
|
|
note('using signal %d' % signal)
|
||
|
|
|
||
|
|
# Get the pid list to consider.
|
||
|
|
pids = set()
|
||
|
|
for arg in args:
|
||
|
|
try:
|
||
|
|
pids.add(int(arg))
|
||
|
|
except:
|
||
|
|
parser.error('invalid positional argument: %r' % arg)
|
||
|
|
|
||
|
|
filtered = ps = getProcessTable()
|
||
|
|
|
||
|
|
# Apply filters.
|
||
|
|
if pids:
|
||
|
|
filtered = [p for p in filtered
|
||
|
|
if p.pid in pids]
|
||
|
|
if opts.execName is not None:
|
||
|
|
filtered = [p for p in filtered
|
||
|
|
if re_full_match(opts.execName,
|
||
|
|
os.path.basename(p.executable))]
|
||
|
|
if opts.execPath is not None:
|
||
|
|
filtered = [p for p in filtered
|
||
|
|
if re_full_match(opts.execPath, p.executable)]
|
||
|
|
if opts.userName is not None:
|
||
|
|
filtered = [p for p in filtered
|
||
|
|
if re_full_match(opts.userName, p.user)]
|
||
|
|
filtered = [p for p in filtered
|
||
|
|
if opts.minCPU <= p.cpu_percent <= opts.maxCPU]
|
||
|
|
filtered = [p for p in filtered
|
||
|
|
if opts.minMem <= float(p.vmem_size) / (1<<20) <= opts.maxMem]
|
||
|
|
filtered = [p for p in filtered
|
||
|
|
if opts.minRSS <= p.rss <= opts.maxRSS]
|
||
|
|
filtered = [p for p in filtered
|
||
|
|
if opts.minTime <= p.cpu_time <= opts.maxTime]
|
||
|
|
|
||
|
|
if len(filtered) == len(ps):
|
||
|
|
if not opts.force and not opts.dryRun:
|
||
|
|
error('refusing to kill all processes without --force')
|
||
|
|
|
||
|
|
if not filtered:
|
||
|
|
warning('no processes selected')
|
||
|
|
|
||
|
|
for p in filtered:
|
||
|
|
if opts.verbose:
|
||
|
|
note('kill(%r, %s) # (user=%r, executable=%r, CPU=%2.2f%%, time=%r, vmem=%r, rss=%r)' %
|
||
|
|
(p.pid, signalValueName, p.user, p.executable, p.cpu_percent, p.cpu_time, p.vmem_size, p.rss))
|
||
|
|
if not opts.dryRun:
|
||
|
|
try:
|
||
|
|
os.kill(p.pid, signal)
|
||
|
|
except OSError:
|
||
|
|
if opts.debug:
|
||
|
|
raise
|
||
|
|
warning('unable to kill PID: %r' % p.pid)
|
||
|
|
|
||
|
|
if __name__ == '__main__':
|
||
|
|
main()
|