Batasi penggunaan memori untuk satu proses Linux

Saya sedang menjalankan pdftoppmuntuk mengubah PDF yang disediakan pengguna menjadi gambar 300DPI. Ini berfungsi dengan baik, kecuali jika pengguna menyediakan PDF dengan ukuran halaman yang sangat besar. pdftoppmakan mengalokasikan cukup memori untuk menampung gambar 300DPI dari ukuran itu dalam memori, yang untuk halaman persegi 100 inci adalah 100 * 300 * 100 * 300 * 4 byte per piksel = 3,5GB. Seorang pengguna jahat hanya bisa memberi saya PDF besar-konyol dan menyebabkan semua jenis masalah.

Jadi yang ingin saya lakukan adalah meletakkan beberapa batasan keras pada penggunaan memori untuk proses anak yang akan saya jalankan - proses saja mati jika mencoba mengalokasikan lebih dari, katakanlah, 500MB memori. Apakah itu mungkin?

Saya tidak berpikir ulimit dapat digunakan untuk ini, tetapi apakah ada satu proses yang setara?

Ada beberapa masalah dengan ulimit. Berikut ini adalah bacaan yang bermanfaat tentang topik ini: Membatasi konsumsi waktu dan memori dari suatu program di Linux , yang mengarah ke alat batas waktu , yang memungkinkan Anda membatasi proses (dan forknya) berdasarkan konsumsi waktu atau memori.

Alat timeout membutuhkan Perl 5+ dan sistem /procfile terpasang. Setelah itu Anda menyalin alat ke eg /usr/local/binseperti:

curl https://raw.githubusercontent.com/pshved/timeout/master/timeout | \
  sudo tee /usr/local/bin/timeout && sudo chmod 755 /usr/local/bin/timeout

Setelah itu, Anda dapat 'membatasi' proses Anda dengan konsumsi memori seperti pada pertanyaan Anda seperti:

timeout -m 500 pdftoppm Sample.pdf

Atau Anda dapat menggunakan -t <seconds>dan -x <hertz>membatasi masing-masing proses berdasarkan waktu atau kendala CPU.

Cara alat ini bekerja adalah dengan memeriksa beberapa kali per detik jika proses spawned belum kelebihan batas yang ditetapkan. Ini berarti sebenarnya ada jendela kecil di mana suatu proses berpotensi menjadi kelebihan langganan sebelum pemberitahuan batas waktu dan membunuh proses.

Maka, pendekatan yang lebih tepat kemungkinan akan melibatkan cgroup, tetapi itu jauh lebih terlibat untuk diatur, bahkan jika Anda akan menggunakan Docker atau runC, yang di antaranya, menawarkan abstraksi yang lebih ramah pengguna di sekitar cgroup.

