You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
808 lines
30 KiB
Python
808 lines
30 KiB
Python
"""Process manipulation command
|
|
"""
|
|
|
|
from builtins import str
|
|
from builtins import range
|
|
__copyright__ = """
|
|
Copyright (C) 2007-2010 Novell Inc.
|
|
Copyright (C) 2013-2017 SUSE
|
|
Author: Alex Tsariounov <tsariounov@gmail.com>
|
|
|
|
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/<pid>/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', 'd']
|
|
# 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<len(policy) else '?')
|
|
if stat[statdef['rtpolicy']] == '0':
|
|
out2.append('th')
|
|
elif stat[statdef['rtpolicy']] == '3':
|
|
out2.append('at')
|
|
# SCHED_ISO is reserved but not yet implemented as of Linux v4.4
|
|
elif stat[statdef['rtpolicy']] == '4':
|
|
out2.append('??')
|
|
elif stat[statdef['rtpolicy']] == '5':
|
|
out2.append('dl')
|
|
else:
|
|
if int(stat[statdef['rtpriority']]) < 10:
|
|
out2.append('_')
|
|
out2.append(stat[statdef['rtpriority']])
|
|
else:
|
|
out2.append(stat[statdef['rtpriority']].rjust(2))
|
|
out.append(''.join(out2))
|
|
|
|
try:
|
|
os.readlink('/proc/'+pid+'/exe')
|
|
#prog = stdict['Name'] + ' '.join(cmdline.split()[1:])
|
|
prog = cmdline
|
|
except:
|
|
prog = '['+stdict['Name']+']'
|
|
out.append(prog)
|
|
|
|
if config.mread:
|
|
l2 = []
|
|
for line in out:
|
|
l2.append(line.strip())
|
|
return ';'.join(l2)
|
|
|
|
out = ' '.join(out)
|
|
if width != 0 and len(out) >= 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))
|
|
|