openrc/sh/rc-cgroup.sh
Mike Frysinger 301161a7a4 use HEAD in git URIs to point to the default branch
This makes the URIs shorter and dynamic: whatever the default branch
the repo uses will be used.
2021-12-20 20:07:00 -05:00

255 lines
6.9 KiB
Bash

# Copyright (c) 2012-2015 The OpenRC Authors.
# See the Authors file at the top-level directory of this distribution and
# https://github.com/OpenRC/openrc/blob/HEAD/AUTHORS
#
# This file is part of OpenRC. It is subject to the license terms in
# the LICENSE file found in the top-level directory of this
# distribution and at https://github.com/OpenRC/openrc/blob/HEAD/LICENSE
# This file may not be copied, modified, propagated, or distributed
# except according to the terms contained in the LICENSE file.
extra_stopped_commands="${extra_stopped_commands} cgroup_cleanup"
description_cgroup_cleanup="Kill all processes in the cgroup"
cgroup_find_path()
{
local OIFS name dir result
[ -n "$1" ] || return 0
OIFS="$IFS"
IFS=":"
while read -r _ name dir; do
[ "$name" = "$1" ] && result="$dir"
done < /proc/1/cgroup
IFS="$OIFS"
printf "%s" "${result}"
}
# This extracts all pids in a cgroup and puts them in the cgroup_pids
# variable.
# It is done this way to avoid subshells so we don't have to worry about
# locating the pid of the subshell in the cgroup.
# https://github.com/openrc/openrc/issues/396
cgroup_get_pids()
{
local cgroup_procs p
cgroup_pids=
cgroup_procs="$(cgroup2_find_path)"
if [ -n "${cgroup_procs}" ]; then
cgroup_procs="${cgroup_procs}/${RC_SVCNAME}/cgroup.procs"
else
cgroup_procs="/sys/fs/cgroup/openrc/${RC_SVCNAME}/tasks"
fi
[ -f "${cgroup_procs}" ] || return 0
while read -r p; do
[ "$p" -eq $$ ] && continue
cgroup_pids="${cgroup_pids} ${p}"
done < "${cgroup_procs}"
return 0
}
cgroup_running()
{
[ -d "/sys/fs/cgroup/unified/${RC_SVCNAME}" ] ||
[ -d "/sys/fs/cgroup/${RC_SVCNAME}" ] ||
[ -d "/sys/fs/cgroup/openrc/${RC_SVCNAME}" ]
}
cgroup_set_values()
{
[ -n "$1" ] && [ -n "$2" ] && [ -d "/sys/fs/cgroup/$1" ] || return 0
local controller h
controller="$1"
h=$(cgroup_find_path "$1")
cgroup="/sys/fs/cgroup/${1}${h}openrc_${RC_SVCNAME}"
[ -d "$cgroup" ] || mkdir -p "$cgroup"
set -- $2
local name val
while [ -n "$1" ] && [ "$controller" != "cpuacct" ]; do
case "$1" in
$controller.*)
if [ -n "${name}" ] && [ -w "${cgroup}/${name}" ] &&
[ -n "${val}" ]; then
veinfo "$RC_SVCNAME: Setting $cgroup/$name to $val"
printf "%s" "$val" > "$cgroup/$name"
fi
name=$1
val=
;;
*)
[ -n "$val" ] &&
val="$val $1" ||
val="$1"
;;
esac
shift
done
if [ -n "${name}" ] && [ -w "${cgroup}/${name}" ] && [ -n "${val}" ]; then
veinfo "$RC_SVCNAME: Setting $cgroup/$name to $val"
printf "%s" "$val" > "$cgroup/$name"
fi
if [ -w "$cgroup/tasks" ]; then
veinfo "$RC_SVCNAME: adding to $cgroup/tasks"
printf "%d" 0 > "$cgroup/tasks"
fi
return 0
}
cgroup_add_service()
{
# relocate starting process to the top of the cgroup
# it prevents from unwanted inheriting of the user
# cgroups. But may lead to a problems where that inheriting
# is needed.
for d in /sys/fs/cgroup/* ; do
[ -w "${d}"/tasks ] && printf "%d" 0 > "${d}"/tasks
done
openrc_cgroup=/sys/fs/cgroup/openrc
if [ -d "$openrc_cgroup" ]; then
cgroup="$openrc_cgroup/$RC_SVCNAME"
mkdir -p "$cgroup"
[ -w "$cgroup/tasks" ] && printf "%d" 0 > "$cgroup/tasks"
fi
}
cgroup_set_limits()
{
local blkio="${rc_cgroup_blkio:-$RC_CGROUP_BLKIO}"
[ -n "$blkio" ] && cgroup_set_values blkio "$blkio"
local cpu="${rc_cgroup_cpu:-$RC_CGROUP_CPU}"
[ -n "$cpu" ] && cgroup_set_values cpu "$cpu"
local cpuacct="${rc_cgroup_cpuacct:-$RC_CGROUP_CPUACCT}"
[ -n "$cpuacct" ] && cgroup_set_values cpuacct "$cpuacct"
local cpuset="${rc_cgroup_cpuset:-$RC_CGROUP_cpuset}"
[ -n "$cpuset" ] && cgroup_set_values cpuset "$cpuset"
local devices="${rc_cgroup_devices:-$RC_CGROUP_DEVICES}"
[ -n "$devices" ] && cgroup_set_values devices "$devices"
local hugetlb="${rc_cgroup_hugetlb:-$RC_CGROUP_HUGETLB}"
[ -n "$hugetlb" ] && cgroup_set_values hugetlb "$hugetlb"
local memory="${rc_cgroup_memory:-$RC_CGROUP_MEMORY}"
[ -n "$memory" ] && cgroup_set_values memory "$memory"
local net_cls="${rc_cgroup_net_cls:-$RC_CGROUP_NET_CLS}"
[ -n "$net_cls" ] && cgroup_set_values net_cls "$net_cls"
local net_prio="${rc_cgroup_net_prio:-$RC_CGROUP_NET_PRIO}"
[ -n "$net_prio" ] && cgroup_set_values net_prio "$net_prio"
local pids="${rc_cgroup_pids:-$RC_CGROUP_PIDS}"
[ -n "$pids" ] && cgroup_set_values pids "$pids"
return 0
}
cgroup2_find_path()
{
if grep -qw cgroup2 /proc/filesystems; then
case "${rc_cgroup_mode:-hybrid}" in
hybrid) printf "/sys/fs/cgroup/unified" ;;
unified) printf "/sys/fs/cgroup" ;;
esac
fi
return 0
}
cgroup2_remove()
{
local cgroup_path rc_cgroup_path
cgroup_path="$(cgroup2_find_path)"
[ -z "${cgroup_path}" ] && return 0
rc_cgroup_path="${cgroup_path}/${RC_SVCNAME}"
[ ! -d "${rc_cgroup_path}" ] ||
[ ! -e "${rc_cgroup_path}"/cgroup.events ] &&
return 0
grep -qx "$$" "${rc_cgroup_path}/cgroup.procs" &&
printf "%d" 0 > "${cgroup_path}/cgroup.procs"
local key populated vvalue
while read -r key value; do
case "${key}" in
populated) populated=${value} ;;
*) ;;
esac
done < "${rc_cgroup_path}/cgroup.events"
[ "${populated}" = 1 ] && return 0
rmdir "${rc_cgroup_path}"
return 0
}
cgroup2_set_limits()
{
local cgroup_path
cgroup_path="$(cgroup2_find_path)"
[ -z "${cgroup_path}" ] && return 0
mountinfo -q "${cgroup_path}"|| return 0
rc_cgroup_path="${cgroup_path}/${RC_SVCNAME}"
[ ! -d "${rc_cgroup_path}" ] && mkdir "${rc_cgroup_path}"
[ -f "${rc_cgroup_path}"/cgroup.procs ] &&
printf 0 > "${rc_cgroup_path}"/cgroup.procs
[ -z "${rc_cgroup_settings}" ] && return 0
echo "${rc_cgroup_settings}" | while read -r key value; do
[ -z "${key}" ] && continue
[ -z "${value}" ] && continue
[ ! -f "${rc_cgroup_path}/${key}" ] && continue
veinfo "${RC_SVCNAME}: cgroups: setting ${key} to ${value}"
printf "%s" "${value}" > "${rc_cgroup_path}/${key}"
done
return 0
}
cgroup2_kill_cgroup() {
local cgroup_path
cgroup_path="$(cgroup2_find_path)"
[ -z "${cgroup_path}" ] && return 1
rc_cgroup_path="${cgroup_path}/${RC_SVCNAME}"
if [ -f "${rc_cgroup_path}"/cgroup.kill ]; then
printf "%d" 1 > "${rc_cgroup_path}"/cgroup.kill
fi
return
}
cgroup_fallback_cleanup() {
ebegin "Starting fallback cgroups cleanup"
local loops=0
cgroup_get_pids
if [ -n "${cgroup_pids}" ]; then
kill -s CONT ${cgroup_pids} 2> /dev/null
kill -s "${stopsig:-TERM}" ${cgroup_pids} 2> /dev/null
yesno "${rc_send_sighup:-no}" &&
kill -s HUP ${cgroup_pids} 2> /dev/null
kill -s "${stopsig:-TERM}" ${cgroup_pids} 2> /dev/null
cgroup_get_pids
while [ -n "${cgroup_pids}" ] &&
[ "${loops}" -lt "${rc_timeout_stopsec:-90}" ]; do
loops=$((loops+1))
sleep 1
cgroup_get_pids
done
if [ -n "${cgroup_pids}" ] && yesno "${rc_send_sigkill:-yes}"; then
kill -s KILL ${cgroup_pids} 2> /dev/null
fi
fi
eend $?
}
cgroup_cleanup()
{
cgroup_running || return 0
ebegin "Starting cgroups cleanup"
cgroup2_kill_cgroup || cgroup_fallback_cleanup
cgroup2_remove
cgroup_get_pids
[ -z "${cgroup_pids}" ]
eend $? "Unable to stop all processes"
return 0
}