Skip to content

Commit

Permalink
core: support <soft:hard> ranges for RLIMIT options
Browse files Browse the repository at this point in the history 
The new parser supports:

 <value>       - specify both limits to the same value
 <soft:hard>   - specify both limits

the size or time specific suffixes are supported, for example

  LimitRTTIME=1sec
  LimitAS=4G:16G

The patch introduces parse_rlimit_range() and rlim type (size, sec,
usec, etc.) specific parsers. No code is duplicated now.

The patch also sync docs for DefaultLimitXXX= and LimitXXX=.

References: systemd/systemd#1769
  • Loading branch information
@karelzak
karelzak committed Nov 25, 2015
1 parent 6098bb0 commit 91518d2
Show file tree
Hide file tree
Showing 4 changed files with 171 additions and 120 deletions.
27 changes: 20 additions & 7 deletions man/systemd-system.conf.xml
View file
Original file line number Diff line number Diff line change
Expand Up @@ -354,13 +354,26 @@
<listitem><para>These settings control various default
resource limits for units. See
<citerefentry><refentrytitle>setrlimit</refentrytitle><manvolnum>2</manvolnum></citerefentry>
for details. Use the string <varname>infinity</varname> to
configure no limit on a specific resource. The multiplicative suffixes
K (=1024), M (=1024*1024) and so on for G, T, P and E may be used for
resource limits measured in bytes (e.g. DefaultLimitAS=16G). These
settings may be overridden in individual units using the corresponding
LimitXXX= directives. Note that these resource limits are only
defaults for units, they are not applied to PID 1
for details. The resource limit is possible to specify in two formats,
<option>value</option> to set soft and hard limits to the same value,
or <option>soft:hard</option> to set both limits individually (e.g. DefaultLimitAS=4G:16G).
Use the string <varname>infinity</varname> to
configure no limit on a specific resource. The multiplicative
suffixes K (=1024), M (=1024*1024) and so on for G, T, P and E
may be used for resource limits measured in bytes
(e.g. DefaultLimitAS=16G). For the limits referring to time values,
the usual time units ms, s, min, h and so on may be used (see
<citerefentry><refentrytitle>systemd.time</refentrytitle><manvolnum>7</manvolnum></citerefentry>
for details). Note that if no time unit is specified for
<varname>DefaultLimitCPU=</varname> the default unit of seconds is
implied, while for <varname>DefaultLimitRTTIME=</varname> the default
unit of microseconds is implied. Also, note that the effective
granularity of the limits might influence their
enforcement. For example, time limits specified for
<varname>DefaultLimitCPU=</varname> will be rounded up implicitly to
multiples of 1s. These settings may be overridden in individual units
using the corresponding LimitXXX= directives. Note that these resource
limits are only defaults for units, they are not applied to PID 1
itself.</para></listitem>
</varlistentry>
</variablelist>
Expand Down
5 changes: 4 additions & 1 deletion man/systemd.exec.xml
View file
Original file line number Diff line number Diff line change
Expand Up @@ -630,7 +630,10 @@
<listitem><para>These settings set both soft and hard limits
of various resources for executed processes. See
<citerefentry><refentrytitle>setrlimit</refentrytitle><manvolnum>2</manvolnum></citerefentry>
for details. Use the string <varname>infinity</varname> to
for details. The resource limit is possible to specify in two formats,
<option>value</option> to set soft and hard limits to the same value,
or <option>soft:hard</option> to set both limits individually (e.g. LimitAS=4G:16G).
Use the string <varname>infinity</varname> to
configure no limit on a specific resource. The multiplicative
suffixes K (=1024), M (=1024*1024) and so on for G, T, P and E
may be used for resource limits measured in bytes
Expand Down
229 changes: 117 additions & 112 deletions src/core/load-fragment.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1089,59 +1089,120 @@ int config_parse_bounding_set(
return 0;
}

