Fix <sys/resource.h>.
The situation here is a bit confusing. On 64-bit, rlimit and rlimit64 are
the same, and so getrlimit/getrlimit64, setrlimit/setrlimit64,
and prlimit/prlimit64 are all the same. On 32-bit, rlimit and rlimit64 are
different. 32-bit architectures other than MIPS go one step further by having
an even more limited getrlimit system call, so arm and x86 need to use
ugetrlimit instead of getrlimit. Worse, the 32-bit architectures don't have
64-bit getrlimit- and setrlimit-equivalent system calls, and you have to use
prlimit64 instead. There's no 32-bit prlimit system call, so there's no
easy implementation of that --- what should we do if the result of prlimit64
won't fit in a struct rlimit? Since 32-bit survived without prlimit/prlimit64
for this long, I'm not going to bother implementing prlimit for 32-bit.
We need the rlimit64 functions to be able to build strace 4.8 out of the box.
Change-Id: I1903d913b23016a2fc3b9f452885ac730d71e001
2014-01-09 19:17:03 +01:00
|
|
|
/*
|
|
|
|
|
* Copyright (C) 2014 The Android Open Source Project
|
|
|
|
|
*
|
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
|
*
|
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
|
*
|
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
|
* limitations under the License.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
|
|
|
|
|
|
#include <sys/resource.h>
|
|
|
|
|
|
2014-05-13 20:19:57 +02:00
|
|
|
#if defined(__GLIBC__)
|
Fix <sys/resource.h>.
The situation here is a bit confusing. On 64-bit, rlimit and rlimit64 are
the same, and so getrlimit/getrlimit64, setrlimit/setrlimit64,
and prlimit/prlimit64 are all the same. On 32-bit, rlimit and rlimit64 are
different. 32-bit architectures other than MIPS go one step further by having
an even more limited getrlimit system call, so arm and x86 need to use
ugetrlimit instead of getrlimit. Worse, the 32-bit architectures don't have
64-bit getrlimit- and setrlimit-equivalent system calls, and you have to use
prlimit64 instead. There's no 32-bit prlimit system call, so there's no
easy implementation of that --- what should we do if the result of prlimit64
won't fit in a struct rlimit? Since 32-bit survived without prlimit/prlimit64
for this long, I'm not going to bother implementing prlimit for 32-bit.
We need the rlimit64 functions to be able to build strace 4.8 out of the box.
Change-Id: I1903d913b23016a2fc3b9f452885ac730d71e001
2014-01-09 19:17:03 +01:00
|
|
|
/* The host glibc we're currently building with doesn't have prlimit64 yet. */
|
|
|
|
|
static int prlimit64(pid_t, int resource, const struct rlimit64* new_limit, struct rlimit64* old_limit) {
|
|
|
|
|
if (new_limit != NULL) {
|
|
|
|
|
return setrlimit64(resource, new_limit);
|
|
|
|
|
} else {
|
|
|
|
|
return getrlimit64(resource, old_limit);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
TEST(sys_resource, smoke) {
|
2014-05-13 20:19:57 +02:00
|
|
|
#if defined(__LP64__) || defined(__GLIBC__)
|
Fix <sys/resource.h>.
The situation here is a bit confusing. On 64-bit, rlimit and rlimit64 are
the same, and so getrlimit/getrlimit64, setrlimit/setrlimit64,
and prlimit/prlimit64 are all the same. On 32-bit, rlimit and rlimit64 are
different. 32-bit architectures other than MIPS go one step further by having
an even more limited getrlimit system call, so arm and x86 need to use
ugetrlimit instead of getrlimit. Worse, the 32-bit architectures don't have
64-bit getrlimit- and setrlimit-equivalent system calls, and you have to use
prlimit64 instead. There's no 32-bit prlimit system call, so there's no
easy implementation of that --- what should we do if the result of prlimit64
won't fit in a struct rlimit? Since 32-bit survived without prlimit/prlimit64
for this long, I'm not going to bother implementing prlimit for 32-bit.
We need the rlimit64 functions to be able to build strace 4.8 out of the box.
Change-Id: I1903d913b23016a2fc3b9f452885ac730d71e001
2014-01-09 19:17:03 +01:00
|
|
|
ASSERT_EQ(sizeof(rlimit), sizeof(rlimit64));
|
|
|
|
|
ASSERT_EQ(8U, sizeof(rlim_t));
|
|
|
|
|
#else
|
|
|
|
|
ASSERT_NE(sizeof(rlimit), sizeof(rlimit64));
|
|
|
|
|
ASSERT_EQ(4U, sizeof(rlim_t));
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
// Read with getrlimit, getrlimit64, and prlimit64.
|
|
|
|
|
// (prlimit is prlimit64 on LP64 and unimplemented on 32-bit.)
|
|
|
|
|
rlimit l32;
|
|
|
|
|
rlimit64 l64;
|
|
|
|
|
rlimit64 pr_l64;
|
|
|
|
|
ASSERT_EQ(0, getrlimit(RLIMIT_CORE, &l32));
|
|
|
|
|
ASSERT_EQ(0, getrlimit64(RLIMIT_CORE, &l64));
|
|
|
|
|
ASSERT_EQ(0, prlimit64(0, RLIMIT_CORE, NULL, &pr_l64));
|
|
|
|
|
ASSERT_EQ(l64.rlim_cur, l32.rlim_cur);
|
|
|
|
|
ASSERT_EQ(l64.rlim_cur, pr_l64.rlim_cur);
|
|
|
|
|
ASSERT_EQ(l64.rlim_max, pr_l64.rlim_max);
|
|
|
|
|
if (l64.rlim_max == RLIM64_INFINITY) {
|
|
|
|
|
ASSERT_EQ(RLIM_INFINITY, l32.rlim_max);
|
|
|
|
|
} else {
|
|
|
|
|
ASSERT_EQ(l64.rlim_max, l32.rlim_max);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Write with setrlimit and read back with everything.
|
|
|
|
|
l32.rlim_cur = 123;
|
|
|
|
|
ASSERT_EQ(0, setrlimit(RLIMIT_CORE, &l32));
|
|
|
|
|
ASSERT_EQ(0, getrlimit(RLIMIT_CORE, &l32));
|
|
|
|
|
ASSERT_EQ(0, getrlimit64(RLIMIT_CORE, &l64));
|
|
|
|
|
ASSERT_EQ(0, prlimit64(0, RLIMIT_CORE, NULL, &pr_l64));
|
|
|
|
|
ASSERT_EQ(123U, l32.rlim_cur);
|
|
|
|
|
ASSERT_EQ(l64.rlim_cur, l32.rlim_cur);
|
|
|
|
|
ASSERT_EQ(l64.rlim_cur, pr_l64.rlim_cur);
|
|
|
|
|
|
|
|
|
|
// Write with setrlimit64 and read back with everything.
|
|
|
|
|
l64.rlim_cur = 456;
|
|
|
|
|
ASSERT_EQ(0, setrlimit64(RLIMIT_CORE, &l64));
|
|
|
|
|
ASSERT_EQ(0, getrlimit(RLIMIT_CORE, &l32));
|
|
|
|
|
ASSERT_EQ(0, getrlimit64(RLIMIT_CORE, &l64));
|
|
|
|
|
ASSERT_EQ(0, prlimit64(0, RLIMIT_CORE, NULL, &pr_l64));
|
|
|
|
|
ASSERT_EQ(456U, l32.rlim_cur);
|
|
|
|
|
ASSERT_EQ(l64.rlim_cur, l32.rlim_cur);
|
|
|
|
|
ASSERT_EQ(l64.rlim_cur, pr_l64.rlim_cur);
|
|
|
|
|
|
|
|
|
|
// Write with prlimit64 and read back with everything.
|
|
|
|
|
l64.rlim_cur = 789;
|
|
|
|
|
ASSERT_EQ(0, prlimit64(0, RLIMIT_CORE, &l64, NULL));
|
|
|
|
|
ASSERT_EQ(0, getrlimit(RLIMIT_CORE, &l32));
|
|
|
|
|
ASSERT_EQ(0, getrlimit64(RLIMIT_CORE, &l64));
|
|
|
|
|
ASSERT_EQ(0, prlimit64(0, RLIMIT_CORE, NULL, &pr_l64));
|
|
|
|
|
ASSERT_EQ(789U, l32.rlim_cur);
|
|
|
|
|
ASSERT_EQ(l64.rlim_cur, l32.rlim_cur);
|
|
|
|
|
ASSERT_EQ(l64.rlim_cur, pr_l64.rlim_cur);
|
|
|
|
|
}
|
