3进程状态getrlimit()函数和setrlimit()函数

1修改进程资源限制，软限制可改，最大值不能超过硬限制，硬限制只有root用户可以修改

查看进程资源限制

cat /proc/self/limits

ulimit -a

2getrlimit()函数和setrlimit()函数

A依赖的头文件

#include<sys/time.h>

#include<sys/resource.h>

B函数声明

int getrlimit(int resource, struct rlimit*rlim);

int setrlimit(int resource, const structrlimit *rlim);

int prlimit(pid_t pid, int resource, conststruct rlimit *new_limit,

struct rlimit *old_limit);

函数说明：通过getrlimit,setrlimit,prlimit函数来获得或者设置资源的limits

描述信息

The getrlimit() and setrlimit() system calls get and set resource limitsrespectively. Each resource has anassociated soft and hard limit,as defined by the rlimit structure:

struct rlimit {

rlim_t rlim_cur; /* Soft limit */

rlim_t rlim_max; /* Hard limit (ceiling for rlim_cur) */

};

翻译：这个getrlimit()和setrlimit()函数分别获得和设置资源的limits,每个资源有一个关联的软限制和硬限制，它们被定义在rlimit结构体中。

The soft limit is thevalue that the kernel enforces for the corre‐

sponding resource. The hard limitacts as a ceiling for the soft

limit: an unprivileged process may set only its softlimit to a value

in the range from 0 up to the hard limit, and (irreversibly) lower its

hard limit. A privileged process (under Linux: one with the

CAP_SYS_RESOURCE capability) may make arbitrary changes to either limit

value.

The resource argument must be one of:

RLIMIT_AS

The maximum size of the process'svirtual memory (address space)

in bytes. This limit affects calls to brk(2), mmap(2) and

mremap(2), which fail with the error ENOMEM uponexceeding this

limit. Also automatic stack expansion will fail (andgenerate a

SIGSEGV that kills the process if no alternatestack has been

made available viasigaltstack(2)). Since the value isa long,

on machines with a 32-bit long either thislimit is at most 2

GiB, or this resource isunlimited.

RLIMIT_CORE

Maximum size of core file. When 0 no core dump files are cre‐

ated. When nonzero, larger dumps are truncated tothis size.
RLIMIT_CPU

CPU time limit in seconds. When the process reaches the soft

limit, it is sent a SIGXCPUsignal. The default action for this

signal is to terminate the process. However, the signal can be

caught, and the handler canreturn control to the main program.

If the process continues to consume CPUtime, it will be sent

SIGXCPU once per second untilthe hard limit is reached, at

which time it is sent SIGKILL. (This latter point describes

Linux behavior. Implementations vary in how they treat pro‐

cesses which continue to consume CPU time after reaching the

soft limit. Portable applications that need to catchthis sig‐

nal should perform an orderly termination uponfirst receipt of

SIGXCPU.)

RLIMIT_DATA

The maximum size of the process's data segment (initialized

data, uninitialized data, and heap). This limitaffects calls

to brk(2) and sbrk(2), which failwith the error ENOMEM upon

encountering the soft limit ofthis resource.

RLIMIT_FSIZE

The maximum size of files that theprocess may create. Attempts

to extend a file beyond this limit result in delivery of a

SIGXFSZ signal. By default, this signal terminates a process,

but a process can catch thissignal instead, in which case the

relevant system call (e.g., write(2),truncate(2)) fails with

the error EFBIG.

RLIMIT_LOCKS (Early Linux 2.4 only)

A limit on the combined number offlock(2) locks and fcntl(2)

leases that this process mayestablish.

RLIMIT_MEMLOCK

The maximum number of bytes of memory thatmay be locked into

RAM. In effect this limit is rounded down to thenearest multi‐

ple of the system page size. This limit affects mlock(2) and

mlockall(2) and the mmap(2)MAP_LOCKED operation. Since Linux

2.6.9 it also affects theshmctl(2) SHM_LOCK operation, where it

sets a maximum on the total bytesin shared memory segments (see

shmget(2)) that may be locked bythe real user ID of the calling

process. The shmctl(2) SHM_LOCK locks areaccounted for sepa‐

rately from the per-process memory locks established by

mlock(2), mlockall(2), andmmap(2) MAP_LOCKED; a process can

lock bytes up to this limit ineach of these two categories. In

Linux kernels before 2.6.9, thislimit controlled the amount of

memory that could be locked by a privileged process. Since

Linux 2.6.9, no limits are placedon the amount of memory that a

