Hạn chế sử dụng bộ nhớ cho một quy trình Linux

Tôi đang chạy pdftoppmđể chuyển đổi PDF do người dùng cung cấp thành hình ảnh 300DPI. Điều này hoạt động rất tốt, trừ khi người dùng cung cấp một tệp PDF với kích thước trang rất lớn. pdftoppmsẽ phân bổ đủ bộ nhớ để chứa hình ảnh 300DPI có kích thước đó trong bộ nhớ, mà đối với trang vuông 100 inch là 100 * 300 * 100 * 300 * 4 byte mỗi pixel = 3,5GB. Một người dùng độc hại có thể chỉ cho tôi một bản PDF lớn ngớ ngẩn và gây ra tất cả các loại vấn đề.

Vì vậy, những gì tôi muốn làm là đặt một số giới hạn cứng cho việc sử dụng bộ nhớ cho một tiến trình con tôi sắp chạy - chỉ cần xử lý chết nếu nó cố phân bổ nhiều hơn 500 MB bộ nhớ. Điều đó có thể không?

Tôi không nghĩ rằng ulimit có thể được sử dụng cho việc này, nhưng liệu có tương đương một quá trình không?

Có một số vấn đề với ulimit. Đây là một bài đọc hữu ích về chủ đề: Hạn chế thời gian và mức tiêu thụ bộ nhớ của một chương trình trong Linux , dẫn đến công cụ hết thời gian , cho phép bạn lồng một tiến trình (và các nhánh của nó) theo thời gian hoặc mức tiêu thụ bộ nhớ.

Công cụ hết thời gian yêu cầu Perl 5+ và /prochệ thống tập tin được gắn kết. Sau đó, bạn sao chép công cụ để ví dụ /usr/local/binnhư vậy:

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

Sau đó, bạn có thể 'lồng' quy trình của mình bằng mức tiêu thụ bộ nhớ như trong câu hỏi của bạn như vậy:

timeout -m 500 pdftoppm Sample.pdf

Ngoài ra, bạn có thể sử dụng -t <seconds>và -x <hertz>để tương ứng giới hạn quá trình theo thời gian hoặc các ràng buộc CPU.

Cách thức hoạt động của công cụ này là bằng cách kiểm tra nhiều lần trong một giây nếu quá trình sinh ra chưa đăng ký vượt quá các ranh giới đã đặt của nó. Điều này có nghĩa là thực sự có một cửa sổ nhỏ nơi một quy trình có khả năng được đăng ký vượt mức trước khi thông báo hết thời gian và giết chết quy trình.

Do đó, một cách tiếp cận đúng hơn có thể liên quan đến các nhóm, nhưng nó liên quan nhiều hơn đến việc thiết lập, ngay cả khi bạn sử dụng Docker hoặc runC, trong số đó, cung cấp một sự trừu tượng thân thiện hơn với các nhóm.

Một cách khác để hạn chế điều này là sử dụng các nhóm kiểm soát của Linux. Điều này đặc biệt hữu ích nếu bạn muốn giới hạn phân bổ bộ nhớ vật lý của một quá trình (hoặc nhóm quy trình) khác biệt với bộ nhớ ảo. Ví dụ:

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

sẽ tạo một nhóm điều khiển có tên myGroup, giới hạn tập hợp các quy trình chạy trong mygroup lên tới 500 MB bộ nhớ vật lý và tối đa 5000 MB trao đổi. Để chạy một quy trình trong nhóm kiểm soát:

cgexec -g memory:myGroup pdftoppm

Lưu ý rằng trên bản phân phối Ubuntu hiện đại, ví dụ này yêu cầu cài đặt cgroup-bingói và chỉnh sửa /etc/default/grubđể thay đổi GRUB_CMDLINE_LINUX_DEFAULTthành:

GRUB_CMDLINE_LINUX_DEFAULT="cgroup_enable=memory swapaccount=1"

và sau đó chạy sudo update-grubvà khởi động lại để khởi động với các tham số khởi động kernel mới.

Nếu quy trình của bạn không sinh ra nhiều trẻ tiêu tốn nhiều bộ nhớ nhất, bạn có thể sử dụng setrlimitchức năng. Giao diện người dùng phổ biến hơn cho việc đó là sử dụng ulimitlệnh của trình bao:

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

