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);
}