privileged process may lock, and this limit insteadgoverns the

amount of memory that anunprivileged process may lock.

RLIMIT_MSGQUEUE (Since Linux 2.6.8)

Specifies the limit on the numberof bytes that can be allocated

for POSIX message queues for the real user ID of the calling

process. This limit is enforced for mq_open(3). Each message

queue that the user createscounts (until it is removed) against

this limit according to theformula:

bytes = attr.mq_maxmsg *sizeof(struct msg_msg *) +

attr.mq_maxmsg *attr.mq_msgsize

where attr is the mq_attr structure specified as the fourth

argument to mq_open(3).

The first addend in the formula, whichincludes sizeof(struct

msg_msg *) (4 bytes onLinux/i386), ensures that the user cannot

create an unlimited number of zero-lengthmessages (such mes‐

sages nevertheless each consumesome system memory for bookkeep‐

ing overhead).

RLIMIT_NICE (since Linux 2.6.12, but seeBUGS below)

Specifies a ceiling to which the process's nice value can be

raised using setpriority(2) ornice(2). The actual ceiling for

the nice value is calculated as 20 - rlim_cur. (This strange‐

ness occurs because negative numbers cannot be specified as

resource limit values, since they typically have special mean‐

ings. For example, RLIM_INFINITY typically is thesame as -1.)

RLIMIT_NOFILE

Specifies a value one greaterthan the maximum file descriptor

number that can be opened by this process. Attempts (open(2),

pipe(2), dup(2), etc.) to exceed this limit yield the error

EMFILE. (Historically, this limit was named RLIMIT_OFILE on

BSD.)

RLIMIT_NPROC

The maximum number of processes(or, more precisely on Linux,

threads) that can be created forthe real user ID of the calling

process. Upon encountering this limit, fork(2)fails with the

error EAGAIN.

RLIMIT_RSS

Specifies the limit (in pages) of the process's resident set

(the number of virtual pagesresident in RAM). This limit has

effect only in Linux 2.4.x, x< 30, and there affects only calls

to madvise(2) specifyingMADV_WILLNEED.

RLIMIT_RTPRIO (Since Linux 2.6.12, but see BUGS)

Specifies a ceiling on thereal-time priority that may be set

for this process using sched_setscheduler(2) and sched_set‐

param(2).

RLIMIT_RTTIME (Since Linux 2.6.25)

Specifies a limit (inmicroseconds) on the amount of CPU time

that a process scheduled under areal-time scheduling policy may

consume without making a blockingsystem call. For the purpose

of this limit, each time aprocess makes a blocking system call,

the count of its consumed CPUtime is reset to zero. The CPU

time count is not reset if the process continues trying to use

the CPU but is preempted, itstime slice expires, or it calls

sched_yield(2).

Upon reaching the softlimit, the process is sent a SIGXCPU sig‐

nal. If the process catches or ignores this signaland contin‐

ues consuming CPU time, thenSIGXCPU will be generated once each

second until the hard limit is reached, at which point the

process is sent a SIGKILL signal.

The intended use of this limit is to stop arunaway real-time

process from locking up thesystem.

RLIMIT_SIGPENDING (Since Linux 2.6.8)

Specifies the limit on the numberof signals that may be queued

for the real user ID of the calling process. Both standard and

real-time signals are counted forthe purpose of checking this

limit. However, the limit is enforced only forsigqueue(3); it

is always possible to use kill(2)to queue one instance of any

of the signals that are notalready queued to the process.

RLIMIT_STACK

The maximum size of the process stack, inbytes. Upon reaching

this limit, a SIGSEGV signal isgenerated. To handle this sig‐

nal, a process must employ an alternatesignal stack (sigalt‐

stack(2)).

Since Linux 2.6.23, this limitalso determines the amount of

space used for the process'scommand-line arguments and environ‐

ment variables; for details, seeexecve(2).

prlimit()

The Linux-specific prlimit() system call combines and extends the func‐

tionality of setrlimit() and getrlimit(). It can be used to both set

and get the resource limits of an arbitrary process.

The resource argument has the same meaning as for setrlimit() and getr‐

limit().

If the new_limit argument is a not NULL, then therlimit structure to

which it points is used to set new values for the soft and hard limits

for resource. If the old_limitargument is a not NULL, then a success‐

ful call to prlimit() places the previous soft and hard limits for

resource in the rlimit structure pointed to by old_limit.

The pid argument specifies the ID of the process onwhich the call is

to operate. If pid is 0, then thecall applies to the calling process.