Cara lain untuk membatasi ini adalah dengan menggunakan grup kontrol Linux. Ini sangat berguna jika Anda ingin membatasi alokasi (atau sekelompok proses 'proses) memori fisik berbeda dari memori virtual. Sebagai contoh:

cgcreate -g memory:myGroup
echo 500M > /sys/fs/cgroup/memory/myGroup/memory.limit_in_bytes
echo 5G > /sys/fs/cgroup/memory/myGroup/memory.memsw.limit_in_bytes

akan membuat grup kontrol bernama myGroup, membatasi rangkaian proses yang berjalan di bawah myGroup hingga 500 MB memori fisik dan hingga 5.000 MB swap. Untuk menjalankan proses di bawah grup kontrol:

cgexec -g memory:myGroup pdftoppm

Perhatikan bahwa pada distribusi Ubuntu modern contoh ini mengharuskan Anda menginstal cgroup-binpaket dan mengedit /etc/default/grubuntuk mengubah GRUB_CMDLINE_LINUX_DEFAULTke:

GRUB_CMDLINE_LINUX_DEFAULT="cgroup_enable=memory swapaccount=1"

dan kemudian jalankan sudo update-grubdan reboot untuk boot dengan parameter boot kernel baru.

Jika proses Anda tidak menghasilkan lebih banyak anak yang menghabiskan sebagian besar memori, Anda dapat menggunakan setrlimitfungsi. Antarmuka pengguna yang lebih umum untuk itu adalah menggunakan ulimitperintah shell:

$ ulimit -Sv 500000     # Set ~500 mb limit
$ pdftoppm ...

Ini hanya akan membatasi memori "virtual" dari proses Anda, dengan mempertimbangkan — dan membatasi — memori yang digunakan oleh proses yang dibagikan dengan proses lain, dan memori dipetakan tetapi tidak dicadangkan (misalnya, tumpukan besar Java). Namun, memori virtual adalah perkiraan terdekat untuk proses yang tumbuh sangat besar, membuat kesalahan tersebut tidak signifikan.

Jika program Anda menghasilkan anak-anak, dan mereka yang mengalokasikan memori, itu menjadi lebih kompleks, dan Anda harus menulis skrip bantu untuk menjalankan proses di bawah kendali Anda. Saya menulis di blog saya, mengapa dan bagaimana .

Saya menggunakan skrip di bawah ini, yang sangat bagus. Ia menggunakan cgroups melalui cgmanager. Pembaruan: sekarang menggunakan perintah dari cgroup-tools. Beri nama skrip ini limitmemdan letakkan di $ PATH Anda dan Anda dapat menggunakannya seperti limitmem 100M bash. Ini akan membatasi penggunaan memori dan swap. Untuk membatasi hanya memori hapus baris dengan memory.memsw.limit_in_bytes.

sunting: Pada instalasi Linux standar ini hanya membatasi penggunaan memori, bukan menukar penggunaan. Untuk mengaktifkan pembatasan penggunaan swap, Anda harus mengaktifkan akuntansi swap pada sistem Linux Anda. Lakukan itu dengan menetapkan / menambahkan swapaccount=1di /etc/default/grubsehingga terlihat seperti

GRUB_CMDLINE_LINUX="swapaccount=1"

Kemudian jalankan sudo update-grubdan reboot.

Penafian: Saya tidak akan terkejut jika cgroup-toolsjuga rusak di masa depan. Solusi yang benar adalah dengan menggunakan api systemd untuk manajemen cgroup tetapi tidak ada alat baris perintah untuk atm itu

#!/bin/sh

# This script uses commands from the cgroup-tools package. The cgroup-tools commands access the cgroup filesystem directly which is against the (new-ish) kernel's requirement that cgroups are managed by a single entity (which usually will be systemd). Additionally there is a v2 cgroup api in development which will probably replace the existing api at some point. So expect this script to break in the future. The correct way forward would be to use systemd's apis to create the cgroups, but afaik systemd currently (feb 2018) only exposes dbus apis for which there are no command line tools yet, and I didn't feel like writing those.

# strict mode: error if commands fail or if unset variables are used
set -eu

if [ "$#" -lt 2 ]
then
    echo Usage: `basename $0` "<limit> <command>..."
    echo or: `basename $0` "<memlimit> -s <swaplimit> <command>..."
    exit 1
fi

cgname="limitmem_$$"

# parse command line args and find limits

limit="$1"
swaplimit="$limit"
shift

if [ "$1" = "-s" ]
then
    shift
    swaplimit="$1"
    shift
fi

if [ "$1" = -- ]
then
    shift
fi

if [ "$limit" = "$swaplimit" ]
then
    memsw=0
    echo "limiting memory to $limit (cgroup $cgname) for command $@" >&2
else
    memsw=1
    echo "limiting memory to $limit and total virtual memory to $swaplimit (cgroup $cgname) for command $@" >&2
fi

# create cgroup
sudo cgcreate -g "memory:$cgname"
sudo cgset -r memory.limit_in_bytes="$limit" "$cgname"
bytes_limit=`cgget -g "memory:$cgname" | grep memory.limit_in_bytes | cut -d\  -f2`

# try also limiting swap usage, but this fails if the system has no swap
if sudo cgset -r memory.memsw.limit_in_bytes="$swaplimit" "$cgname"
then
    bytes_swap_limit=`cgget -g "memory:$cgname" | grep memory.memsw.limit_in_bytes | cut -d\  -f2`
else
    echo "failed to limit swap"
    memsw=0
fi

# create a waiting sudo'd process that will delete the cgroup once we're done. This prevents the user needing to enter their password to sudo again after the main command exists, which may take longer than sudo's timeout.
tmpdir=${XDG_RUNTIME_DIR:-$TMPDIR}
tmpdir=${tmpdir:-/tmp}
fifo="$tmpdir/limitmem_$$_cgroup_closer"
mkfifo --mode=u=rw,go= "$fifo"
sudo -b sh -c "head -c1 '$fifo' >/dev/null ; cgdelete -g 'memory:$cgname'"

# spawn subshell to run in the cgroup. If the command fails we still want to remove the cgroup so unset '-e'.
set +e
(
set -e
# move subshell into cgroup
sudo cgclassify -g "memory:$cgname" --sticky `sh -c 'echo $PPID'`  # $$ returns the main shell's pid, not this subshell's.
exec "$@"
)

# grab exit code 
exitcode=$?

set -e

# show memory usage summary

peak_mem=`cgget -g "memory:$cgname" | grep memory.max_usage_in_bytes | cut -d\  -f2`
failcount=`cgget -g "memory:$cgname" | grep memory.failcnt | cut -d\  -f2`
percent=`expr "$peak_mem" / \( "$bytes_limit" / 100 \)`

echo "peak memory used: $peak_mem ($percent%); exceeded limit $failcount times" >&2

if [ "$memsw" = 1 ]
then
    peak_swap=`cgget -g "memory:$cgname" | grep memory.memsw.max_usage_in_bytes | cut -d\  -f2`
    swap_failcount=`cgget -g "memory:$cgname" |grep memory.memsw.failcnt | cut -d\  -f2`
    swap_percent=`expr "$peak_swap" / \( "$bytes_swap_limit" / 100 \)`

    echo "peak virtual memory used: $peak_swap ($swap_percent%); exceeded limit $swap_failcount times" >&2
fi

# remove cgroup by sending a byte through the pipe
echo 1 > "$fifo"
rm "$fifo"

exit $exitcode

Selain alat dari daemontools, disarankan oleh Mark Johnson, Anda juga dapat mempertimbangkan chpstyang ditemukan di runit. Runit sendiri dibundel busybox, jadi Anda mungkin sudah menginstalnya.

The halaman manual darichpst menunjukkan pilihan:

-m byte batas memori. Batasi segmen data, segmen stack, halaman fisik terkunci, dan total semua segmen per proses untuk masing-masing byte byte.

Saya menjalankan Ubuntu 18.04.2 LTS dan skrip JanKanis tidak berfungsi dengan baik seperti yang disarankannya. Menjalankan limitmem 100M scriptmembatasi 100MB RAM dengan swap tanpa batas .

Menjalankan limitmem 100M -s 100M scriptgagal secara diam-diam karena cgget -g "memory:$cgname"tidak ada parameter bernama memory.memsw.limit_in_bytes.

Jadi saya menonaktifkan swap:

# create cgroup
sudo cgcreate -g "memory:$cgname"
sudo cgset -r memory.limit_in_bytes="$limit" "$cgname"
sudo cgset -r memory.swappiness=0 "$cgname"
bytes_limit=`cgget -g "memory:$cgname" | grep memory.limit_in_bytes | cut -d\  -f2`

Pada setiap distro berbasis systemd Anda juga dapat menggunakan cgroups secara tidak langsung melalui systemd-run. Misalnya untuk kasus Anda membatasi pdftoppm500M RAM, gunakan:

systemd-run --scope -p MemoryLimit=500M pdftoppm

Catatan: ini akan meminta Anda untuk kata sandi tetapi aplikasi akan diluncurkan sebagai pengguna Anda. Jangan biarkan ini menipu Anda agar berpikir bahwa perintah itu perlu sudo, karena itu akan menyebabkan perintah berjalan di bawah root, yang hampir tidak merupakan niat Anda.

Jika Anda tidak ingin memasukkan kata sandi (setelah semua, sebagai pengguna Anda memiliki ingatan Anda, mengapa Anda memerlukan kata sandi untuk membatasinya) , Anda dapat menggunakan --useropsi, namun untuk ini untuk bekerja Anda akan memerlukan dukungan cgroupsv2 diaktifkan, yang benar sekarang perlu boot dengan systemd.unified_cgroup_hierarchyparameter kernel .