1*c2113380Snjoly /* $NetBSD: t_setrlimit.c,v 1.3 2012/03/11 23:26:22 njoly Exp $ */ 2774b9069Sjruoho 3774b9069Sjruoho /*- 4774b9069Sjruoho * Copyright (c) 2011 The NetBSD Foundation, Inc. 5774b9069Sjruoho * All rights reserved. 6774b9069Sjruoho * 7774b9069Sjruoho * This code is derived from software contributed to The NetBSD Foundation 8774b9069Sjruoho * by Jukka Ruohonen. 9774b9069Sjruoho * 10774b9069Sjruoho * Redistribution and use in source and binary forms, with or without 11774b9069Sjruoho * modification, are permitted provided that the following conditions 12774b9069Sjruoho * are met: 13774b9069Sjruoho * 1. Redistributions of source code must retain the above copyright 14774b9069Sjruoho * notice, this list of conditions and the following disclaimer. 15774b9069Sjruoho * 2. Redistributions in binary form must reproduce the above copyright 16774b9069Sjruoho * notice, this list of conditions and the following disclaimer in the 17774b9069Sjruoho * documentation and/or other materials provided with the distribution. 18774b9069Sjruoho * 19774b9069Sjruoho * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20774b9069Sjruoho * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21774b9069Sjruoho * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22774b9069Sjruoho * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23774b9069Sjruoho * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24774b9069Sjruoho * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25774b9069Sjruoho * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26774b9069Sjruoho * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27774b9069Sjruoho * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28774b9069Sjruoho * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29774b9069Sjruoho * POSSIBILITY OF SUCH DAMAGE. 30774b9069Sjruoho */ 31774b9069Sjruoho #include <sys/cdefs.h> 32*c2113380Snjoly __RCSID("$NetBSD: t_setrlimit.c,v 1.3 2012/03/11 23:26:22 njoly Exp $"); 33774b9069Sjruoho 34774b9069Sjruoho #include <sys/resource.h> 35774b9069Sjruoho #include <sys/mman.h> 36774b9069Sjruoho #include <sys/wait.h> 37774b9069Sjruoho 38774b9069Sjruoho #include <atf-c.h> 39774b9069Sjruoho #include <errno.h> 40774b9069Sjruoho #include <fcntl.h> 41774b9069Sjruoho #include <limits.h> 42774b9069Sjruoho #include <signal.h> 43ada921b8Sdholland #include <stdint.h> 44774b9069Sjruoho #include <stdlib.h> 45774b9069Sjruoho #include <string.h> 46774b9069Sjruoho #include <unistd.h> 47774b9069Sjruoho 48774b9069Sjruoho static void sighandler(int); 49774b9069Sjruoho static const char path[] = "setrlimit"; 50774b9069Sjruoho 51774b9069Sjruoho static const int rlimit[] = { 52774b9069Sjruoho RLIMIT_AS, 53774b9069Sjruoho RLIMIT_CORE, 54774b9069Sjruoho RLIMIT_CPU, 55774b9069Sjruoho RLIMIT_DATA, 56774b9069Sjruoho RLIMIT_FSIZE, 57774b9069Sjruoho RLIMIT_MEMLOCK, 58774b9069Sjruoho RLIMIT_NOFILE, 59774b9069Sjruoho RLIMIT_NPROC, 60774b9069Sjruoho RLIMIT_RSS, 61774b9069Sjruoho RLIMIT_SBSIZE, 62774b9069Sjruoho RLIMIT_STACK 63774b9069Sjruoho }; 64774b9069Sjruoho 65774b9069Sjruoho ATF_TC(setrlimit_basic); 66774b9069Sjruoho ATF_TC_HEAD(setrlimit_basic, tc) 67774b9069Sjruoho { 68774b9069Sjruoho atf_tc_set_md_var(tc, "descr", "A basic soft limit test"); 69774b9069Sjruoho } 70774b9069Sjruoho 71774b9069Sjruoho ATF_TC_BODY(setrlimit_basic, tc) 72774b9069Sjruoho { 73774b9069Sjruoho struct rlimit res; 74774b9069Sjruoho int *buf, lim; 75774b9069Sjruoho size_t i; 76774b9069Sjruoho 77774b9069Sjruoho buf = calloc(__arraycount(rlimit), sizeof(int)); 78774b9069Sjruoho 79774b9069Sjruoho if (buf == NULL) 80774b9069Sjruoho atf_tc_fail("initialization failed"); 81774b9069Sjruoho 82774b9069Sjruoho for (i = lim = 0; i < __arraycount(rlimit); i++) { 83774b9069Sjruoho 84774b9069Sjruoho (void)memset(&res, 0, sizeof(struct rlimit)); 85774b9069Sjruoho 86774b9069Sjruoho if (getrlimit(rlimit[i], &res) != 0) 87774b9069Sjruoho continue; 88774b9069Sjruoho 89774b9069Sjruoho if (res.rlim_cur == RLIM_INFINITY || res.rlim_cur == 0) 90774b9069Sjruoho continue; 91774b9069Sjruoho 92774b9069Sjruoho if (res.rlim_cur == res.rlim_max) /* An unprivileged run. */ 93774b9069Sjruoho continue; 94774b9069Sjruoho 95774b9069Sjruoho buf[i] = res.rlim_cur; 96774b9069Sjruoho res.rlim_cur = res.rlim_cur - 1; 97774b9069Sjruoho 98774b9069Sjruoho if (setrlimit(rlimit[i], &res) != 0) { 99774b9069Sjruoho lim = rlimit[i]; 100774b9069Sjruoho goto out; 101774b9069Sjruoho } 102774b9069Sjruoho } 103774b9069Sjruoho 104774b9069Sjruoho out: 105774b9069Sjruoho for (i = 0; i < __arraycount(rlimit); i++) { 106774b9069Sjruoho 107774b9069Sjruoho (void)memset(&res, 0, sizeof(struct rlimit)); 108774b9069Sjruoho 109774b9069Sjruoho if (buf[i] == 0) 110774b9069Sjruoho continue; 111774b9069Sjruoho 112774b9069Sjruoho if (getrlimit(rlimit[i], &res) != 0) 113774b9069Sjruoho continue; 114774b9069Sjruoho 115774b9069Sjruoho res.rlim_cur = buf[i]; 116774b9069Sjruoho 117774b9069Sjruoho (void)setrlimit(rlimit[i], &res); 118774b9069Sjruoho } 119774b9069Sjruoho 120774b9069Sjruoho if (lim != 0) 121774b9069Sjruoho atf_tc_fail("failed to set limit (%d)", lim); 122774b9069Sjruoho } 123774b9069Sjruoho 124774b9069Sjruoho ATF_TC(setrlimit_current); 125774b9069Sjruoho ATF_TC_HEAD(setrlimit_current, tc) 126774b9069Sjruoho { 127774b9069Sjruoho atf_tc_set_md_var(tc, "descr", "setrlimit(3) with current limits"); 128774b9069Sjruoho } 129774b9069Sjruoho 130774b9069Sjruoho ATF_TC_BODY(setrlimit_current, tc) 131774b9069Sjruoho { 132774b9069Sjruoho struct rlimit res; 133774b9069Sjruoho size_t i; 134774b9069Sjruoho 135774b9069Sjruoho for (i = 0; i < __arraycount(rlimit); i++) { 136774b9069Sjruoho 137774b9069Sjruoho (void)memset(&res, 0, sizeof(struct rlimit)); 138774b9069Sjruoho 139774b9069Sjruoho ATF_REQUIRE(getrlimit(rlimit[i], &res) == 0); 140774b9069Sjruoho ATF_REQUIRE(setrlimit(rlimit[i], &res) == 0); 141774b9069Sjruoho } 142774b9069Sjruoho } 143774b9069Sjruoho 144774b9069Sjruoho ATF_TC(setrlimit_err); 145774b9069Sjruoho ATF_TC_HEAD(setrlimit_err, tc) 146774b9069Sjruoho { 147774b9069Sjruoho atf_tc_set_md_var(tc, "descr", "Test error conditions"); 148774b9069Sjruoho } 149774b9069Sjruoho 150774b9069Sjruoho ATF_TC_BODY(setrlimit_err, tc) 151774b9069Sjruoho { 152774b9069Sjruoho struct rlimit res; 153774b9069Sjruoho size_t i; 154774b9069Sjruoho 155774b9069Sjruoho for (i = 0; i < __arraycount(rlimit); i++) { 156774b9069Sjruoho 157774b9069Sjruoho errno = 0; 158774b9069Sjruoho 159774b9069Sjruoho ATF_REQUIRE(getrlimit(rlimit[i], (void *)0) != 0); 160774b9069Sjruoho ATF_REQUIRE(errno == EFAULT); 161774b9069Sjruoho } 162774b9069Sjruoho 163774b9069Sjruoho errno = 0; 164774b9069Sjruoho 165774b9069Sjruoho ATF_REQUIRE(getrlimit(INT_MAX, &res) != 0); 166774b9069Sjruoho ATF_REQUIRE(errno == EINVAL); 167774b9069Sjruoho } 168774b9069Sjruoho 169774b9069Sjruoho ATF_TC_WITH_CLEANUP(setrlimit_fsize); 170774b9069Sjruoho ATF_TC_HEAD(setrlimit_fsize, tc) 171774b9069Sjruoho { 172774b9069Sjruoho atf_tc_set_md_var(tc, "descr", "Test setrlimit(2), RLIMIT_FSIZE"); 173774b9069Sjruoho } 174774b9069Sjruoho 175774b9069Sjruoho ATF_TC_BODY(setrlimit_fsize, tc) 176774b9069Sjruoho { 177774b9069Sjruoho struct rlimit res; 178774b9069Sjruoho int fd, sta; 179774b9069Sjruoho pid_t pid; 180774b9069Sjruoho 181774b9069Sjruoho fd = open(path, O_RDWR | O_CREAT, 0700); 182774b9069Sjruoho 183774b9069Sjruoho if (fd < 0) 184774b9069Sjruoho atf_tc_fail("initialization failed"); 185774b9069Sjruoho 186774b9069Sjruoho pid = fork(); 187774b9069Sjruoho ATF_REQUIRE(pid >= 0); 188774b9069Sjruoho 189774b9069Sjruoho if (pid == 0) { 190774b9069Sjruoho 191774b9069Sjruoho res.rlim_cur = 2; 192774b9069Sjruoho res.rlim_max = 2; 193774b9069Sjruoho 194774b9069Sjruoho if (setrlimit(RLIMIT_FSIZE, &res) != 0) 195774b9069Sjruoho _exit(EXIT_FAILURE); 196774b9069Sjruoho 197774b9069Sjruoho if (signal(SIGXFSZ, sighandler) == SIG_ERR) 198774b9069Sjruoho _exit(EXIT_FAILURE); 199774b9069Sjruoho 200774b9069Sjruoho /* 201774b9069Sjruoho * The third call should generate a SIGXFSZ. 202774b9069Sjruoho */ 203774b9069Sjruoho (void)write(fd, "X", 1); 204774b9069Sjruoho (void)write(fd, "X", 1); 205774b9069Sjruoho (void)write(fd, "X", 1); 206774b9069Sjruoho 207774b9069Sjruoho _exit(EXIT_FAILURE); 208774b9069Sjruoho } 209774b9069Sjruoho 210774b9069Sjruoho (void)close(fd); 211774b9069Sjruoho (void)wait(&sta); 212774b9069Sjruoho (void)unlink(path); 213774b9069Sjruoho 214774b9069Sjruoho if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) 215774b9069Sjruoho atf_tc_fail("RLIMIT_FSIZE not enforced"); 216774b9069Sjruoho } 217774b9069Sjruoho 218774b9069Sjruoho ATF_TC_CLEANUP(setrlimit_fsize, tc) 219774b9069Sjruoho { 220774b9069Sjruoho (void)unlink(path); 221774b9069Sjruoho } 222774b9069Sjruoho 223774b9069Sjruoho static void 224774b9069Sjruoho sighandler(int signo) 225774b9069Sjruoho { 226774b9069Sjruoho 227774b9069Sjruoho if (signo != SIGXFSZ) 228774b9069Sjruoho _exit(EXIT_FAILURE); 229774b9069Sjruoho 230774b9069Sjruoho _exit(EXIT_SUCCESS); 231774b9069Sjruoho } 232774b9069Sjruoho 233774b9069Sjruoho ATF_TC(setrlimit_memlock); 234774b9069Sjruoho ATF_TC_HEAD(setrlimit_memlock, tc) 235774b9069Sjruoho { 236774b9069Sjruoho atf_tc_set_md_var(tc, "descr", "Test setrlimit(2), RLIMIT_MEMLOCK"); 237774b9069Sjruoho } 238774b9069Sjruoho 239774b9069Sjruoho ATF_TC_BODY(setrlimit_memlock, tc) 240774b9069Sjruoho { 241774b9069Sjruoho struct rlimit res; 242774b9069Sjruoho void *buf; 243774b9069Sjruoho long page; 244774b9069Sjruoho pid_t pid; 245774b9069Sjruoho int sta; 246774b9069Sjruoho 247774b9069Sjruoho page = sysconf(_SC_PAGESIZE); 248774b9069Sjruoho ATF_REQUIRE(page >= 0); 249774b9069Sjruoho 250774b9069Sjruoho buf = malloc(page); 251774b9069Sjruoho pid = fork(); 252774b9069Sjruoho 253774b9069Sjruoho if (buf == NULL || pid < 0) 254774b9069Sjruoho atf_tc_fail("initialization failed"); 255774b9069Sjruoho 256774b9069Sjruoho if (pid == 0) { 257774b9069Sjruoho 258774b9069Sjruoho /* 259774b9069Sjruoho * Try to lock a page while 260774b9069Sjruoho * RLIMIT_MEMLOCK is zero. 261774b9069Sjruoho */ 262774b9069Sjruoho if (mlock(buf, page) != 0) 263774b9069Sjruoho _exit(EXIT_FAILURE); 264774b9069Sjruoho 265774b9069Sjruoho if (munlock(buf, page) != 0) 266774b9069Sjruoho _exit(EXIT_FAILURE); 267774b9069Sjruoho 268774b9069Sjruoho res.rlim_cur = 0; 269774b9069Sjruoho res.rlim_max = 0; 270774b9069Sjruoho 271774b9069Sjruoho if (setrlimit(RLIMIT_MEMLOCK, &res) != 0) 272774b9069Sjruoho _exit(EXIT_FAILURE); 273774b9069Sjruoho 274774b9069Sjruoho if (mlock(buf, page) != 0) 275774b9069Sjruoho _exit(EXIT_SUCCESS); 276774b9069Sjruoho 277774b9069Sjruoho (void)munlock(buf, page); 278774b9069Sjruoho 279774b9069Sjruoho _exit(EXIT_FAILURE); 280774b9069Sjruoho } 281774b9069Sjruoho 282774b9069Sjruoho free(buf); 283774b9069Sjruoho 284774b9069Sjruoho (void)wait(&sta); 285774b9069Sjruoho 286774b9069Sjruoho if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) 287774b9069Sjruoho atf_tc_fail("RLIMIT_MEMLOCK not enforced"); 288774b9069Sjruoho } 289774b9069Sjruoho 290774b9069Sjruoho ATF_TC(setrlimit_nofile_1); 291774b9069Sjruoho ATF_TC_HEAD(setrlimit_nofile_1, tc) 292774b9069Sjruoho { 293774b9069Sjruoho atf_tc_set_md_var(tc, "descr", "Test setrlimit(2), RLIMIT_NOFILE, #1"); 294774b9069Sjruoho } 295774b9069Sjruoho 296774b9069Sjruoho ATF_TC_BODY(setrlimit_nofile_1, tc) 297774b9069Sjruoho { 298774b9069Sjruoho struct rlimit res; 299774b9069Sjruoho int fd, i, rv, sta; 300774b9069Sjruoho pid_t pid; 301774b9069Sjruoho 302774b9069Sjruoho res.rlim_cur = 0; 303774b9069Sjruoho res.rlim_max = 0; 304774b9069Sjruoho 305774b9069Sjruoho pid = fork(); 306774b9069Sjruoho ATF_REQUIRE(pid >= 0); 307774b9069Sjruoho 308774b9069Sjruoho if (pid == 0) { 309774b9069Sjruoho 310774b9069Sjruoho /* 311774b9069Sjruoho * Close all descriptors, set RLIMIT_NOFILE 312774b9069Sjruoho * to zero, and try to open a random file. 313774b9069Sjruoho * This should fail with EMFILE. 314774b9069Sjruoho */ 315774b9069Sjruoho for (i = 0; i < 1024; i++) 316774b9069Sjruoho (void)close(i); 317774b9069Sjruoho 318774b9069Sjruoho rv = setrlimit(RLIMIT_NOFILE, &res); 319774b9069Sjruoho 320774b9069Sjruoho if (rv != 0) 321774b9069Sjruoho _exit(EXIT_FAILURE); 322774b9069Sjruoho 323774b9069Sjruoho errno = 0; 324774b9069Sjruoho fd = open("/etc/passwd", O_RDONLY); 325774b9069Sjruoho 326774b9069Sjruoho if (fd >= 0 || errno != EMFILE) 327774b9069Sjruoho _exit(EXIT_FAILURE); 328774b9069Sjruoho 329774b9069Sjruoho _exit(EXIT_SUCCESS); 330774b9069Sjruoho } 331774b9069Sjruoho 332774b9069Sjruoho (void)wait(&sta); 333774b9069Sjruoho 334774b9069Sjruoho if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) 335774b9069Sjruoho atf_tc_fail("RLIMIT_NOFILE not enforced"); 336774b9069Sjruoho } 337774b9069Sjruoho 338774b9069Sjruoho ATF_TC(setrlimit_nofile_2); 339774b9069Sjruoho ATF_TC_HEAD(setrlimit_nofile_2, tc) 340774b9069Sjruoho { 341774b9069Sjruoho atf_tc_set_md_var(tc, "descr", "Test setrlimit(2), RLIMIT_NOFILE, #2"); 342774b9069Sjruoho } 343774b9069Sjruoho 344774b9069Sjruoho ATF_TC_BODY(setrlimit_nofile_2, tc) 345774b9069Sjruoho { 346774b9069Sjruoho static const rlim_t lim = 12; 347774b9069Sjruoho struct rlimit res; 348774b9069Sjruoho int fd, i, rv, sta; 349774b9069Sjruoho pid_t pid; 350774b9069Sjruoho 351774b9069Sjruoho /* 352774b9069Sjruoho * See that an arbitrary limit on 353774b9069Sjruoho * open files is being enforced. 354774b9069Sjruoho */ 355774b9069Sjruoho res.rlim_cur = lim; 356774b9069Sjruoho res.rlim_max = lim; 357774b9069Sjruoho 358774b9069Sjruoho pid = fork(); 359774b9069Sjruoho ATF_REQUIRE(pid >= 0); 360774b9069Sjruoho 361774b9069Sjruoho if (pid == 0) { 362774b9069Sjruoho 363774b9069Sjruoho for (i = 0; i < 1024; i++) 364774b9069Sjruoho (void)close(i); 365774b9069Sjruoho 366774b9069Sjruoho rv = setrlimit(RLIMIT_NOFILE, &res); 367774b9069Sjruoho 368774b9069Sjruoho if (rv != 0) 369774b9069Sjruoho _exit(EXIT_FAILURE); 370774b9069Sjruoho 371774b9069Sjruoho for (i = 0; i < (int)lim; i++) { 372774b9069Sjruoho 373774b9069Sjruoho fd = open("/etc/passwd", O_RDONLY); 374774b9069Sjruoho 375774b9069Sjruoho if (fd < 0) 376774b9069Sjruoho _exit(EXIT_FAILURE); 377774b9069Sjruoho } 378774b9069Sjruoho 379774b9069Sjruoho /* 380774b9069Sjruoho * After the limit has been reached, 381774b9069Sjruoho * EMFILE should again follow. 382774b9069Sjruoho */ 383774b9069Sjruoho fd = open("/etc/passwd", O_RDONLY); 384774b9069Sjruoho 385774b9069Sjruoho if (fd >= 0 || errno != EMFILE) 386774b9069Sjruoho _exit(EXIT_FAILURE); 387774b9069Sjruoho 388774b9069Sjruoho _exit(EXIT_SUCCESS); 389774b9069Sjruoho } 390774b9069Sjruoho 391774b9069Sjruoho (void)wait(&sta); 392774b9069Sjruoho 393774b9069Sjruoho if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) 394774b9069Sjruoho atf_tc_fail("RLIMIT_NOFILE not enforced"); 395774b9069Sjruoho } 396774b9069Sjruoho 397774b9069Sjruoho ATF_TC(setrlimit_nproc); 398774b9069Sjruoho ATF_TC_HEAD(setrlimit_nproc, tc) 399774b9069Sjruoho { 400774b9069Sjruoho atf_tc_set_md_var(tc, "descr", "Test setrlimit(2), RLIMIT_NPROC"); 401774b9069Sjruoho atf_tc_set_md_var(tc, "require.user", "unprivileged"); 402774b9069Sjruoho } 403774b9069Sjruoho 404774b9069Sjruoho ATF_TC_BODY(setrlimit_nproc, tc) 405774b9069Sjruoho { 406774b9069Sjruoho struct rlimit res; 407774b9069Sjruoho pid_t pid, cpid; 408774b9069Sjruoho int sta; 409774b9069Sjruoho 410774b9069Sjruoho pid = fork(); 411774b9069Sjruoho ATF_REQUIRE(pid >= 0); 412774b9069Sjruoho 413774b9069Sjruoho if (pid == 0) { 414774b9069Sjruoho 415774b9069Sjruoho /* 416774b9069Sjruoho * Set RLIMIT_NPROC to zero and try to fork. 417774b9069Sjruoho */ 418774b9069Sjruoho res.rlim_cur = 0; 419774b9069Sjruoho res.rlim_max = 0; 420774b9069Sjruoho 421774b9069Sjruoho if (setrlimit(RLIMIT_NPROC, &res) != 0) 422774b9069Sjruoho _exit(EXIT_FAILURE); 423774b9069Sjruoho 424774b9069Sjruoho cpid = fork(); 425774b9069Sjruoho 426774b9069Sjruoho if (cpid < 0) 427774b9069Sjruoho _exit(EXIT_SUCCESS); 428774b9069Sjruoho 429774b9069Sjruoho _exit(EXIT_FAILURE); 430774b9069Sjruoho } 431774b9069Sjruoho 432774b9069Sjruoho (void)waitpid(pid, &sta, 0); 433774b9069Sjruoho 434774b9069Sjruoho if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) 435774b9069Sjruoho atf_tc_fail("RLIMIT_NPROC not enforced"); 436774b9069Sjruoho } 437774b9069Sjruoho 438774b9069Sjruoho ATF_TC(setrlimit_perm); 439774b9069Sjruoho ATF_TC_HEAD(setrlimit_perm, tc) 440774b9069Sjruoho { 441774b9069Sjruoho atf_tc_set_md_var(tc, "descr", "Test setrlimit(2) for EPERM"); 442774b9069Sjruoho atf_tc_set_md_var(tc, "require.user", "unprivileged"); 443774b9069Sjruoho } 444774b9069Sjruoho 445774b9069Sjruoho ATF_TC_BODY(setrlimit_perm, tc) 446774b9069Sjruoho { 447774b9069Sjruoho struct rlimit res; 448774b9069Sjruoho size_t i; 449774b9069Sjruoho 450774b9069Sjruoho /* 451774b9069Sjruoho * Try to raise the maximum limits as an user. 452774b9069Sjruoho */ 453774b9069Sjruoho for (i = 0; i < __arraycount(rlimit); i++) { 454774b9069Sjruoho 455774b9069Sjruoho ATF_REQUIRE(getrlimit(rlimit[i], &res) == 0); 456774b9069Sjruoho 457774b9069Sjruoho if (res.rlim_max == UINT64_MAX) /* Overflow. */ 458774b9069Sjruoho continue; 459774b9069Sjruoho 460774b9069Sjruoho errno = 0; 461774b9069Sjruoho res.rlim_max = res.rlim_max + 1; 462774b9069Sjruoho 463*c2113380Snjoly ATF_CHECK_ERRNO(EPERM, setrlimit(rlimit[i], &res) != 0); 464774b9069Sjruoho } 465774b9069Sjruoho } 466774b9069Sjruoho 467774b9069Sjruoho ATF_TP_ADD_TCS(tp) 468774b9069Sjruoho { 469774b9069Sjruoho 470774b9069Sjruoho ATF_TP_ADD_TC(tp, setrlimit_basic); 471774b9069Sjruoho ATF_TP_ADD_TC(tp, setrlimit_current); 472774b9069Sjruoho ATF_TP_ADD_TC(tp, setrlimit_err); 473774b9069Sjruoho ATF_TP_ADD_TC(tp, setrlimit_fsize); 474774b9069Sjruoho ATF_TP_ADD_TC(tp, setrlimit_memlock); 475774b9069Sjruoho ATF_TP_ADD_TC(tp, setrlimit_nofile_1); 476774b9069Sjruoho ATF_TP_ADD_TC(tp, setrlimit_nofile_2); 477774b9069Sjruoho ATF_TP_ADD_TC(tp, setrlimit_nproc); 478774b9069Sjruoho ATF_TP_ADD_TC(tp, setrlimit_perm); 479774b9069Sjruoho 480774b9069Sjruoho return atf_no_error(); 481774b9069Sjruoho } 482