To set or get the resources of aprocess other than itself, the caller

must have the CAP_SYS_RESOURCE capability, or the real, effective, and

saved set user IDs of the target process must match the real user ID of

the caller and the real, effective, and saved set group IDs of the tar‐

get process must match the real group ID of the caller.

案例说明：

#define _GNU_SOURCE

#define _FILE_OFFSET_BITS 64

#include<stdio.h>

#include<time.h>

#include<stdlib.h>

#include<unistd.h>

#include<sys/resource.h>

#define errExit(msg)do{perror(msg);exit(EXIT_FAILURE);} while(0)

int main(int argc,char *argv[])

{

struct rlimit old, new;

struct rlimit *newp;

pid_t pid;

if (!(argc == 2 || argc == 4)) {

fprintf(stderr, "Usage: %s<pid> [<new-soft-limit> "

"<new-hard-limit>]\n", argv[0]);

exit(EXIT_FAILURE);

}

pid = atoi(argv[1]); /* PIDof target process */

newp = NULL;

if (argc == 4) {

new.rlim_cur = atoi(argv[2]);

new.rlim_max = atoi(argv[3]);

newp = &new;

}

/* Set CPU time limit of target process; retrieve and display

previous limit */

if (prlimit(pid, RLIMIT_CPU, newp, &old) == -1)

errExit("prlimit-1");

printf("Previous limits: soft=%lld; hard=%lld\n",

(long long) old.rlim_cur,(long long) old.rlim_max);

/* Retrieve and display new CPU time limit */

if (prlimit(pid, RLIMIT_CPU, NULL, &old) == -1)

errExit("prlimit-2");

printf("New limits: soft=%lld; hard=%lld\n",

(long long) old.rlim_cur,(long long) old.rlim_max);

exit(EXIT_FAILURE);

}

3进程状态getrlimit()函数和setrlimit()函数相关推荐

UNIX环境高级编程》笔记--getrlimit和setrlimit函数
每个进程都有一组资源限制,其中一些可以使用getrlimit和setrlimit函数进行查询和修改. [cpp] view plain copy #include <sys/resource.h ...
关于进程资源限制的getrlimit和setrlimit函数（epoll、服务器经常用）
getrlimit和setrlimit 头文件 #include <sys/resource.h> 函数原型 int getrlimit(int resource, struct rlim ...
Linux---fork函数和exec函数
这里主要介绍Unix/Linux中进程创建,fork()函数和exec()函数. 这里先介绍一下什么是进程: 进程是正在执行的程序的一个实例.每个实例都有自己的地址空间和执行状态.当操作系统给内核数据 ...
render函数和redirect函数的区别+反向解析
render函数和redirect函数的区别+反向解析 1.视图函数:一定是要包含两个对象的(render源码里面有HttpResponse对象) request对象:----->所有的请求 ...
Python day10 global关键字、函数递归、匿名函数、map函数的用法详解
1.global关键字引用全局变量,在局部全局变量改变,也会改变,global相当于指针,将地址指向全局变量的name name='littlepage'def littepage():global ...
C++ 笔记（13）— 函数（函数声明、函数定义、函数调用[传值、指针、引用]、函数参数默认值、函数重载）
每个 C++ 程序都至少有一个函数,即主函数 main() ,所有简单的程序都可以定义其他额外的函数. 1. 函数声明函数声明告诉编译器函数的名称.返回类型和参数.函数声明包括以下几个部分: ret ...
Go 学习笔记（16）— 函数（02）[函数签名、有名函数、匿名函数、调用匿名函数、匿名函数赋值给变量、匿名函数做回调函数]
1. 函数签名函数类型也叫做函数签名,可以使用 fmt.Printf("%T") 格式化参数打印函数类型. package mainimport "fmt"f ...
Go 学习笔记（15）— 函数（01）[函数定义、函数特点、多值返回、实参形参、变长参数，函数作为参数调用]
1. 函数定义 Go 语言最少有个 main() 函数.函数声明告诉了编译器函数的名称,返回类型和参数. func funcName(parameter_list)(result_list) {fun ...
MySQL 学习笔记（3）— 字符串函数、数值函数、日期时间函数、流程函数、聚集函数以及分组数据
1. 字符串函数 MySQL 的常用函数包括字符串函数.数值函数.日期时间函数.流程函数等. SELECT ascii("abc"),char(97),concat("h ...

3进程状态getrlimit()函数和setrlimit()函数

3进程状态getrlimit()函数和setrlimit()函数相关推荐

最新文章

热门文章