aboutsummaryrefslogtreecommitdiff
path: root/contrib/llvm/utils/Misc/zkill
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/llvm/utils/Misc/zkill')
-rwxr-xr-xcontrib/llvm/utils/Misc/zkill276
1 files changed, 0 insertions, 276 deletions
diff --git a/contrib/llvm/utils/Misc/zkill b/contrib/llvm/utils/Misc/zkill
deleted file mode 100755
index bc0bfd586f7a..000000000000
--- a/contrib/llvm/utils/Misc/zkill
+++ /dev/null
@@ -1,276 +0,0 @@
-#!/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()
generated by cgit v1.2.3 (git 2.25.1) at 2025-03-04 06:05:56 +0000