PKvq5H OOcpuset/cset.py"""Cpuset class and cpuset graph, importing module will create model """ __copyright__ = """ Copyright (C) 2016 Johannes Bechberger Copyright (C) 2007-2010 Novell Inc. Author: Alex Tsariounov This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """ import os, re, sys, logging if __name__ == '__main__': sys.path.insert(0, "..") logging.basicConfig() from cpuset.util import * log = logging.getLogger('cset') RootSet = None class CpuSet(object): # sets is a class variable dict that keeps track of all # cpusets discovered such that we can link them in properly. # The basepath is it's base path, the sets are indexed via # a relative path from this basepath. sets = {} basepath = '' cpus_path = '/cpus' mems_path = '/mems' cpu_exclusive_path = '/cpu_exclusive' mem_exclusive_path = '/mem_exclusive' tasks_path = '/tasks' def __init__(self, path=None): log.debug("initializing CpuSet") if (path == None): # recursively find all cpusets and link together # note: a breadth-first search could do this in one # pass, but there are never many cpusets, so # that optimization is left for the future log.debug("finding all cpusets") path = self.locate_cpusets() CpuSet.basepath = path log.debug("creating root node at %s", path) self.__root = True self.name = 'root' self.path = '/' self.parent = self if (CpuSet.sets): del CpuSet.sets CpuSet.sets = {} CpuSet.sets[self.path] = self # if mounted as a cgroup controller, switch file name format if not os.access(path + CpuSet.cpus_path, os.F_OK): CpuSet.cpus_path = '/cpuset.cpus' CpuSet.mems_path = '/cpuset.mems' CpuSet.cpu_exclusive_path = '/cpuset.cpu_exclusive' CpuSet.mem_exclusive_path = '/cpuset.mem_exclusive' # bottom-up search otherwise links will not exist log.debug("starting bottom-up discovery walk...") for dir, dirs, files in os.walk(path, topdown=False): log.debug("*** walking %s", dir) if dir != CpuSet.basepath: node = CpuSet(dir) else: node = self node.subsets = [] for sub in dirs: if len(sub) > 0: relpath = os.path.join(dir,sub).replace(CpuSet.basepath, '') else: relpath = '/' node.subsets.append(CpuSet.sets[relpath]) log.debug("%s has %i subsets: [%s]", dir, len(node.subsets), '|'.join(dirs)) log.debug("staring top-down parenting walk...") for dir, dirs, files in os.walk(path): dir = dir.replace(CpuSet.basepath, '') if len(dir) == 0: dir = '/' node = CpuSet.sets[dir] log.debug("~~~ walking %s", node.path) if dir == '/': log.debug("parent is self (root cpuset), skipping") else: parpath = dir[0:dir.rfind('/')] log.debug('parpath decodes to: %s from dir of: %s', parpath, dir) if parpath in CpuSet.sets: log.debug("parent is %s", parpath) node.parent = CpuSet.sets[parpath] else: log.debug("parent is root cpuset") node.parent = CpuSet.sets['/'] log.debug("found %i cpusets", len(CpuSet.sets)) else: # one new cpuset node log.debug("new cpuset node absolute: %s", path) if len(path) > len(CpuSet.basepath): path = path.replace(CpuSet.basepath, '') else: path = '/' log.debug(" relative: %s", path) if path in CpuSet.sets: log.debug("the cpuset %s already exists, skipping", path) self = CpuSet.sets[path] # questionable.... return cpus = CpuSet.basepath + path + CpuSet.cpus_path if not os.access(cpus, os.F_OK): # not a cpuset directory str = '%s is not a cpuset directory' % (CpuSet.basepath + path) log.error(str) raise CpusetException(str) self.__root = False self.read_cpuset(path) CpuSet.sets[path] = self def locate_cpusets(self): log.debug("locating cpuset filesystem...") cpuset = re.compile(r"none (/.+) cpuset .+") cgroup = re.compile(r"none (/.+) cgroup .+") cpuset1 = re.compile(r"cpuset (/.+) cpuset .+") cgroup1 = re.compile(r"cgroup (/.+) cgroup .+") path = None f = file("/proc/mounts") for line in f: res = cpuset.search(line) if res: path = res.group(1) break res = cpuset1.search(line) if res: path = res.group(1) break else: if cgroup.search(line): groups = line.split() if re.search("cpuset", groups[3]): path = groups[1] break if cgroup1.search(line): groups = line.split() if re.search("cpuset", groups[3]): path = groups[1] break f.close() if not path: # mounted cpusets not found, so mount them if not os.access(config.mountpoint, os.F_OK): os.mkdir(config.mountpoint) ret = os.system("mount -t cpuset none " + config.mountpoint) if ret: raise CpusetException( 'mount of cpuset filesystem failed, do you have permission?') path = config.mountpoint log.debug("cpusets mounted at: " + path) return path def read_cpuset(self, path): log.debug("reading cpuset passed relpath: %s", path) self.path = path log.debug("...path=%s", path) self.name = path[path.rfind('/')+1:] log.debug("...name=%s", self.name) # Properties of cpuset node def delprop(self): raise AttributeError("deletion of properties not allowed") def getcpus(self): f = file(CpuSet.basepath+self.path+CpuSet.cpus_path) return f.readline()[:-1] def setcpus(self, newval): cpuspec_check(newval) f = file(CpuSet.basepath+self.path+CpuSet.cpus_path,'w') f.write(str(newval)) f.close() log.debug("-> prop_set %s.cpus = %s", self.path, newval) cpus = property(fget=getcpus, fset=setcpus, fdel=delprop, doc="CPU specifier") def getmems(self): f = file(CpuSet.basepath+self.path+CpuSet.mems_path) return f.readline()[:-1] def setmems(self, newval): # FIXME: check format for correctness f = file(CpuSet.basepath+self.path+CpuSet.mems_path,'w') f.write(str(newval)) f.close() log.debug("-> prop_set %s.mems = %s", self.path, newval) mems = property(getmems, setmems, delprop, "Mem node specifier") def getcpuxlsv(self): f = file(CpuSet.basepath+self.path+CpuSet.cpu_exclusive_path) if f.readline()[:-1] == '1': return True else: return False def setcpuxlsv(self, newval): log.debug("-> prop_set %s.cpu_exclusive = %s", self.path, newval) f = file(CpuSet.basepath+self.path+CpuSet.cpu_exclusive_path,'w') if newval: f.write('1') else: f.write('0') f.close() cpu_exclusive = property(getcpuxlsv, setcpuxlsv, delprop, "CPU exclusive flag") def getmemxlsv(self): f = file(CpuSet.basepath+self.path+CpuSet.mem_exclusive_path) if f.readline()[:-1] == '1': return True else: return False def setmemxlsv(self, newval): log.debug("-> prop_set %s.mem_exclusive = %s", self.path, newval) f = file(CpuSet.basepath+self.path+CpuSet.mem_exclusive_path,'w') if newval: f.write('1') else: f.write('0') f.close() mem_exclusive = property(getmemxlsv, setmemxlsv, delprop, "Memory exclusive flag") def gettasks(self): f = file(CpuSet.basepath+self.path+CpuSet.tasks_path) lst = [] for task in f: lst.append(task[:-1]) return lst def settasks(self, tasklist): notfound = [] unmovable = [] if len(tasklist) > 3: pb = ProgressBar(len(tasklist), '=') tick = 0 prog = True else: prog = False for task in tasklist: try: f = file(CpuSet.basepath+self.path+CpuSet.tasks_path,'w') f.write(task) f.close() except Exception as err: if str(err).find('No such process') != -1: notfound.append(task) elif str(err).find('Invalid argument'): unmovable.append(task) else: raise if prog: tick += 1 #pb(tick) if len(notfound) > 0: log.info('**> %s tasks were not found, so were not moved', len(notfound)) log.debug(' not found: %s', notfound) if len(unmovable) > 0: log.info('**> %s tasks are not movable, impossible to move', len(unmovable)) log.debug(' not movable: %s', unmovable) log.debug("-> prop_set %s.tasks set with %s tasks", self.path, len(tasklist)) tasks = property(gettasks, settasks, delprop, "Task list") # # Helper functions # def lookup_task_from_proc(pid): """lookup the cpuset of the specified pid from proc filesystem""" log.debug("entering lookup_task_from_proc, pid = %s", str(pid)) path = "/proc/"+str(pid)+"/cpuset" if os.access(path, os.F_OK): set = file(path).readline()[:-1] log.debug('lookup_task_from_proc: found task %s cpuset: %s', str(pid), set) return set # FIXME: add search for threads here... raise CpusetException("task ID %s not found, i.e. not running" % str(pid)) def lookup_task_from_cpusets(pid): """lookup the cpuset of the specified pid from cpuset filesystem""" log.debug("entering lookup_task_from_cpusets, pid = %s", str(pid)) global RootSet if RootSet == None: rescan() gotit = None if pid in RootSet.tasks: gotit = RootSet else: for node in walk_set(RootSet): if pid in node.tasks: gotit = node break if gotit: log.debug('lookup_task_from_cpusets: found task %s cpuset: %s', str(pid), gotit.path) return gotit.path raise CpusetException("task ID %s not found, i.e. not running" % str(pid)) def unique_set(name): """find a unique cpuset by name or path, raise if multiple sets found""" log.debug("entering unique_set, name=%s", name) if name == None: raise CpusetException('unique_set() passed None as arg') if isinstance(name, CpuSet): return name nl = find_sets(name) if len(nl) > 1: raise CpusetNotUnique('cpuset name "%s" not unique: %s' % (name, [x.path for x in nl]) ) return nl[0] def find_sets(name): """find cpusets by name or path, raise CpusetNotFound if not found""" log = logging.getLogger("cset.find_sets") log.debug('finding "%s" in cpusets', name) nodelist = [] if name.find('/') == -1: log.debug("find by name") if name == 'root': log.debug("returning root set") nodelist.append(RootSet) else: log.debug("walking from: %s", RootSet.path) for node in walk_set(RootSet): if node.name == name: log.debug('... found node "%s"', name) nodelist.append(node) else: log.debug("find by path") # make sure that leading slash is used if searching by path if name[0] != '/': name = '/' + name if name in CpuSet.sets: log.debug('... found node "%s"', CpuSet.sets[name].name) nodelist.append(CpuSet.sets[name]) if len(nodelist) == 0: raise CpusetNotFound('cpuset "%s" not found in cpusets' % name) return nodelist def walk_set(set): """ generator for walking cpuset graph, breadth-first, more or less... """ log = logging.getLogger("cset.walk_set") for node in set.subsets: log.debug("+++ yield %s", node.name) yield node for node in set.subsets: for result in walk_set(node): log.debug("++++++ yield %s", node.name) yield result def rescan(): """re-read the cpuset directory to sync system with data structs""" log.debug("entering rescan") global RootSet, maxcpu, allcpumask RootSet = CpuSet() # figure out system properties log.debug("rescan: all cpus = %s", RootSet.cpus) maxcpu = int(RootSet.cpus.split('-')[-1].split(',')[-1]) log.debug(" max cpu = %s", maxcpu) allcpumask = calc_cpumask(maxcpu) log.debug(" allcpumask = %s", allcpumask) def cpuspec_check(cpuspec, usemax=True): """check format of cpuspec for validity""" log.debug("cpuspec_check(%s)", cpuspec) mo = re.search("[^0-9,\-]", cpuspec) if mo: str = 'CPUSPEC "%s" contains invalid charaters: %s' % (cpuspec, mo.group()) log.debug(str) raise CpusetException(str) groups = cpuspec.split(',') if usemax and int(groups[-1].split('-')[-1]) > int(maxcpu): str = 'CPUSPEC "%s" specifies higher max(%s) than available(%s)' % \ (cpuspec, groups[-1].split('-')[-1], maxcpu) log.debug(str) raise CpusetException(str) for sub in groups: it = sub.split('-') if len(it) == 2: if len(it[0]) == 0 or len(it[1]) == 0: # catches negative numbers raise CpusetException('CPUSPEC "%s" has bad group "%s"' % (cpuspec, sub)) if len(it) > 2: raise CpusetException('CPUSPEC "%s" has bad group "%s"' % (cpuspec, sub)) def cpuspec_to_hex(cpuspec): """convert a cpuspec to the hexadecimal string representation""" log.debug('cpuspec_to_string(%s)', cpuspec) cpuspec_check(cpuspec, usemax=False) groups = cpuspec.split(',') number = 0 for sub in groups: items = sub.split('-') if len(items) == 1: if not len(items[0]): # two consecutive commas in cpuspec continue # one cpu in this group log.debug(" adding cpu %s to result", items[0]) number |= 1 << int(items[0]) elif len(items) == 2: il = [int(ii) for ii in items] if il[1] >= il[0]: rng = list(range(il[0], il[1]+1)) else: rng = list(range(il[1], il[0]+1)) log.debug(' group=%s has cpu range of %s', sub, rng) for num in rng: number |= 1 << num else: raise CpusetException('CPUSPEC "%s" has bad group "%s"' % (cpuspec, sub)) log.debug(' final int number=%s in hex=%x', number, number) return '%x' % number def memspec_check(memspec): """check format of memspec for validity""" # FIXME: look under /sys/devices/system/node for numa memory node # information and check the memspec that way, currently we only do # a basic check log.debug("memspec_check(%s)", memspec) mo = re.search("[^0-9,\-]", memspec) if mo: str = 'MEMSPEC "%s" contains invalid charaters: %s' % (memspec, mo.group()) log.debug(str) raise CpusetException(str) def cpuspec_inverse(cpuspec): """calculate inverse of cpu specification""" cpus = [0 for x in range(maxcpu+1)] groups = cpuspec.split(',') log.debug("cpuspec_inverse(%s) maxcpu=%d groups=%d", cpuspec, maxcpu, len(groups)) for set in groups: items = set.split('-') if len(items) == 1: if not len(items[0]): # common error of two consecutive commas in cpuspec, # just ignore it and keep going continue cpus[int(items[0])] = 1 elif len(items) == 2: for x in range(int(items[0]), int(items[1])+1): cpus[x] = 1 else: raise CpusetException("cpuspec(%s) has bad group %s" % (cpuspec, set)) log.debug("cpuspec array: %s", cpus) # calculate inverse of array for x in range(0, len(cpus)): if cpus[x] == 0: cpus[x] = 1 else: cpus[x] = 0 log.debug(" inverse: %s", cpus) # build cpuspec expression nspec = "" ingrp = False for x in range(0, len(cpus)): if cpus[x] == 0 and ingrp: nspec += str(begin) if x > begin+1: if cpus[x] == 1: nspec += '-' + str(x) else: nspec += '-' + str(x-1) ingrp = False if cpus[x] == 1: if not ingrp: if len(nspec): nspec += ',' begin = x ingrp = True if x == len(cpus)-1: nspec += str(begin) if x > begin: nspec += '-' + str(x) log.debug("inverse cpuspec: %s", nspec) return nspec def summary(set): """return summary of cpuset with number of tasks running""" log.debug("entering summary, set=%s", set.path) if len(set.tasks) == 1: msg = 'task' else: msg = 'tasks' return ('"%s" cpuset of CPUSPEC(%s) with %s %s running' % (set.name, set.cpus, len(set.tasks), msg) ) def calc_cpumask(max): all = 1 ii = 1 while ii < max+1: all |= 1 << ii ii += 1 return "%x" % all # Test if stand-alone execution if __name__ == '__main__': rescan() # first create them, then find them try: os.makedirs(CpuSet.basepath+'/csettest/one/x') os.mkdir(CpuSet.basepath+'/csettest/one/y') os.makedirs(CpuSet.basepath+'/csettest/two/x') os.mkdir(CpuSet.basepath+'/csettest/two/y') except: pass print(('Max cpu on system:', maxcpu)) print(('All cpu mask: 0x%s' % allcpumask)) print('------- find_sets tests --------') print(('Find by root of "root" -> ', find_sets("root"))) print(('Find by path of "/" -> ', find_sets("/"))) print(('Find by path of "/csettest/one" -> ', find_sets("/csettest/one"))) print(('Find by name of "one" -> ', find_sets("one"))) print(('Find by path of "/csettest/two" -> ', find_sets("/csettest/two"))) print(('Find by name of "two" -> ', find_sets("two"))) print(('Find by path of "/csettest/one/x" -> ', find_sets("/csettest/one/x"))) print(('Find by name of "x" -> ', find_sets("x"))) print(('Find by path of "/csettest/two/y" -> ', find_sets("/csettest/two/y"))) print(('Find by name of "y" -> ', find_sets("y"))) try: node = find_sets("cantfindmenoway") print(('Found "cantfindmenoway??!? -> ', node)) except CpusetException as err: print(('Caught exeption for non-existant set (correctly)-> ', err)) PKuo5ḤGI I cpuset/config.py""" Cpuset Configuration Module The config module maintains global (class) variables of the various configuration parameters for the cpuset application. These are filled in from applicable configuration file passed as a path to the ReadConfigFile() method, if desired. The class variables are given default values in the module source. Anything found in the configuration files in the list of paths will override these defaults. """ __copyright__ = """ Copyright (C) 2016 Johannes Bechberger Copyright (C) 2009-2010 Novell Inc. Author: Alex Tsariounov This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """ import sys import types import configparser ############################################################################ # Default configuration variable values ############################################################################ defloc = '/etc/cset.conf' # default config file location mread = False # machine readable output, usually set # via option -m/--machine mountpoint = '/cpusets' # cpuset filessytem mount point ############################################################################ def ReadConfigFiles(path=None): if path == None: path = defloc cf = configparser.ConfigParser() try: fr = cf.read(path) if len(fr) == 0: return # can't use logging, too early... if len(cf.sections()) != 1: print(("cset: warning, more than one section found in config file:", cf.sections())) if 'default' not in cf.sections(): print(('cset: [default] section not found in config file "%s"' % path)) sys.exit(3) except configparser.MissingSectionHeaderError: f = open(path) cstr = f.read() f.close() import io cf.readfp(io.StringIO('[default]\n' + cstr)) # override our globals... for opt in cf.options('default'): typ = type(globals()[opt]) if typ == bool: globals()[opt] = cf.getboolean('default', opt) elif typ == int: globals()[opt] = cf.getint('default', opt) else: globals()[opt] = cf.get('default', opt) # Importing module autoinitializes it def __init(): ReadConfigFiles() __init() PKuo5HTcpuset/main.py"""Front end command line tool for Linux cpusets """ __copyright__ = """ Copyright (C) 2016 Johannes Bechberger Copyright (C) 2007-2010 Novell Inc. Author: Alex Tsariounov This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """ import sys, os from optparse import OptionParser from cpuset import config import cpuset.commands from cpuset.commands.common import CmdException from cpuset.util import CpusetException # # The commands map # class Commands(dict): """Commands class. It performs on-demand module loading """ def canonical_cmd(self, key): """Return the canonical name for a possibly-shortenned command name. """ candidates = [cmd for cmd in list(self.keys()) if cmd.startswith(key)] if not candidates: log.error('Unknown command: %s', key) log.error('Try "%s help" for a list of supported commands', prog) sys.exit(1) elif len(candidates) > 1: log.error('Ambiguous command: %s', key) log.error('Candidates are: %s', ', '.join(candidates)) sys.exit(1) return candidates[0] def __getitem__(self, key): """Return the command python module name based. """ global prog cmd_mod = self.get(key) or self.get(self.canonical_cmd(key)) __import__('cpuset.commands.' + cmd_mod) return getattr(cpuset.commands, cmd_mod) commands = Commands({ 'shield': 'shield', 'set': 'set', # 'mem': 'mem', 'proc': 'proc', }) supercommands = ( 'shield', ) def _print_helpstring(cmd): print(' ' + cmd + ' ' * (12 - len(cmd)) + commands[cmd].help) def print_help(): print('Usage: %s [global options] [command options]' % os.path.basename(sys.argv[0])) print() print('Global options:') print(' -l/--log output debugging log in fname') print(' -m/--machine print machine readable output') print(' -x/--tohex convert a CPUSPEC to hex') print() print('Generic commands:') print(' help print the detailed command usage') print(' version display version information') print(' copyright display copyright information') cmds = list(commands.keys()) cmds.sort() print() print('Super commands (high-level and multi-function):') for cmd in supercommands: _print_helpstring(cmd) print() print('Regular commands:') for cmd in cmds: if not cmd in supercommands: _print_helpstring(cmd) def main(): # handle pipes better import signal signal.signal(signal.SIGPIPE, signal.SIG_DFL) global prog prog = os.path.basename(sys.argv[0]) global logfile logfile = None if len(sys.argv) < 2: print('usage: %s ' % prog, file=sys.stderr) print(' Try "%s --help" for a list of supported commands' % prog, file=sys.stderr) sys.exit(1) # configure logging import logging console = logging.StreamHandler(sys.stdout) console.setLevel(logging.INFO) formatter = logging.Formatter(prog + ': %(message)s') console.setFormatter(formatter) logging.getLogger('').addHandler(console) global log log = logging.getLogger('') log.setLevel(logging.DEBUG) try: debug_level = int(os.environ['CSET_DEBUG_LEVEL']) except KeyError: debug_level = 0 except ValueError: log.error('Invalid CSET_DEBUG_LEVEL environment variable') sys.exit(1) while True: if len(sys.argv) == 1: log.error('no arguments, nothing to do!') sys.exit(2) cmd = sys.argv[1] if cmd in ['-l', '--log']: if len(sys.argv) < 3: log.critical('not enough arguments') sys.exit(1) # FIXME: very fragile logfile = sys.argv[2] #trace = logging.FileHandler('/var/log/cset.log', 'w') trace = logging.FileHandler(logfile, 'a') trace.setLevel(logging.DEBUG) formatter = logging.Formatter('%(asctime)s %(name)-6s %(levelname)-8s %(message)s', '%y%m%d-%H:%M:%S') trace.setFormatter(formatter) logging.getLogger('').addHandler(trace) log.debug("---------- STARTING ----------") from cpuset.version import version log.debug('Cpuset (cset) %s' % version) del(sys.argv[2]) del(sys.argv[1]) continue if cmd in ['-h', '--help']: if len(sys.argv) >= 3: cmd = commands.canonical_cmd(sys.argv[2]) sys.argv[2] = '--help' else: print_help() sys.exit(0) if cmd == 'help': if len(sys.argv) == 3 and not sys.argv[2] in ['-h', '--help']: cmd = commands.canonical_cmd(sys.argv[2]) if not cmd in commands: log.error('help: "%s" command unknown' % cmd) sys.exit(1) sys.argv[0] += ' %s' % cmd command = commands[cmd] parser = OptionParser(usage = command.usage, option_list = command.options) from pydoc import pager pager(parser.format_help()) else: print_help() sys.exit(0) if cmd in ['-v', '--version', 'version']: from cpuset.version import version log.info('Cpuset (cset) %s' % version) sys.exit(0) if cmd in ['-c', 'copyright', 'copying']: log.info(__copyright__) sys.exit(0) if cmd in ['-m', '--machine']: config.mread = True del(sys.argv[1]) continue if cmd in ['-x', '--tohex']: if len(sys.argv) < 3: log.critical('not enough arguments') sys.exit(1) cpuspec = sys.argv[2] from . import cset try: print(cset.cpuspec_to_hex(cpuspec)) except (ValueError, OSError, IOError, CpusetException, CmdException) as err: log.critical('**> ' + str(err)) if debug_level: raise else: sys.exit(2) sys.exit(0) break # re-build the command line arguments cmd = commands.canonical_cmd(cmd) sys.argv[0] += ' %s' % cmd del(sys.argv[1]) log.debug('cmdline: ' + ' '.join(sys.argv)) try: # importing the cset class creates the model log.debug("creating cpuset model") import cpuset.cset command = commands[cmd] usage = command.usage.split('\n')[0].strip() parser = OptionParser(usage = usage, option_list = command.options) options, args = parser.parse_args() command.func(parser, options, args) except (ValueError, OSError, IOError, CpusetException, CmdException) as err: log.critical('**> ' + str(err)) if str(err).find('Permission denied') != -1: log.critical('insufficient permissions, you probably need to be root') if str(err).find('invalid literal') != -1: log.critical('option not understood') if debug_level: raise else: sys.exit(2) except KeyboardInterrupt: sys.exit(1) sys.exit(0) PKuo5H..cpuset/__init__.py__copyright__ = """ Copyright (C) 2016 Johannes Bechberger Copyright (C) 2007-2010 Novell Inc. Author: Alex Tsariounov This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA --------------------------------------------------------------------- Substrate code and ideas taken from the excellent stgit 0.13, see https://gna.org/projects/stgit and http://www.procode.org/stgit/ Stacked GIT is under GPL V2 or later. --------------------------------------------------------------------- """ PKuo5Hcpuset/version.py__copyright__ = """ Copyright (C) 2016 Johannes Bechberger Copyright (C) 2007-2010 Novell Inc. Author: Alex Tsariounov This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """ version = '1.0' PKuo5H;:_ _ cpuset/util.py"""Utility functions """ __copyright__ = """ Copyright (C) 2016 Johannes Bechberger Copyright (C) 2007-2010 Novell Inc. Author: Alex Tsariounov This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """ import sys, time from cpuset import config class CpusetException(Exception): pass class CpusetAbort(CpusetException): pass class CpusetNotFound(CpusetException): pass class CpusetNotUnique(CpusetException): pass class CpusetExists(CpusetException): pass # a twirling bar progress indicator class TwirlyBar: def __init__(self): import sys self.__dict__['__call__'] = self.tick self.__state = 0 self.__bar = ('|', '/', '-', '\\') def tick(self): if not config.mread: print(('\b' + self.__bar[self.__state] + '\b')) self.__state = self.__state + 1 if self.__state > 3: self.__state = 0 def fastick(self): for x in range(10): self.tick() time.sleep(0.04) # a progress bar indicator class ProgressBar: def __init__(self, finalcount, progresschar=None): self.__dict__['__call__'] = self.progress self.finalcount=finalcount self.blockcount=0 # Use ascii block char for progress if none passed if not progresschar: self.block=chr(178) else: self.block=progresschar if config.mread: return self.f=sys.stdout if not self.finalcount: return self.f.write('[') for i in range(50): self.f.write(' ') self.f.write(']%') for i in range(52): self.f.write('\b') def progress(self, count): count=min(count, self.finalcount) if self.finalcount: percentcomplete=int(round(100*count/self.finalcount)) if percentcomplete < 1: percentcomplete=1 else: percentcomplete=100 blockcount=int(percentcomplete/2) if not config.mread: if blockcount > self.blockcount: for i in range(self.blockcount,blockcount): self.f.write(self.block) self.f.flush() if percentcomplete == 100: self.f.write("]\n") self.blockcount=blockcount def file(filename: str, mode: str = "r"): return open(filename, mode)PKuo5H"w"wcpuset/commands/proc.py"""Process manipulation command """ __copyright__ = """ Copyright (C) 2016 Johannes Bechberger Copyright (C) 2007-2010 Novell Inc. Author: Alex Tsariounov This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """ import sys, os, re, logging, pwd, grp from optparse import OptionParser, make_option from cpuset import config from cpuset import cset from cpuset.util import * from cpuset.commands.common import * try: from cpuset.commands import set except SyntaxError: raise except: pass global log log = logging.getLogger('proc') help = 'create and manage processes within cpusets' usage = """%prog [options] [path/program [args]] This command is used to run and manage arbitrary processes on specified cpusets. It is also used to move pre-existing processes and threads to specified cpusets. You may note there is no "kill" or "destroy" option -- use the standard OS ^C or kill commands for that. To list which tasks are running in a particular cpuset, use the --list command. For example: # cset proc --list --set myset This command will list all the tasks running in the cpuset called "myset". Processes are created by specifying the path to the executable and specifying the cpuset that the process is to be created in. For example: # cset proc --set=blazing_cpuset --exec /usr/bin/fast_code This command will execute the /usr/bin/fast_code program on the "blazing_cpuset" cpuset. Note that if your command takes options, then use the traditional "--" marker to separate cset's options from your command's options. For example: # cset proc --set myset --exec -- ls -l This command will execute "ls -l" on the cpuset called "myset". The PIDSPEC argument taken for the move command is a comma separated list of PIDs or TIDs. The list can also include brackets of PIDs or TIDs (i.e. tasks) that are inclusive of the endpoints. For example: 1,2,5 Means processes 1, 2 and 5 1,2,600-700 Means processes 1, 2 and from 600 to 700 Note that the range of PIDs or TIDs does not need to have every position populated. In other words, for the example above, if there is only one process, say PID 57, in the range of 50-65, then only that process will be moved. To move a PIDSPEC to a specific cpuset, you can either specify the PIDSPEC with --pid and the destination cpuset with --toset, or use the short hand and list the cpuset name after the PIDSPEC for the --move arguments. The move command accepts multiple common calling methods. For example, the following commands are equivalent: # cset proc --move 2442,3000-3200 reserved_set # cset proc --move --pid=2442,3000-3200 --toset=reserved_set These commands move the tasks defined as 2442 and any running task between 3000 and 3200 inclusive of the ends to the cpuset called "reserved_set". Specifying the --fromset is not necessary since the tasks will be moved to the destination cpuset no matter which cpuset they are currently running on. Note however that if you do specify a cpuset with the --fromset option, then only those tasks that are both in the PIDSPEC *and* are running in the cpuset specified by --fromset will be moved. I.e., if there is a task running on the system but not in --fromset that is in PIDSPEC, it will not be moved. If the --threads switch is used, then the proc command will gather any threads of belonging to any processes or threads that are specified in the PIDSPEC and move them. This provides an easy way to move all related threads: just pick one TID from the set and use the --threads option. To move all userspace tasks from one cpuset to another, you need to specify the source and destination cpuset by name. For example: # cset proc --move --fromset=comp1 --toset=comp42 This command specifies that all processes and threads running on cpuset "comp1" be moved to cpuset "comp42". Note that the move command will not move kernel threads unless the -k/--kthread switch is specified. If it is, then all unbound kernel threads will be added to the move. Unbound kernel threads are those that can run on any CPU. If you also specify the --force switch, then all tasks, kernel or not, bound or not, will be moved. CAUTION: Please be cautious with the --force switch, since moving a kernel thread that is bound to a specific CPU to a cpuset that does not include that CPU can cause a system hang. You must specify unique cpuset names for the both exec and move commands. If a simple name passed to the --fromset, --toset and --set parameters is unique on the system then that command executes. However, if there are multiple cpusets by that name, then you will need to specify which one you mean with a full path rooted at the base cpuset tree. For example, suppose you have the following cpuset tree: /group1 /myset /yourset /group2 /myset /yourset Then, to move a process from myset in group1 to yourset in group2, you would have to issue the following command: # cset proc --move --pid=50 --fromset=/group1/myset \\ --toset=/group2/yourset """ verbose = 0 options = [make_option('-l', '--list', help = 'list processes in the specified cpuset', action = 'store_true'), make_option('-e', '--exec', help = 'execute arguments in the specified cpuset; ' 'use the "--" option separator to separate ' 'cset options from your exec\'ed command options', dest = 'exc', action = 'store_true'), make_option('-u', '--user', help = 'use this USER to --exec (id or name)'), make_option('-g', '--group', help = 'use this GROUP to --exec (id or name)'), make_option('-m', '--move', help = 'move specified tasks to specified cpuset; ' 'to move a PIDSPEC to a cpuset, use -m PIDSPEC cpuset; ' 'to move all tasks only specify --fromset and --toset', action = 'store_true'), make_option('-p', '--pid', metavar = 'PIDSPEC', help = 'specify pid or tid specification for move'), make_option("--threads", help = 'if specified, any processes found in the PIDSPEC to have ' 'multiple threads will automatically have all their threads ' 'added to the PIDSPEC; use to move all related threads to a ' 'cpuset', action = 'store_true'), make_option('-s', '--set', metavar = 'CPUSET', help = 'specify name of immediate cpuset'), make_option('-t', '--toset', help = 'specify name of destination cpuset'), make_option('-f', '--fromset', help = 'specify name of origination cpuset'), make_option('-k', '--kthread', help = 'move, or include moving, unbound kernel threads', action = 'store_true'), make_option('--force', help = 'force all processes and threads to be moved', action = 'store_true'), make_option('-v', '--verbose', help = 'prints more detailed output, additive', action = 'count') ] def func(parser, options, args): log.debug("entering func, options=%s, args=%s", options, args) global verbose if options.verbose: verbose = options.verbose cset.rescan() tset = None if options.list or options.exc: if options.set: tset = cset.unique_set(options.set) elif options.toset: tset = cset.unique_set(options.toset) elif len(args) > 0: if options.exc: tset = cset.unique_set(args[0]) del args[0] else: tset = args else: raise CpusetException("cpuset not specified") try: log.debug("operating on set %s", tset.path) except: log.debug("operating on sets %s", tset) if options.exc: run(tset, args, options.user, options.group) if options.list: list_sets(tset) return if options.move or options.kthread: fset = None tset = None # first, we need to know the destination if options.toset: tset = cset.unique_set(options.toset) elif options.set and options.pid: tset = cset.unique_set(options.set) elif options.set and options.fromset: tset = cset.unique_set(options.set) elif len(args) > 0: if len(args) > 1 and options.pid == None: options.pid = args[0] if len(args) < 3: tset = cset.unique_set(args[1]) else: # "-m 123 set1 set2" shortcut fset = cset.unique_set(args[1]) tset = cset.unique_set(args[2]) # take care of set1->set2 shortcut pids = pidspec_to_list(options.pid, threads=options.threads) if len(pids) == 1: try: fset = cset.unique_set(pids[0]) options.pid = None except: pass # must be real pidspec else: if len(args) < 2: tset = cset.unique_set(args[0]) else: fset = cset.unique_set(args[0]) tset = cset.unique_set(args[1]) else: raise CpusetException("destination cpuset not specified") set.active(tset) # next, if there is a pidspec, move just that if options.pid: if options.fromset and not options.force: fset = cset.unique_set(options.fromset) elif options.toset and options.set: fset = cset.unique_set(options.set) pids = pidspec_to_list(options.pid, fset, options.threads) if len(pids): log.info('moving following pidspec: %s' % ','.join(pids)) selective_move(None, tset, pids, options.kthread, options.force) else: log.info('**> no tasks moved') log.info('done') else: fset = None # here we assume move everything from fromset to toset if options.fromset: fset = cset.unique_set(options.fromset) elif options.set: fset = cset.unique_set(options.set) elif len(args) > 0: # this must be the fromset, then... fset = cset.unique_set(args[0]) if fset == None: raise CpusetException("origination cpuset not specified") nt = len(fset.tasks) if nt == 0: raise CpusetException('no tasks to move from cpuset "%s"' % fset.path) if options.move: log.info('moving all tasks from %s to %s', fset.name, tset.path) selective_move(fset, tset, None, options.kthread, options.force, options.threads) else: log.info('moving all kernel threads from %s to %s', fset.path, tset.path) # this is a -k "move", so only move kernel threads pids = [] for task in fset.tasks: try: os.readlink('/proc/'+task+'/exe') except: pids.append(task) selective_move(fset, tset, pids, options.kthread, options.force) log.info('done') return # default no options is list list_sets(args) def list_sets(args): log.debug("entering list_sets, args=%s", args) l = [] if isinstance(args, list): for s in args: if isinstance(s, str): l.extend(cset.find_sets(s)) elif not isinstance(s, cset.CpuSet): raise CpusetException( 'list_sets() args=%s, of which "%s" not a string or CpuSet' % (args, s)) else: l.append(s) else: if isinstance(args, str): l.extend(cset.find_sets(args)) elif not isinstance(args, cset.CpuSet): raise CpusetException( "list_sets() passed args=%s, which is not a string or CpuSet" % args) else: l.append(args) if len(l) == 0: raise CpusetException("cpuset(s) to list not specified"); for s in l: if len(s.tasks) > 0: if verbose: log_detailed_task_table(s, ' ') else: log_detailed_task_table(s, ' ', 78) else: log.info(cset.summary(s)) def move(fromset, toset, plist=None, verb=None, force=None): log.debug('entering move, fromset=%s toset=%s list=%s force=%s verb=%s', fromset, toset, plist, force, verb) if isinstance(fromset, str): fset = cset.unique_set(fromset) elif not isinstance(fromset, cset.CpuSet) and plist == None: raise CpusetException( "passed fromset=%s, which is not a string or CpuSet" % fromset) else: fset = fromset if isinstance(toset, str): tset = cset.unique_set(toset) elif not isinstance(toset, cset.CpuSet): raise CpusetException( "passed toset=%s, which is not a string or CpuSet" % toset) else: tset = toset if plist == None: log.debug('moving default of all processes') if tset != fset and not force: plist = fset.tasks else: raise CpusetException( "cannot move tasks into their origination cpuset") output = 0 if verb: output = verb elif verbose: output = verbose if output: l = [] if config.mread: l.append('move_tasks_start') l.extend(task_detail_table(plist)) l.append('move_tasks_stop') else: l.append(' ') l.extend(task_detail_header(' ')) if output > 1: l.extend(task_detail_table(plist, ' ')) else: l.extend(task_detail_table(plist, ' ', 76)) log.info("\n".join(l)) # do the move... tset.tasks = plist def selective_move(fset, tset, plist=None, kthread=None, force=None, threads=None): log.debug('entering selective_move, fset=%s tset=%s plist=%s kthread=%s force=%s', fset, tset, plist, kthread, force) task_check = [] tasks = [] task_heap = [] utsk = 0 ktsk = 0 autsk = 0 aktsk = 0 utsknr = 0 ktsknr = 0 ktskb = 0 sstsk = 0 target = cset.unique_set(tset) if fset: fset = cset.unique_set(fset) if fset == target and not force: raise CpusetException( "error, same source/destination cpuset, use --force if ok") task_check = fset.tasks if plist: task_heap = plist else: task_heap = cset.unique_set(fset).tasks log.debug('processing task heap') for task in task_heap: try: # kernel threads do not have an excutable image os.readlink('/proc/'+task+'/exe') autsk += 1 if fset and not force: try: task_check.index(task) tasks.append(task) log.debug(' added task %s', task) utsk += 1 if threads: log.debug(' thread matching, looking for threads for task %s', task) dirs = os.listdir('/proc/'+task+'/task') if len(dirs) > 1: for thread in dirs: if thread != task: log.debug(' adding thread %s', thread) tasks.append(thread) utsk += 1 except ValueError: log.debug(' task %s not running in %s, skipped', task, fset.name) utsknr += 1 else: if not force and cset.lookup_task_from_cpusets(task) == target.path: log.debug(' task %s moving to orgination set %s, skipped', task, target.path) sstsk += 1 else: tasks.append(task) utsk += 1 except OSError: aktsk += 1 try: # this is in try because the task may not exist by the # time we do this, in that case, just ignore it if kthread: if force: tasks.append(task) ktsk += 1 else: if is_unbound(task): tasks.append(task) ktsk += 1 elif cset.lookup_task_from_cpusets(task) == target.path: log.debug(' task %s moving to orgination set %s, skipped', task, target.path) sstsk += 1 else: log.debug(' kernel thread %s is bound, not adding', task) ktskb += 1 except: log.debug(' kernel thread %s not found , perhaps it went away', task) ktsknr += 1 # ok, move 'em log.debug('moving %d tasks to %s ...', len(tasks), tset.name) if len(tasks) == 0: log.info('**> no task matched move criteria') if sstsk > 0: raise CpusetException('same source/destination cpuset, use --force if ok') elif len(task_heap) > 0 and not kthread: raise CpusetException('if you want to move kernel threads, use -k') elif ktskb > 0: raise CpusetException('kernel tasks are bound, use --force if ok') return if utsk > 0: l = [] l.append('moving') l.append(str(utsk)) l.append('userspace tasks to') l.append(tset.path) log.info(' '.join(l)) if utsknr > 0: l = [] l.append('--> not moving') l.append(str(utsknr)) l.append('tasks (not in fromset, use --force)') log.info(' '.join(l)) if ktsk > 0 or kthread: l = [] l.append('moving') l.append(str(ktsk)) l.append('kernel threads to:') l.append(tset.path) log.info(' '.join(l)) if ktskb > 0: l = [] l.append('--> not moving') l.append(str(ktskb)) l.append('threads (not unbound, use --force)') log.info(' '.join(l)) if aktsk > 0 and force and not kthread and autsk == 0: log.info('*** not moving kernel threads, need both --force and --kthread') if ktsknr > 0: l = [] l.append('--> not moving') l.append(str(ktsknr)) l.append('tasks because they are missing (race)') move(None, target, tasks) def run(tset, args, usr_par=None, grp_par=None): if isinstance(tset, str): s = cset.unique_set(tset) elif not isinstance(tset, cset.CpuSet): raise CpusetException( "passed set=%s, which is not a string or CpuSet" % tset) else: s = tset log.debug('entering run, set=%s args=%s ', s.path, args) set.active(s) # check user if usr_par: try: user = pwd.getpwnam(usr_par)[2] except KeyError: try: user = pwd.getpwuid(int(usr_par))[2] except: raise CpusetException('unknown user: "%s"' % usr_par) if grp_par: try: group = grp.getgrnam(grp_par)[2] except KeyError: try: group = grp.getgrgid(int(grp_par))[2] except: raise CpusetException('unknown group: "%s"' % grp_par) elif usr_par: # if user is specified but group is not, and user is not root, # then use the users group if user != 0: try: group = grp.getgrnam('users')[2] grp_par = True except: pass # just forget it # move myself into target cpuset and exec child move_pidspec(str(os.getpid()), s) log.info('--> last message, executed args into cpuset "%s", new pid is: %s', s.path, os.getpid()) # change user and group before exec if grp_par: os.setgid(group) if usr_par: os.setuid(user) os.environ["LOGNAME"] = usr_par os.environ["USERNAME"] = usr_par os.environ["USER"] = usr_par os.execvp(args[0], args) def is_unbound(proc): # FIXME: popen is slow... # --> use /proc//status -> Cpus_allowed # int(line.replace(',',''), 16) # note: delete leading zeros to compare to allcpumask line = os.popen('/usr/bin/taskset -p ' + str(proc) +' 2>/dev/null', 'r').readline() aff = line.split()[-1] log.debug('is_unbound, proc=%s aff=%s allcpumask=%s', proc, aff, cset.allcpumask) if aff == cset.allcpumask: return True return False def pidspec_to_list(pidspec, fset=None, threads=False): """create a list of process ids out of a pidspec""" log.debug('entering pidspecToList, pidspec=%s fset=%s threads=%s', pidspec, fset, threads) if fset: if isinstance(fset, str): fset = cset.unique_set(fset) elif not isinstance(fset, cset.CpuSet): raise CpusetException("passed fset=%s, which is not a string or CpuSet" % fset) log.debug('from-set specified as: %s', fset.path) if not isinstance(pidspec, str): raise CpusetException('pidspec=%s is not a string' % pidspec) groups = pidspec.split(',') plist = [] nifs = 0 if fset: chktsk = fset.tasks log.debug('parsing groups: %s', groups) for sub in groups: items = sub.split('-') if len(items) == 1: if not len(items[0]): # two consecutive commas in pidspec, just continue processing continue # one pid in this group if fset: try: chktsk.index(items[0]) plist.append(items[0]) log.debug(' added single pid: %s', items[0]) except: log.debug(' task %s not running in %s, skipped', items[0], fset.name) nifs += 1 else: plist.append(items[0]) log.debug(' added single pid: %s', items[0]) elif len(items) == 2: # a range of pids, only include those that exist rng = [str(x) for x in range(int(items[0]), int(items[1])+1) if os.access('/proc/'+str(x), os.F_OK)] if fset: for tsk in rng: try: chktsk.index(tsk) plist.append(tsk) log.debug(' added task from range: %s', tsk) except: log.debug(' task %s not running in %s, skipped', tsk, fset.name) nifs += 1 else: plist.extend(rng) log.debug(' added range of pids from %s-%s: %s', items[0], items[1], rng) else: raise CpusetException('pidspec=%s has bad group=%s' % (pidspec, items)) log.debug('raw parsed pid list of %s tasks: %s', len(plist), plist) if nifs > 0: if nifs > 1: nmsg = "tasks" else: nmsg = "task" log.info('**> skipped %s %s, not in origination set "%s"', nifs, nmsg, fset.name) log.debug('checking for duplicates...') pdict = {} dups = 0 for task in plist: if task in pdict: dups += 1 continue pdict[task] = True log.debug('found %s duplicates', dups) if threads: log.debug('thread matching activated, looking for threads...') dups = 0 hits = 0 for task in list(pdict.keys()): dirs = os.listdir('/proc/'+str(task)+'/task') if len(dirs) > 1: hits += 1 for thread in dirs: if thread in pdict: dups += 1 continue pdict[thread] = True log.debug('found %s multithreaded containers and %s duplicates', hits, dups) plist = list(pdict.keys()) log.debug('returning parsed pid list of %s tasks: %s', len(plist), plist) return plist def move_pidspec(pidspec, toset, fset=None, threads=False): log.debug('entering move_pidspec, pidspec=%s toset=%s threads=%s', pidspec, toset, threads) if not fset: pids = pidspec_to_list(pidspec, None, threads) else: # if fromset is specified, only move tasks that are in pidspec # and are running in fromset log.debug('specified fset=%s', fset) pids = pidspec_to_list(pidspec, fset, threads) if len(pids) == 0: raise CpusetException('tasks do not match all criteria, none moved') move(None, toset, pids) def task_detail(pid, width=70): # scheduler policy definitions policy = ['o', 'f', 'r', 'b', '?', 'i'] # stat location definitions statdef = { 'pid': 0, 'name': 1, 'state': 2, 'ppid': 3, 'pgid': 4, 'sid': 5, 'priority': 17, 'nice': 18, 'numthreads': 19, 'rtpriority': 39, 'rtpolicy': 40, } # get task details from /proc, stat has rtprio/policy but not uid... pid = str(pid) if not os.access('/proc/'+pid, os.F_OK): raise CpusetException('task "%s" does not exist' % pid) status = file('/proc/'+pid+'/status', 'r').readlines() stdict = {} for line in status: try: stdict[line.split()[0][:-1]] = line.split(':')[1].strip() except: pass # sometimes, we get an extra \n out of this file... stat = file('/proc/'+pid+'/stat', 'r').readline() # we assume parentheses appear only around the name stat_right_paren = stat.rfind(')') stat_left_paren = stat.find('(') stat = [stat[:stat_left_paren-1]] + \ [stat[stat_left_paren:stat_right_paren+1]] + \ stat[stat_right_paren+2:].split() cmdline = file('/proc/'+pid+'/cmdline').readline() # assume that a zero delimits the cmdline (it does now...) cmdline = cmdline.replace('\0', ' ') out = [] try: uid=pwd.getpwuid(int(stdict['Uid'].split()[0]))[0][:8].ljust(8) except: uid=stdict['Uid'].split()[0][:8].ljust(8) out.append(uid) out.append(stdict['Pid'].rjust(5)) out.append(stdict['PPid'].rjust(5)) out2 = [] out2.append(stdict['State'].split()[0]) policy_code=int(stat[statdef['rtpolicy']]) out2.append(policy[policy_code] if policy_code= width: out = out[:width-3] + "..." return out def task_detail_header(indent=None): if indent == None: istr = "" else: istr = indent l = [] l.append(istr + 'USER PID PPID SPPr TASK NAME') l.append(istr + '-------- ----- ----- ---- ---------') return l def task_detail_table(pids, indent=None, width=None): l = [] if indent == None: istr = "" else: istr = indent for task in pids: if width: l.append(istr + task_detail(task, width)) else: l.append(istr + task_detail(task, 0)) return l def log_detailed_task_table(set, indent=None, width=None): log.debug("entering print_detailed_task_table, set=%s indent=%s width=%s", set.path, indent, width) l = [] if not config.mread: l.append(cset.summary(set)) l.extend(task_detail_header(indent)) l.extend(task_detail_table(set.tasks, indent, width)) else: l.append('proc_list_start-' + set.name) l.extend(task_detail_table(set.tasks)) l.append('proc_list_stop-' + set.name) log.info("\n".join(l)) PKuo5H{ cpuset/commands/mem.py"""Memory node manipulation command """ __copyright__ = """ Copyright (C) 2016 Johannes Bechberger Copyright (C) 2007-2010 Novell Inc. Author: Alex Tsariounov This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """ import sys, os, logging from optparse import OptionParser, make_option from cpuset.commands.common import * from cpuset import cset from cpuset.util import * global log log = logging.getLogger('mem') help = 'create and destroy memory nodes within cpusets' usage = """%prog [options] [cpuset name] Create and manage memory node assignments to cpusets. Note that for non-NUMA machines, the memory node assignment will always be 0 (zero) and is so set by default. Thus this command only needs to be used for NUMA machines. """ options = [make_option('-l', '--list', help = 'list memory nodes in specified cpuset', action = 'store_true'), make_option('-c', '--create', metavar = 'NODESPEC', help = 'create a memory node in specified cpuset'), make_option('-d', '--destroy', help = 'destroy specified memory node in specified cpuset', action = 'store_true'), make_option('-m', '--move', help = 'move specified memory node to specified cpuset', action = 'store_true'), make_option('-s', '--set', metavar = 'CPUSET', help = 'specify immediate cpuset'), make_option('-t', '--toset', help = 'specify destination cpuset'), make_option('-f', '--fromset', help = 'specify origination cpuset') ] def func(parser, options, args): log.debug("entering mem, options=%s, args=%s", options, args) PKuo5H'Tppcpuset/commands/common.py"""Common functions and variables for all commands """ __copyright__ = """ Copyright (C) 2016 Johannes Bechberger Copyright (C) 2007-2010 Novell Inc. Author: Alex Tsariounov This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """ # Command exception class class CmdException(Exception): pass PKp5HIIcpuset/commands/set.py"""Cpuset manipulation command """ import math __copyright__ = """ Copyright (C) 2016 Johannes Bechberger Copyright (C) 2007-2010 Novell Inc. Author: Alex Tsariounov This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """ import sys, os, logging, time from optparse import OptionParser, make_option from cpuset import config from cpuset import cset from cpuset.util import * from cpuset.commands.common import * try: from cpuset.commands import proc except SyntaxError: raise except: pass global log log = logging.getLogger('set') help = 'create, modify and destroy cpusets' usage = """%prog [options] [cpuset name] This command is used to create, modify, and destroy cpusets. Cpusets form a tree-like structure rooted at the root cpuset which always includes all system CPUs and all system memory nodes. A cpuset is an organizational unit that defines a group of CPUs and a group of memory nodes where a process or thread (i.e. task) is allowed to run on. For non-NUMA machines, the memory node is always 0 (zero) and cannot be set to anything else. For NUMA machines, the memory node can be set to a similar specification as the CPU definition and will tie those memory nodes to that cpuset. You will usually want the memory nodes that belong to the CPUs defined to be in the same cpuset. A cpuset can have exclusive right to the CPUs defined in it. This means that only this cpuset can own these CPUs. Similarly, a cpuset can have exclusive right to the memory nodes defined in it. This means that only this cpuset can own these memory nodes. Cpusets can be specified by name or by path; however, care should be taken when specifying by name if the name is not unique. This tool will generally not let you do destructive things to non-unique cpuset names. Cpusets are uniquely specified by path. The path starts at where the cpusets filesystem is mounted so you generally do not have to know where that is. For example, so specify a cpuset that is called "two" which is a subset of "one" which in turn is a subset of the root cpuset, use the path "/one/two" regardless of where the cpusets filesystem is mounted. When specifying CPUs, a so-called CPUSPEC is used. The CPUSPEC will accept a comma-separated list of CPUs and inclusive range specifications. For example, --cpu=1,3,5-7 will assign CPU1, CPU3, CPU5, CPU6, and CPU7 to the specified cpuset. Note that cpusets follow certain rules. For example, children can only include CPUs that the parents already have. If you do not follow those rules, the kernel cpuset subsystem will not let you create that cpuset. For example, if you create a cpuset that contains CPU3, and then attempt to create a child of that cpuset with a CPU other than 3, you will get an error, and the cpuset will not be active. The error is somewhat cryptic in that it is usually a "Permission denied" error. Memory nodes are specified with a MEMSPEC in a similar way to the CPUSPEC. For example, --mem=1,3-6 will assign MEM1, MEM3, MEM4, MEM5, and MEM6 to the specified cpuset. Note that if you attempt to create or modify a cpuset with a memory node specification that is not valid, you may get a cryptic error message, "No space left on device", and the modification will not be allowed. When you destroy a cpuset, then the tasks running in that set are moved to the parent of that cpuset. If this is not what you want, then manually move those tasks to the cpuset of your choice with the 'cset proc' command (see 'cset proc --help' for more information). EXAMPLES Create a cpuset with the default memory specification: # cset set --cpu=2,4,6-8 --set=new_set This command creates a cpuset called "new_set" located off the root cpuset which holds CPUS 2,4,6,7,8 and node 0 (interleaved) memory. Note that --set is optional, and you can just specify the name for the new cpuset after all arguments. Create a cpuset that specifies both CPUs and memory nodes: # cset set --cpu=3 --mem=3 /rad/set_one Note that this command uses the full path method to specify the name of the new cpuset "/rad/set_one". It also names the new cpuset implicitly (i.e. no --set option, although you can use that if you want to). If the "set_one" name is unique, you can subsequently refer to is just by that. Memory node 3 is assigned to this cpuset as well as CPU 3. The above commands will create the new cpusets, or if they already exist, they will modify them to the new specifications.""" verbose = 0 options = [make_option('-l', '--list', help = 'list the named cpuset(s); recursive list if also -r', action = 'store_true'), make_option('-c', '--cpu', help = 'create or modify cpuset in the specified ' 'cpuset with CPUSPEC specification', metavar = 'CPUSPEC'), make_option('-m', '--mem', help = 'specify which memory nodes to assign ' 'to the created or modified cpuset (optional)', metavar = 'MEMSPEC'), make_option('-n', '--newname', help = 'rename cpuset specified with --set to NEWNAME'), make_option('-d', '--destroy', help = 'destroy specified cpuset', action = 'store_true'), make_option('-s', '--set', metavar = 'CPUSET', help = 'specify cpuset'), make_option('-r', '--recurse', help = 'do things recursively, use with --list and --destroy', action = 'store_true'), make_option('--force', help = 'force recursive deletion even if processes are running ' 'in those cpusets (they will be moved to parent cpusets)', action = 'store_true'), make_option('-x', '--usehex', help = 'use hexadecimal value for CPUSPEC and MEMSPEC when ' 'listing cpusets', action = 'store_true'), make_option('-v', '--verbose', help = 'prints more detailed output, additive', action = 'count'), make_option('--cpu_exclusive', help = 'mark this cpuset as owning its CPUs exclusively', action = 'store_true'), make_option('--mem_exclusive', help = 'mark this cpuset as owning its MEMs exclusively', action = 'store_true'), ] def func(parser, options, args): log.debug("entering func, options=%s, args=%s", options, args) global verbose if options.verbose: verbose = options.verbose cset.rescan() if options.list: if options.set: list_sets(options.set, options.recurse, options.usehex) return if len(args): list_sets(args, options.recurse, options.usehex) else: list_sets('root', options.recurse, options.usehex) return if options.cpu or options.mem: # create or modify cpuset create_from_options(options, args) return if options.newname: rename_set(options, args) return if options.destroy: if options.set: destroy_sets(options.set, options.recurse, options.force) else: destroy_sets(args, options.recurse, options.force) return if options.cpu_exclusive or options.mem_exclusive: # FIXME: modification of existing cpusets for exclusivity log.info("Modification of cpu_exclusive and mem_exclusive not implemented.") return # default behavior if no options specified is list log.debug('no options set, default is listing cpusets') if options.set: list_sets(options.set, options.recurse, options.usehex) elif len(args): list_sets(args, options.recurse, options.usehex) else: list_sets('root', options.recurse, options.usehex) def list_sets(tset, recurse=None, usehex=False): """list cpusets specified in tset as cpuset or list of cpusets, recurse if true""" log.debug('entering list_sets, tset=%s recurse=%s', tset, recurse) sl = [] if isinstance(tset, list): for s in tset: sl.extend(cset.find_sets(s)) else: sl.extend(cset.find_sets(tset)) log.debug('total unique sets in passed tset: %d', len(sl)) sl2 = [] for s in sl: sl2.append(s) if len(s.subsets) > 0: sl2.extend(s.subsets) if recurse: for node in s.subsets: for nd in cset.walk_set(node): sl2.append(nd) sl = sl2 if config.mread: pl = ['cpuset_list_start'] else: pl = [''] pl.extend(set_header(' ')) for s in sl: if verbose: pl.append(set_details(s,' ', None, usehex)) else: pl.append(set_details(s,' ', 78, usehex)) if config.mread: pl.append('cpuset_list_end') log.info("\n".join(pl)) def destroy_sets(sets, recurse=False, force=False): """destroy cpusets in list of sets, recurse if true, if force destroy if tasks running""" log.debug('enter destroy_sets, sets=%s, force=%s', sets, force) nl = [] if isinstance(sets, list): nl.extend(sets) else: nl.append(sets) # check that sets passed are ok, will raise if one is bad sl2 = [] for s in nl: st = cset.unique_set(s) sl2.append(st) if len(st.subsets) > 0: if not recurse: raise CpusetException( 'cpuset "%s" has subsets, delete them first, or use --recurse' % st.path) elif not force: raise CpusetException( 'cpuset "%s" has subsets, use --force to destroy' % st.path) sl2.extend(st.subsets) for node in st.subsets: for nd in cset.walk_set(node): sl2.append(nd) # ok, good to go if recurse: sl2.reverse() for s in sl2: s = cset.unique_set(s) # skip the root set!!! or you'll have problems... if s.path == '/': continue log.info('--> processing cpuset "%s", moving %s tasks to parent "%s"...', s.name, len(s.tasks), s.parent.path) proc.move(s, s.parent) log.info('--> deleting cpuset "%s"', s.path) destroy(s) log.info('done') def destroy(name): """destroy one cpuset by name as cset or string""" log.debug('entering destroy, name=%s', name) if isinstance(name, str): set = cset.unique_set(name) elif not isinstance(name, cset.CpuSet): raise CpusetException( "passed name=%s, which is not a string or CpuSet" % name) else: set = name tsks = set.tasks if len(tsks) > 0: # wait for tasks, sometimes it takes a little while to # have them leave the set ii = 0 while len(tsks)>0: log.debug('%i tasks still running in set %s, waiting interval %s...', len(tsks), set.name, ii+1) time.sleep(0.5) tsks = set.tasks ii += 1 if (ii) > 6: # try it for 3 seconds, bail if tasks still there raise CpusetException( "trying to destroy cpuset %s with tasks running: %s" % (set.path, set.tasks)) log.debug("tasks expired, deleting set %s" % set.path) os.rmdir(cset.CpuSet.basepath+set.path) # fixme: perhaps reparsing the all the sets is not so efficient... cset.rescan() def rename_set(options, args): """rename cpuset as specified in options and args lists""" log.debug('entering rename_set, options=%s args=%s', options, args) # figure out target cpuset name, if --set not used, use first arg name = options.newname if options.set: tset = cset.unique_set(options.set) elif len(args) > 0: tset = cset.unique_set(args[0]) else: raise CpusetException('desired cpuset not specified') path = tset.path[0:tset.path.rfind('/')+1] log.debug('target set="%s", path="%s", name="%s"', tset.path, path, name) try: if name.find('/') == -1: chk = cset.unique_set(path+name) else: if name[0:name.rfind('/')+1] != path: raise CpusetException('desired name cannot have different path') chk = cset.unique_set(name) raise CpusetException('cpuset "'+chk.path+'" already exists') except CpusetNotFound: pass except: raise if name.rfind('/') != -1: name = name[name.rfind('/')+1:] log.info('--> renaming "%s" to "%s"', cset.CpuSet.basepath+tset.path, name) os.rename(cset.CpuSet.basepath+tset.path, cset.CpuSet.basepath+path+name) cset.rescan() def create_from_options(options, args): """create cpuset as specified by options and args lists""" log.debug('entering create_from_options, options=%s args=%s', options, args) # figure out target cpuset name, if --set not used, use first arg if options.set: tset = options.set elif len(args) > 0: tset = args[0] else: raise CpusetException('cpuset not specified') cspec = None mspec = None cx = None mx = None if options.cpu: cset.cpuspec_check(options.cpu) cspec = options.cpu if options.mem: cset.memspec_check(options.mem) mspec = options.mem if options.cpu_exclusive: cx = options.cpu_exclusive if options.mem_exclusive: mx = options.mem_exclusive try: create(tset, cspec, mspec, cx, mx) if not mspec: modify(tset, memspec='0') # always need at least this log.info('--> created cpuset "%s"', tset) except CpusetExists: modify(tset, cspec, mspec, cx, mx) log.info('--> modified cpuset "%s"', tset) active(tset) def create(name, cpuspec, memspec, cx, mx): """create one cpuset by name, cpuspec, memspec, cpu and mem exclusive flags""" log.debug('entering create, name=%s cpuspec=%s memspec=%s cx=%s mx=%s', name, cpuspec, memspec, cx, mx) try: cset.unique_set(name) except CpusetNotFound: pass except: raise CpusetException('cpuset "%s" not unique, please specify by path' % name) else: raise CpusetExists('attempt to create already existing set: "%s"' % name) # FIXME: check if name is a path here os.mkdir(cset.CpuSet.basepath+'/'+name) # fixme: perhaps reparsing the all the sets is not so efficient... cset.rescan() log.debug('created new cpuset "%s"', name) modify(name, cpuspec, memspec, cx, mx) def modify(name, cpuspec=None, memspec=None, cx=None, mx=None): """modify one cpuset by name, cpuspec, memspec, cpu and mem exclusive flags""" log.debug('entering modify, name=%s cpuspec=%s memspec=%s cx=%s mx=%s', name, cpuspec, memspec, cx, mx) if isinstance(name, str): nset = cset.unique_set(name) elif not isinstance(name, cset.CpuSet): raise CpusetException( "passed name=%s, which is not a string or CpuSet" % name) else: nset = name log.debug('modifying cpuset "%s"', nset.name) if cpuspec: nset.cpus = cpuspec if memspec: nset.mems = memspec if cx: nset.cpu_exclusive = cx if mx: nset.mem_exclusive = mx def active(name): """check that cpuset by name or cset is ready to be used""" log.debug("entering active, name=%s", name) if isinstance(name, str): set = cset.unique_set(name) elif not isinstance(name, cset.CpuSet): raise CpusetException("passing bogus name=%s" % name) else: set = name if set.cpus == '': raise CpusetException('"%s" cpuset not active, no cpus defined' % set.path) if set.mems == '': raise CpusetException('"%s" cpuset not active, no mems defined' % set.path) def set_header(indent=None): """return list of cpuset output header""" if indent: istr = indent else: istr = '' l = [] # '123456789-123456789-123456789-123456789-123456789-123456789-' l.append(istr + ' Name CPUs-X MEMs-X Tasks Subs Path') l.append(istr + '------------ ---------- - ------- - ----- ---- ----------') return l def set_details(name, indent=None, width=None, usehex=False): """return string of cpuset details""" if width == None: width = 0 if isinstance(name, str): set = cset.unique_set(name) elif not isinstance(name, cset.CpuSet): raise CpusetException("passing bogus set=%s" % name) else: set = name l = [] l.append(set.name.rjust(12)) cs = set.cpus if cs == '': cs = '*****' elif usehex: cs = cset.cpuspec_to_hex(cs) l.append(cs.rjust(10)) if set.cpu_exclusive: l.append('y') else: l.append('n') cs = set.mems if cs == '': cs = '*****' elif usehex: cs = cset.cpuspec_to_hex(cs) l.append(cs.rjust(7)) if set.mem_exclusive: l.append('y') else: l.append('n') l.append(str(len(set.tasks)).rjust(5)) l.append(str(len(set.subsets)).rjust(4)) if config.mread: l.append(set.path) l2 = [] for line in l: l2.append(line.strip()) return ';'.join(l2) out = ' '.join(l) + ' ' tst = out + set.path if width != 0 and len(tst) > width: target = width - len(out) patha = set.path[:math.floor(len(set.path)/2)-3] pathb = set.path[math.floor(len(set.path)/2):] patha = patha[:math.floor(target/2)-3] pathb = pathb[-math.floor(target/2):] out += patha + '...' + pathb else: out = tst if indent: istr = indent else: istr = '' return istr + out PKuo5H..cpuset/commands/__init__.py__copyright__ = """ Copyright (C) 2016 Johannes Bechberger Copyright (C) 2007-2010 Novell Inc. Author: Alex Tsariounov This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA --------------------------------------------------------------------- Substrate code and ideas taken from the excellent stgit 0.13, see https://gna.org/projects/stgit and http://www.procode.org/stgit/ Stacked GIT is under GPL V2 or later. --------------------------------------------------------------------- """ PKuo5HFGGcpuset/commands/shield.py"""Shield supercommand """ __copyright__ = """ Copyright (C) 2016 Johannes Bechberger Copyright (C) 2007-2010 Novell Inc. Author: Alex Tsariounov This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """ import sys, os, logging from optparse import OptionParser, make_option from cpuset.commands.common import * from cpuset.commands import proc from cpuset.commands import set from cpuset import cset from cpuset.util import * from cpuset import config global log log = logging.getLogger('shield') help = 'supercommand to set up and manage basic shielding' usage = """%prog [options] [path/program] This is a supercommand that creates basic cpu shielding. The normal cset commands can of course be used to create this basic shield, but the shield command combines many such commands to create and manage a common type of cpu shielding setup. The concept of shielding implies at minimum three cpusets, for example: root, user and system. The root cpuset always exists in all implementations of cpusets and contains all available CPUs on the machine. The system cpuset is so named because normal system tasks are made to run on it. The user cpuset is so named because that is the "shielded" cpuset on which you would run your tasks of interest. Usually, CPU zero would be in the system set and the rest of the CPUs would be in the user set. After creation of the cpusets, all processes running in the root cpuset are moved to the system cpuset. Thus any new processes or threads spawned from these processes will also run the system cpuset. If the optional --kthread=on option is given to the shield command, then all kernel threads (with exception of the per-CPU bound interrupt kernel threads) are also moved to the system set. One executes processes on the shielded user cpuset with the --exec subcommand or moves processes or threads to the shielded cpuset with the --shield subcommand. Note that you do not need to specify which cpuset a process or thread is running in initially when using the --shield subcommand. To create a shield, you would execute the shield command with the --cpu option that specifies CPUSPEC argument that assigns CPUs to be under the shield (this means assigned to the user cpuset, all other cpus will be assigned to the system set). For example: # cset shield --cpu=3 On a 4-way machine, this command will dedicate the first 3 processors, CPU0-CPU2, for the system set (unshielded) and only the last processor, CPU3, for the user set (shielded). The CPUSPEC will accept a comma separated list of CPUs and inclusive range specifications. For example, --cpu=1,3,5-7 will assign CPU1, CPU3, CPU5, CPU6, and CPU7 to the user (or shielded) cpuset. If you do not like the names "system" and "user" for the unshielded and shielded sets respectively, or if those names are used already, then use the --sysset and --userset options. For example: # cset shield --sysset=free --userset=cage --cpu=2,3 --kthread=on The above command will use the name "free" for the unshielded system cpuset, the name "cage" for the shielded user cpuset, initialize these cpusets and dedicate CPU0 and CPU1 to the "free" set and (on a 4-way machine) dedicate CPU2 and CPU3 to the "cage" set. Further, the command moves all processes and threads, including kernel threads from the root cpuset to the "free" cpuset. Note however that if you do use the --syset/--userset options, then you must continue to use those for every invocation of the shield supercommand. After initialization, you can run the process of interest on the shielded cpuset with the --exec subcommand, or move processes or threads already running to the shielded cpuset with the --shield subcommand. The PIDSPEC argument taken for the --pid (or -p) option (used in conjunction with a --shield or --unshield command) is a comma separated list of PIDs or TIDs. The list can also include brackets of PIDs or TIDs that are inclusive of the endpoints. For example: 1,2,5 Means processes 1, 2 and 5 1,2,600-700 Means processes 1, 2 and from 600 to 700 # cset shield --shield --pid=50-65 This command moves all processes and threads with PID or TID in the range 50-65 inclusive, from any cpuset they may be running in into the shielded user cpuset. Note that the range of PIDs or TIDs does not need to have every position populated. In other words, for the example above, if there is only one process, say PID 57, in the range of 50-65, then only that process will be moved. The --unshield (or -u) subcommand will remove the specified processes or threads from the shielded cpuset and move them into the unshielded (or system) cpuset. This option is use with a --pid and a PIDSPEC argument, the same as for the --shield subcommand. Both the --shield and the --unshield commands will also finally output the number of tasks running in the shield and out of the shield if you do not specify a PIDSPEC with -p. By specifying also a --verbose in addition, then you will get a listing of every task that is running in either the shield or out of the shield. Using no subcommand, ie. only "cset shield", will output the status of both shield and non-shield. Tasks will be listed if --verbose is used. You can adjust which CPUs are in the shielded cpuset by issuing the --cpu subcommand again anytime after the shield has been initialized. For example if the original shield contained CPU0 and CPU1 in the system set and CPU2 and CPU3 in the user set, if you then issue the following command: # cset shield --cpu=1,2,3 then that command will move CPU1 into the shielded "user" cpuset. Any processes or threads that were running on CPU1 that belonged to the unshielded "system" cpuset are migrated to CPU0 by the system. The --reset subcommand will in essence destroy the shield. For example, if there was a shield on a 4-way machine with CPU0 in system and CPUs 1-3 in user with processes running on the user cpuset (i.e. in the shield), and a --reset subcommand was issued, then all processes running in both system and user cpusets would be migrated to the root cpuset (which has access to all CPUs and never goes away), after which both system and user cpusets would be destroyed. Note that even though you can mix general usage of cpusets with the shielding concepts described here, you generally will not want to. For more complex shielding or usage scenarios, one would generally use the normal cpuset commands (i.e. cset set and proc) directly.""" USR_SET = '/user' SYS_SET = '/system' verbose = 0 options = [make_option('-c', '--cpu', metavar = 'CPUSPEC', help = 'modifies or initializes the shield cpusets'), make_option('-r', '--reset', help = 'destroys the shield', action = 'store_true'), make_option('-e', '--exec', help = 'executes args in the shield', dest = 'exc', action = 'store_true'), make_option('--user', help = 'use this USER for --exec (id or name)'), make_option('--group', help = 'use this GROUP for --exec (id or name)'), make_option('-s', '--shield', help = 'shield specified PIDSPEC of processes or threads', action = 'store_true'), make_option('-u', '--unshield', help = 'remove specified PIDSPEC of processes or threads from shield', action = 'store_true'), make_option('-p', '--pid', metavar = 'PIDSPEC', help = 'specify pid or tid specification for shield/unshield'), make_option("--threads", help = 'if specified, any processes found in the PIDSPEC to have ' 'multiple threads will automatically have all their threads ' 'added to the PIDSPEC; use to affect all related threads', action = 'store_true'), make_option('-k', '--kthread', metavar = 'on|off', choices = ['on', 'off'], help = 'shield from unbound interrupt threads as well'), make_option('-f', '--force', help = 'force operation, use with care', action = 'store_true'), make_option('-v', '--verbose', help = 'prints more detailed output, additive', action = 'count'), make_option('--sysset', help = 'optionally specify system cpuset name'), make_option('--userset', help = 'optionally specify user cpuset name') ] def func(parser, options, args): log.debug("entering shield, options=%s, args=%s", options, args) global verbose if options.verbose: verbose = options.verbose cset.rescan() if options.sysset: global SYS_SET SYS_SET = options.sysset if options.userset: global USR_SET USR_SET = options.userset if (not options.cpu and not options.reset and not options.exc and not options.shield and not options.unshield and not options.kthread): shield_exists() doshield = False if len(args) == 0: log.info("--> shielding system active with") print_all_stats() else: # shortcut: first assume that arg is a pidspec, if not, then exec it try: plist = proc.pidspec_to_list(args[0]) for pid in plist: int(pid) doshield = True # ok, if we're here, then it's probably a pidspec, shield it except: exec_args(args, options.user, options.group) if doshield: # drop through to shield section below options.pid = args[0] options.shield = True else: return if options.reset: reset_shield() return if options.cpu: make_shield(options.cpu, options.kthread) return if options.kthread: make_kthread(options.kthread) return if options.exc: exec_args(args, options.user, options.group) # exec_args does not return... if options.shield or options.unshield: shield_exists() if options.shield: smsg = 'shielding' to_set = USR_SET from_set = SYS_SET print_stats = print_usr_stats else: smsg = 'unshielding' to_set = SYS_SET from_set = USR_SET print_stats = print_sys_stats if options.pid == None: if len(args) > 0: # shortcut, assumes arg[0] is a pidspec options.pid = args[0] else: # no pidspec so output shield state print_stats() if options.pid: if options.threads: tmsg = '(with threads)' else: tmsg = '' log.info('--> %s following pidspec: %s %s', smsg, options.pid, tmsg) if options.force: proc.move_pidspec(options.pid, to_set, None, options.threads) else: try: proc.move_pidspec(options.pid, to_set, from_set, options.threads) except CpusetException as err: if str(err).find('do not match all criteria') != -1: log.info("--> hint: perhaps use --force if sure of command") raise log.info('done') return def print_all_stats(): print_sys_stats() print_usr_stats() def print_sys_stats(): if verbose and len(cset.unique_set(SYS_SET).tasks) > 0: if verbose == 1: proc.log_detailed_task_table(cset.unique_set(SYS_SET), ' ', 76) else: proc.log_detailed_task_table(cset.unique_set(SYS_SET), ' ') else: if config.mread: str = SYS_SET if str[0] == '/': str = str[1:] log.info('proc_list_no_tasks-' + str) else: log.info(cset.summary(cset.unique_set(SYS_SET))) def print_usr_stats(): if verbose and len(cset.unique_set(USR_SET).tasks) > 0: if verbose == 1: proc.log_detailed_task_table(cset.unique_set(USR_SET), ' ', 76) else: proc.log_detailed_task_table(cset.unique_set(USR_SET), ' ') else: if config.mread: str = USR_SET if str[0] == '/': str = str[1:] log.info('proc_list_no_tasks-' + str) else: log.info(cset.summary(cset.unique_set(USR_SET))) def shield_exists(): try: cset.unique_set(USR_SET) cset.unique_set(SYS_SET) return True except CpusetNotFound: log.debug('can\'t find "%s" and "%s" cpusets on system...', SYS_SET, USR_SET) raise CpusetException('shielding not active on system') def reset_shield(): log.info("--> deactivating/reseting shielding") shield_exists() tasks = cset.unique_set(USR_SET).tasks log.info('moving %s tasks from "%s" user set to root set...', len(tasks), USR_SET) proc.move(USR_SET, 'root', None, verbose) tasks = cset.unique_set(SYS_SET).tasks log.info('moving %s tasks from "%s" system set to root set...', len(tasks), SYS_SET) proc.move(SYS_SET, 'root', None, verbose) log.info('deleting "%s" and "%s" sets', USR_SET, SYS_SET) set.destroy(USR_SET) set.destroy(SYS_SET) log.info('done') def make_shield(cpuspec, kthread): memspec = '0' # FIXME: for numa, we probably want a more intelligent scheme log.debug("entering make_shield, cpuspec=%s kthread=%s", cpuspec, kthread) # create base cpusets for shield cset.cpuspec_check(cpuspec) cpuspec_inv = cset.cpuspec_inverse(cpuspec) try: shield_exists() except: log.debug("shielding does not exist, creating") try: set.create(USR_SET, cpuspec, memspec, True, False) set.create(SYS_SET, cpuspec_inv, memspec, True, False) except Exception as instance: # unroll try: set.destroy(USR_SET) except: pass try: set.destroy(SYS_SET) except: pass log.critical('--> failed to create shield, hint: do other cpusets exist?') raise instance log.info('--> activating shielding:') else: log.debug("shielding exists, modifying cpuspec") # note, since we're going to modify the cpu assigments to these sets, # they cannot be exclusive, the following modify() calls will make # them exclusive again cset.unique_set(USR_SET).cpu_exclusive = False cset.unique_set(SYS_SET).cpu_exclusive = False set.modify(USR_SET, cpuspec, memspec, False, False) set.modify(SYS_SET, cpuspec_inv, memspec, False, False) # reset cpu exlusivity cset.unique_set(USR_SET).cpu_exclusive = True cset.unique_set(SYS_SET).cpu_exclusive = True log.info('--> shielding modified with:') # move root tasks into system set root_tasks = cset.unique_set('/').tasks log.debug("number of root tasks are: %s", len(root_tasks)) # figure out what in root set is not a kernel thread tasks = [] for task in root_tasks: try: os.readlink('/proc/'+task+'/exe') tasks.append(task) except: pass if len(tasks) != 0: log.info("moving %s tasks from root into system cpuset...", len(tasks)) proc.move('root', SYS_SET, tasks, verbose) # move kernel theads into system set if asked for if kthread == 'on': root_tasks = cset.unique_set('/').tasks tasks = [] for task in root_tasks: try: if proc.is_unbound(task): tasks.append(task) except: pass if len(tasks) != 0: log.info("kthread shield activated, moving %s tasks into system cpuset...", len(tasks)) proc.move('root', SYS_SET, tasks, verbose) # print out stats print_all_stats() def make_kthread(state): log.debug("entering make_kthread, state=%s", state) shield_exists() if state == 'on': log.info('--> activating kthread shielding') root_tasks = cset.unique_set('/').tasks log.debug('root set has %d tasks, checking for unbound', len(root_tasks)) tasks = [] for task in root_tasks: try: if proc.is_unbound(task): tasks.append(task) except: pass if len(tasks) != 0: log.debug("total root tasks %s", len(root_tasks)) log.info("kthread shield activated, moving %s tasks into system cpuset...", len(tasks)) proc.move('root', SYS_SET, tasks, verbose) else: log.info('--> deactivating kthread shielding') usr_tasks = cset.unique_set(SYS_SET).tasks tasks = [] for task in usr_tasks: try: os.readlink('/proc/'+task+'/exe') except: tasks.append(task) if len(tasks) != 0: log.info("moving %s tasks into root cpuset...", len(tasks)) proc.move(SYS_SET, '/', tasks, verbose) log.info('done') def exec_args(args, upar, gpar): log.debug("entering exec_args, args=%s", args) shield_exists() proc.run(USR_SET, args, upar, gpar) PKf7HCC(cpuset_py3-1.0.dist-info/DESCRIPTION.rstcpuset-py ========================== Port of the cpuset utility (https://github.com/lpechacek/cpuset) to python3. Cpuset is a Python application that forms a wrapper around the standard Linux filesystem calls to make using the cpusets facilities in the Linux kernel easier. For the latest version see: https://github.com/parttimenerd/cpuset ----- Copyright (C) 2016 Johannes Bechberger Copyright (C) 2008-2011 Novell Inc. Author: Alex Tsariounov This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA PKf7Ht==)cpuset_py3-1.0.dist-info/entry_points.txt [console_scripts] cset=cpuset.main:main PKf7H˿D&cpuset_py3-1.0.dist-info/metadata.json{"classifiers": ["Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: 3 :: Only", "Operating System :: POSIX :: Linux", "Environment :: Console", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License"], "extensions": {"python.commands": {"wrap_console": {"cset": "cpuset.main:main"}}, "python.details": {"contacts": [{"email": "me@mostlynerdless.de", "name": "Johannes Bechberger", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst"}, "project_urls": {"Home": "https://github.com/parttimenerd/cpuset"}}, "python.exports": {"console_scripts": {"cset": "cpuset.main:main"}}}, "generator": "bdist_wheel (0.26.0)", "license": "MIT", "metadata_version": "2.0", "name": "cpuset-py3", "platform": "linux", "summary": "Fork of cpuset (https://github.com/lpechacek/cpuset) by Alex Tsariounov that works with python3", "version": "1.0"}PKf7H-2&cpuset_py3-1.0.dist-info/top_level.txtcpuset PKf7H}\\cpuset_py3-1.0.dist-info/WHEELWheel-Version: 1.0 Generator: bdist_wheel (0.26.0) Root-Is-Purelib: true Tag: py3-none-any PKf7H.]}C!cpuset_py3-1.0.dist-info/METADATAMetadata-Version: 2.0 Name: cpuset-py3 Version: 1.0 Summary: Fork of cpuset (https://github.com/lpechacek/cpuset) by Alex Tsariounov that works with python3 Home-page: https://github.com/parttimenerd/cpuset Author: Johannes Bechberger Author-email: me@mostlynerdless.de License: MIT Platform: linux Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3 :: Only Classifier: Operating System :: POSIX :: Linux Classifier: Environment :: Console Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License cpuset-py ========================== Port of the cpuset utility (https://github.com/lpechacek/cpuset) to python3. Cpuset is a Python application that forms a wrapper around the standard Linux filesystem calls to make using the cpusets facilities in the Linux kernel easier. For the latest version see: https://github.com/parttimenerd/cpuset ----- Copyright (C) 2016 Johannes Bechberger Copyright (C) 2008-2011 Novell Inc. Author: Alex Tsariounov This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA PKf7Hcpuset_py3-1.0.dist-info/RECORDcpuset/__init__.py,sha256=Bjde4yLz135Fv7a1BSmbbXzeguHevpfjMPnFzcXAX1Q,1070 cpuset/config.py,sha256=Pa957quR3b2Nx8Vnuc_HvQUDlCn8o-mM19eDLDR2gk4,2889 cpuset/cset.py,sha256=6TsKfbCNIKM4nPLjwJGP7ZbaUJaliBc3BDQ42awOPeQ,20403 cpuset/main.py,sha256=Z5ImBvP_QVJ8GqNEbSvH-GNuODCFp-RVGQSG0AMEqPQ,8139 cpuset/util.py,sha256=4cER2foUX_vS8AfPBBJzfP8cezakLIKEz7vzQrAl93I,2911 cpuset/version.py,sha256=ftVeQQUxym6RZIcSL-AFYf_z7SUftYDOvgCfdYvP4pE,773 cpuset/commands/__init__.py,sha256=Bjde4yLz135Fv7a1BSmbbXzeguHevpfjMPnFzcXAX1Q,1070 cpuset/commands/common.py,sha256=9A9g5tyfUobP-7y8WDzoJSYpAFaV35TVu0fJA8oRGaM,880 cpuset/commands/mem.py,sha256=jbvP_pQSS6uLUbl8GbqEdETxpbYONi2BJVLRSLbaq38,2440 cpuset/commands/proc.py,sha256=fulRD_EqB7J5tVqFzrD4XKwr_4U6463e5nMpizwSCXE,30498 cpuset/commands/set.py,sha256=Kw93RNN77u-aPQ0RC8Rrbz0U9A3ALCS-JMj-SnwN0JQ,18713 cpuset/commands/shield.py,sha256=B1mUYGgAMizltC7pDQQsrzAtXWz_FOw5nxg0RIHxVn0,18412 cpuset_py3-1.0.dist-info/DESCRIPTION.rst,sha256=NKJyTRCyrXsjWb8OQKXwPTzetWfRoN_GN1FtzAhxQRw,1091 cpuset_py3-1.0.dist-info/METADATA,sha256=Xfi8RnPbdc2NQdby6GINSF1_09icQ2YrEADldUHsco0,1724 cpuset_py3-1.0.dist-info/RECORD,, cpuset_py3-1.0.dist-info/WHEEL,sha256=zX7PHtH_7K-lEzyK75et0UBa3Bj8egCBMXe1M4gc6SU,92 cpuset_py3-1.0.dist-info/entry_points.txt,sha256=-wzjBjy0UG3kNsOrESK1kLUs7BDFJXNke1P4nAjlLBU,61 cpuset_py3-1.0.dist-info/metadata.json,sha256=188ppwzDTG_8XPQEMrfd8gpSOqhq8UxOCuVzgdI2HM4,932 cpuset_py3-1.0.dist-info/top_level.txt,sha256=QbEXI8Ar2XRoYB1k6ZnTdK1ix5SmV9-2UavkWij2SZY,7 PKvq5H OOcpuset/cset.pyPKuo5ḤGI I Ocpuset/config.pyPKuo5HTV[cpuset/main.pyPKuo5H..M{cpuset/__init__.pyPKuo5Hcpuset/version.pyPKuo5H;:_ _ ߂cpuset/util.pyPKuo5H"w"wjcpuset/commands/proc.pyPKuo5H{ cpuset/commands/mem.pyPKuo5H'Tpp}cpuset/commands/common.pyPKp5HII$cpuset/commands/set.pyPKuo5H..q\cpuset/commands/__init__.pyPKuo5HFGG`cpuset/commands/shield.pyPKf7HCC(cpuset_py3-1.0.dist-info/DESCRIPTION.rstPKf7Ht==)cpuset_py3-1.0.dist-info/entry_points.txtPKf7H˿D&cpuset_py3-1.0.dist-info/metadata.jsonPKf7H-2&cpuset_py3-1.0.dist-info/top_level.txtPKf7H}\\;cpuset_py3-1.0.dist-info/WHEELPKf7H.]}C!Ӳcpuset_py3-1.0.dist-info/METADATAPKf7Hιcpuset_py3-1.0.dist-info/RECORDPKR