int config_parse_limit(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {

struct rlimit **rl = data;
rlim_t v;
int r;

assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);
static int rlim_parse_u64(const char *val, rlim_t *res) {
int r = 0;

rl += ltype;

if (streq(rvalue, "infinity"))
v = RLIM_INFINITY;
if (streq(val, "infinity"))
*res = RLIM_INFINITY;
else {
uint64_t u;

/* setrlimit(2) suggests rlim_t is always 64bit on Linux. */
assert_cc(sizeof(rlim_t) == sizeof(uint64_t));

r = safe_atou64(rvalue, &u);
r = safe_atou64(val, &u);
if (r >= 0 && u >= (uint64_t) RLIM_INFINITY)
r = -ERANGE;
if (r < 0) {
log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse resource value, ignoring: %s", rvalue);
return 0;
}
if (r == 0)
*res = (rlim_t) u;
}
return r;
}

static int rlim_parse_size(const char *val, rlim_t *res) {
int r = 0;

if (streq(val, "infinity"))
*res = RLIM_INFINITY;
else {
uint64_t u;

r = parse_size(val, 1024, &u);
if (r >= 0 && u >= (uint64_t) RLIM_INFINITY)
r = -ERANGE;
if (r == 0)
*res = (rlim_t) u;
}
return r;
}

static int rlim_parse_sec(const char *val, rlim_t *res) {
int r = 0;

if (streq(val, "infinity"))
*res = RLIM_INFINITY;
else {
usec_t t;

r = parse_sec(val, &t);
if (r < 0)
return r;
if (t == USEC_INFINITY)
*res = RLIM_INFINITY;
else
*res = (rlim_t) (DIV_ROUND_UP(t, USEC_PER_SEC));

}
return r;
}

static int rlim_parse_usec(const char *val, rlim_t *res) {
int r = 0;

if (streq(val, "infinity"))
*res = RLIM_INFINITY;
else {
usec_t t;

r = parse_time(val, &t, 1);
if (r < 0)
return r;
if (t == USEC_INFINITY)
*res = RLIM_INFINITY;
else
*res = (rlim_t) t;
}
return r;
}

v = (rlim_t) u;
static int parse_rlimit_range(
const char *unit,
const char *filename,
unsigned line,
const char *value,
struct rlimit **rl,
int (*rlim_parser)(const char *, rlim_t *)) {

rlim_t soft, hard;
_cleanup_free_ char *sword = NULL, *hword = NULL;
int nwords, r;

assert(value);

/* <value> or <soft:hard> */
nwords = extract_many_words(&value, ":", EXTRACT_DONT_COALESCE_SEPARATORS, &sword, &hword, NULL);
r = nwords < 0 ? nwords : nwords == 0 ? -EINVAL : 0;

if (r == 0)
r = rlim_parser(sword, &soft);
if (r == 0 && nwords == 2)
r = rlim_parser(hword, &hard);
if (r < 0) {
log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse resource value, ignoring: %s", value);
return 0;
}

if (!*rl) {
*rl = new(struct rlimit, 1);
if (!*rl)
return log_oom();
}

(*rl)->rlim_cur = (*rl)->rlim_max = v;
(*rl)->rlim_cur = soft;
(*rl)->rlim_max = nwords == 2 ? hard : soft;
return 0;
}

int config_parse_bytes_limit(
int config_parse_limit(
const char *unit,
const char *filename,
unsigned line,
Expand All @@ -1154,40 +1215,37 @@ int config_parse_bytes_limit(
void *userdata) {

struct rlimit **rl = data;
rlim_t bytes;
int r;

assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);

rl += ltype;
return parse_rlimit_range(unit, filename, line, rvalue, rl, rlim_parse_u64);
}

if (streq(rvalue, "infinity"))
bytes = RLIM_INFINITY;
else {
uint64_t u;

r = parse_size(rvalue, 1024, &u);
if (r >= 0 && u >= (uint64_t) RLIM_INFINITY)
r = -ERANGE;
if (r < 0) {
log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse resource value, ignoring: %s", rvalue);
return 0;
}
int config_parse_bytes_limit(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {

bytes = (rlim_t) u;
}
struct rlimit **rl = data;

if (!*rl) {
*rl = new(struct rlimit, 1);
if (!*rl)
return log_oom();
}
assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);

(*rl)->rlim_cur = (*rl)->rlim_max = bytes;
return 0;
rl += ltype;
return parse_rlimit_range(unit, filename, line, rvalue, rl, rlim_parse_size);
}

int config_parse_sec_limit(
Expand All @@ -1203,44 +1261,16 @@ int config_parse_sec_limit(
void *userdata) {

struct rlimit **rl = data;
rlim_t seconds;
int r;

assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);

rl += ltype;

if (streq(rvalue, "infinity"))
seconds = RLIM_INFINITY;
else {
usec_t t;

r = parse_sec(rvalue, &t);
if (r < 0) {
log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse resource value, ignoring: %s", rvalue);
return 0;
}

if (t == USEC_INFINITY)
seconds = RLIM_INFINITY;
else
seconds = (rlim_t) (DIV_ROUND_UP(t, USEC_PER_SEC));
}

if (!*rl) {
*rl = new(struct rlimit, 1);
if (!*rl)
return log_oom();
}

(*rl)->rlim_cur = (*rl)->rlim_max = seconds;
return 0;
return parse_rlimit_range(unit, filename, line, rvalue, rl, rlim_parse_sec);
}


int config_parse_usec_limit(
const char *unit,
const char *filename,
Expand All @@ -1254,42 +1284,17 @@ int config_parse_usec_limit(
void *userdata) {

struct rlimit **rl = data;
rlim_t useconds;
int r;

assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);

rl += ltype;
return parse_rlimit_range(unit, filename, line, rvalue, rl, rlim_parse_usec);
}

if (streq(rvalue, "infinity"))
useconds = RLIM_INFINITY;
else {
usec_t t;

r = parse_time(rvalue, &t, 1);
if (r < 0) {
log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse resource value, ignoring: %s", rvalue);
return 0;
}

if (t == USEC_INFINITY)
useconds = RLIM_INFINITY;
else
useconds = (rlim_t) t;
}

if (!*rl) {
*rl = new(struct rlimit, 1);
if (!*rl)
return log_oom();
}

(*rl)->rlim_cur = (*rl)->rlim_max = useconds;
return 0;
}

#ifdef HAVE_SYSV_COMPAT
int config_parse_sysv_priority(const char *unit,
Expand Down
Loading

0 comments on commit 91518d2

Please sign in to comment.