Điều này sẽ chỉ giới hạn bộ nhớ "ảo" trong quy trình của bạn, có tính đến tài khoản và giới hạn bộ nhớ mà quy trình đang được gọi chia sẻ với các quy trình khác và bộ nhớ được ánh xạ nhưng không được bảo lưu (ví dụ, đống lớn của Java). Tuy nhiên, bộ nhớ ảo là xấp xỉ gần nhất cho các quá trình phát triển thực sự lớn, làm cho các lỗi đã nói không đáng kể.

Nếu chương trình của bạn sinh ra trẻ em và chính chúng sẽ phân bổ bộ nhớ, nó sẽ trở nên phức tạp hơn và bạn nên viết các tập lệnh phụ trợ để chạy các quy trình dưới sự kiểm soát của bạn. Tôi đã viết trong blog của mình, tại sao và như thế nào .

Tôi đang sử dụng đoạn script dưới đây, hoạt động rất tốt. Nó sử dụng các nhóm thông qua cgmanager. Cập nhật: bây giờ sử dụng các lệnh từ cgroup-tools. Đặt tên cho tập lệnh này limitmemvà đặt nó vào $ PATH của bạn và bạn có thể sử dụng nó như thế nào limitmem 100M bash. Điều này sẽ giới hạn cả bộ nhớ và sử dụng trao đổi. Để giới hạn chỉ bộ nhớ loại bỏ dòng với memory.memsw.limit_in_bytes.

chỉnh sửa: Trên các cài đặt Linux mặc định, điều này chỉ giới hạn việc sử dụng bộ nhớ, không trao đổi sử dụng. Để kích hoạt giới hạn sử dụng trao đổi, bạn cần kích hoạt tính toán trao đổi trên hệ thống Linux của mình. Làm điều đó bằng cách thiết lập / thêm swapaccount=1vào /etc/default/grubđể nó trông giống như

GRUB_CMDLINE_LINUX="swapaccount=1"

Sau đó chạy sudo update-grubvà khởi động lại.

Tuyên bố miễn trừ trách nhiệm: Tôi sẽ không ngạc nhiên nếu cgroup-toolscũng sẽ phá vỡ trong tương lai. Giải pháp chính xác là sử dụng api của systemd để quản lý nhóm nhưng không có công cụ dòng lệnh nào cho atm đó

#!/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

Ngoài các công cụ từ daemontools, được đề xuất bởi Mark Johnson, bạn cũng có thể xem xét chpstnhững công cụ được tìm thấy trong runit. Runit tự nó được gói trong busybox, vì vậy bạn có thể đã cài đặt nó.

Các trang người đàn ông củachpst cho thấy các tùy chọn:

-m byte bộ nhớ giới hạn. Giới hạn phân đoạn dữ liệu, phân đoạn ngăn xếp, các trang vật lý bị khóa và tổng số tất cả các phân đoạn trên mỗi quy trình cho mỗi byte byte.

Tôi đang chạy Ubuntu 18.04.2 LTS và tập lệnh JanKanis không hoạt động với tôi như anh ấy gợi ý. Chạy limitmem 100M scriptlà giới hạn 100 MB RAM với trao đổi không giới hạn .

Chạy limitmem 100M -s 100M scriptkhông âm thầm như cgget -g "memory:$cgname"không có tham số có tên memory.memsw.limit_in_bytes.

Vì vậy, tôi đã vô hiệu hóa trao đổi:

# 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`

Trên bất kỳ bản phân phối dựa trên hệ thống nào, bạn cũng có thể sử dụng các nhóm trực tiếp thông qua hệ thống chạy. Ví dụ: đối với trường hợp giới hạn pdftoppm500M RAM, hãy sử dụng:

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

Lưu ý: điều này sẽ yêu cầu bạn nhập mật khẩu nhưng ứng dụng sẽ được khởi chạy với tư cách là người dùng của bạn. Không cho phép điều này khiến bạn ảo tưởng rằng lệnh cần sudo, bởi vì điều đó sẽ khiến lệnh chạy dưới quyền root, điều mà hầu như không phải là ý định của bạn.

Nếu bạn muốn không nhập mật khẩu (sau tất cả, với tư cách là người dùng bạn sở hữu bộ nhớ, tại sao bạn cần mật khẩu để giới hạn mật khẩu) , bạn có thể sử dụng --usertùy chọn này, tuy nhiên để làm việc này, bạn sẽ cần hỗ trợ cgroupsv2, đúng bây giờ yêu cầu khởi động với systemd.unified_cgroup_hierarchytham số kernel .