t_setrlimit.c revision 1.4
1 /* $NetBSD: t_setrlimit.c,v 1.4 2012/06/12 23:56:19 christos Exp $ */ 2 3 /*- 4 * Copyright (c) 2011 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jukka Ruohonen. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 #include <sys/cdefs.h> 32 __RCSID("$NetBSD: t_setrlimit.c,v 1.4 2012/06/12 23:56:19 christos Exp $"); 33 34 #include <sys/resource.h> 35 #include <sys/mman.h> 36 #include <sys/wait.h> 37 38 #include <atf-c.h> 39 #include <errno.h> 40 #include <fcntl.h> 41 #include <limits.h> 42 #include <lwp.h> 43 #include <signal.h> 44 #include <stdint.h> 45 #include <stdio.h> 46 #include <stdlib.h> 47 #include <string.h> 48 #include <ucontext.h> 49 #include <unistd.h> 50 51 static void sighandler(int); 52 static const char path[] = "setrlimit"; 53 54 static const int rlimit[] = { 55 RLIMIT_AS, 56 RLIMIT_CORE, 57 RLIMIT_CPU, 58 RLIMIT_DATA, 59 RLIMIT_FSIZE, 60 RLIMIT_MEMLOCK, 61 RLIMIT_NOFILE, 62 RLIMIT_NPROC, 63 RLIMIT_RSS, 64 RLIMIT_SBSIZE, 65 RLIMIT_STACK 66 }; 67 68 ATF_TC(setrlimit_basic); 69 ATF_TC_HEAD(setrlimit_basic, tc) 70 { 71 atf_tc_set_md_var(tc, "descr", "A basic soft limit test"); 72 } 73 74 ATF_TC_BODY(setrlimit_basic, tc) 75 { 76 struct rlimit res; 77 int *buf, lim; 78 size_t i; 79 80 buf = calloc(__arraycount(rlimit), sizeof(int)); 81 82 if (buf == NULL) 83 atf_tc_fail("initialization failed"); 84 85 for (i = lim = 0; i < __arraycount(rlimit); i++) { 86 87 (void)memset(&res, 0, sizeof(struct rlimit)); 88 89 if (getrlimit(rlimit[i], &res) != 0) 90 continue; 91 92 if (res.rlim_cur == RLIM_INFINITY || res.rlim_cur == 0) 93 continue; 94 95 if (res.rlim_cur == res.rlim_max) /* An unprivileged run. */ 96 continue; 97 98 buf[i] = res.rlim_cur; 99 res.rlim_cur = res.rlim_cur - 1; 100 101 if (setrlimit(rlimit[i], &res) != 0) { 102 lim = rlimit[i]; 103 goto out; 104 } 105 } 106 107 out: 108 for (i = 0; i < __arraycount(rlimit); i++) { 109 110 (void)memset(&res, 0, sizeof(struct rlimit)); 111 112 if (buf[i] == 0) 113 continue; 114 115 if (getrlimit(rlimit[i], &res) != 0) 116 continue; 117 118 res.rlim_cur = buf[i]; 119 120 (void)setrlimit(rlimit[i], &res); 121 } 122 123 if (lim != 0) 124 atf_tc_fail("failed to set limit (%d)", lim); 125 } 126 127 ATF_TC(setrlimit_current); 128 ATF_TC_HEAD(setrlimit_current, tc) 129 { 130 atf_tc_set_md_var(tc, "descr", "setrlimit(3) with current limits"); 131 } 132 133 ATF_TC_BODY(setrlimit_current, tc) 134 { 135 struct rlimit res; 136 size_t i; 137 138 for (i = 0; i < __arraycount(rlimit); i++) { 139 140 (void)memset(&res, 0, sizeof(struct rlimit)); 141 142 ATF_REQUIRE(getrlimit(rlimit[i], &res) == 0); 143 ATF_REQUIRE(setrlimit(rlimit[i], &res) == 0); 144 } 145 } 146 147 ATF_TC(setrlimit_err); 148 ATF_TC_HEAD(setrlimit_err, tc) 149 { 150 atf_tc_set_md_var(tc, "descr", "Test error conditions"); 151 } 152 153 ATF_TC_BODY(setrlimit_err, tc) 154 { 155 struct rlimit res; 156 size_t i; 157 158 for (i = 0; i < __arraycount(rlimit); i++) { 159 160 errno = 0; 161 162 ATF_REQUIRE(getrlimit(rlimit[i], (void *)0) != 0); 163 ATF_REQUIRE(errno == EFAULT); 164 } 165 166 errno = 0; 167 168 ATF_REQUIRE(getrlimit(INT_MAX, &res) != 0); 169 ATF_REQUIRE(errno == EINVAL); 170 } 171 172 ATF_TC_WITH_CLEANUP(setrlimit_fsize); 173 ATF_TC_HEAD(setrlimit_fsize, tc) 174 { 175 atf_tc_set_md_var(tc, "descr", "Test setrlimit(2), RLIMIT_FSIZE"); 176 } 177 178 ATF_TC_BODY(setrlimit_fsize, tc) 179 { 180 struct rlimit res; 181 int fd, sta; 182 pid_t pid; 183 184 fd = open(path, O_RDWR | O_CREAT, 0700); 185 186 if (fd < 0) 187 atf_tc_fail("initialization failed"); 188 189 pid = fork(); 190 ATF_REQUIRE(pid >= 0); 191 192 if (pid == 0) { 193 194 res.rlim_cur = 2; 195 res.rlim_max = 2; 196 197 if (setrlimit(RLIMIT_FSIZE, &res) != 0) 198 _exit(EXIT_FAILURE); 199 200 if (signal(SIGXFSZ, sighandler) == SIG_ERR) 201 _exit(EXIT_FAILURE); 202 203 /* 204 * The third call should generate a SIGXFSZ. 205 */ 206 (void)write(fd, "X", 1); 207 (void)write(fd, "X", 1); 208 (void)write(fd, "X", 1); 209 210 _exit(EXIT_FAILURE); 211 } 212 213 (void)close(fd); 214 (void)wait(&sta); 215 (void)unlink(path); 216 217 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) 218 atf_tc_fail("RLIMIT_FSIZE not enforced"); 219 } 220 221 ATF_TC_CLEANUP(setrlimit_fsize, tc) 222 { 223 (void)unlink(path); 224 } 225 226 static void 227 sighandler(int signo) 228 { 229 230 if (signo != SIGXFSZ) 231 _exit(EXIT_FAILURE); 232 233 _exit(EXIT_SUCCESS); 234 } 235 236 ATF_TC(setrlimit_memlock); 237 ATF_TC_HEAD(setrlimit_memlock, tc) 238 { 239 atf_tc_set_md_var(tc, "descr", "Test setrlimit(2), RLIMIT_MEMLOCK"); 240 } 241 242 ATF_TC_BODY(setrlimit_memlock, tc) 243 { 244 struct rlimit res; 245 void *buf; 246 long page; 247 pid_t pid; 248 int sta; 249 250 page = sysconf(_SC_PAGESIZE); 251 ATF_REQUIRE(page >= 0); 252 253 buf = malloc(page); 254 pid = fork(); 255 256 if (buf == NULL || pid < 0) 257 atf_tc_fail("initialization failed"); 258 259 if (pid == 0) { 260 261 /* 262 * Try to lock a page while 263 * RLIMIT_MEMLOCK is zero. 264 */ 265 if (mlock(buf, page) != 0) 266 _exit(EXIT_FAILURE); 267 268 if (munlock(buf, page) != 0) 269 _exit(EXIT_FAILURE); 270 271 res.rlim_cur = 0; 272 res.rlim_max = 0; 273 274 if (setrlimit(RLIMIT_MEMLOCK, &res) != 0) 275 _exit(EXIT_FAILURE); 276 277 if (mlock(buf, page) != 0) 278 _exit(EXIT_SUCCESS); 279 280 (void)munlock(buf, page); 281 282 _exit(EXIT_FAILURE); 283 } 284 285 free(buf); 286 287 (void)wait(&sta); 288 289 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) 290 atf_tc_fail("RLIMIT_MEMLOCK not enforced"); 291 } 292 293 ATF_TC(setrlimit_nofile_1); 294 ATF_TC_HEAD(setrlimit_nofile_1, tc) 295 { 296 atf_tc_set_md_var(tc, "descr", "Test setrlimit(2), RLIMIT_NOFILE, #1"); 297 } 298 299 ATF_TC_BODY(setrlimit_nofile_1, tc) 300 { 301 struct rlimit res; 302 int fd, i, rv, sta; 303 pid_t pid; 304 305 res.rlim_cur = 0; 306 res.rlim_max = 0; 307 308 pid = fork(); 309 ATF_REQUIRE(pid >= 0); 310 311 if (pid == 0) { 312 313 /* 314 * Close all descriptors, set RLIMIT_NOFILE 315 * to zero, and try to open a random file. 316 * This should fail with EMFILE. 317 */ 318 for (i = 0; i < 1024; i++) 319 (void)close(i); 320 321 rv = setrlimit(RLIMIT_NOFILE, &res); 322 323 if (rv != 0) 324 _exit(EXIT_FAILURE); 325 326 errno = 0; 327 fd = open("/etc/passwd", O_RDONLY); 328 329 if (fd >= 0 || errno != EMFILE) 330 _exit(EXIT_FAILURE); 331 332 _exit(EXIT_SUCCESS); 333 } 334 335 (void)wait(&sta); 336 337 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) 338 atf_tc_fail("RLIMIT_NOFILE not enforced"); 339 } 340 341 ATF_TC(setrlimit_nofile_2); 342 ATF_TC_HEAD(setrlimit_nofile_2, tc) 343 { 344 atf_tc_set_md_var(tc, "descr", "Test setrlimit(2), RLIMIT_NOFILE, #2"); 345 } 346 347 ATF_TC_BODY(setrlimit_nofile_2, tc) 348 { 349 static const rlim_t lim = 12; 350 struct rlimit res; 351 int fd, i, rv, sta; 352 pid_t pid; 353 354 /* 355 * See that an arbitrary limit on 356 * open files is being enforced. 357 */ 358 res.rlim_cur = lim; 359 res.rlim_max = lim; 360 361 pid = fork(); 362 ATF_REQUIRE(pid >= 0); 363 364 if (pid == 0) { 365 366 for (i = 0; i < 1024; i++) 367 (void)close(i); 368 369 rv = setrlimit(RLIMIT_NOFILE, &res); 370 371 if (rv != 0) 372 _exit(EXIT_FAILURE); 373 374 for (i = 0; i < (int)lim; i++) { 375 376 fd = open("/etc/passwd", O_RDONLY); 377 378 if (fd < 0) 379 _exit(EXIT_FAILURE); 380 } 381 382 /* 383 * After the limit has been reached, 384 * EMFILE should again follow. 385 */ 386 fd = open("/etc/passwd", O_RDONLY); 387 388 if (fd >= 0 || errno != EMFILE) 389 _exit(EXIT_FAILURE); 390 391 _exit(EXIT_SUCCESS); 392 } 393 394 (void)wait(&sta); 395 396 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) 397 atf_tc_fail("RLIMIT_NOFILE not enforced"); 398 } 399 400 ATF_TC(setrlimit_nproc); 401 ATF_TC_HEAD(setrlimit_nproc, tc) 402 { 403 atf_tc_set_md_var(tc, "descr", "Test setrlimit(2), RLIMIT_NPROC"); 404 atf_tc_set_md_var(tc, "require.user", "unprivileged"); 405 } 406 407 ATF_TC_BODY(setrlimit_nproc, tc) 408 { 409 struct rlimit res; 410 pid_t pid, cpid; 411 int sta; 412 413 pid = fork(); 414 ATF_REQUIRE(pid >= 0); 415 416 if (pid == 0) { 417 418 /* 419 * Set RLIMIT_NPROC to zero and try to fork. 420 */ 421 res.rlim_cur = 0; 422 res.rlim_max = 0; 423 424 if (setrlimit(RLIMIT_NPROC, &res) != 0) 425 _exit(EXIT_FAILURE); 426 427 cpid = fork(); 428 429 if (cpid < 0) 430 _exit(EXIT_SUCCESS); 431 432 _exit(EXIT_FAILURE); 433 } 434 435 (void)waitpid(pid, &sta, 0); 436 437 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) 438 atf_tc_fail("RLIMIT_NPROC not enforced"); 439 } 440 441 ATF_TC(setrlimit_nthr); 442 ATF_TC_HEAD(setrlimit_nthr, tc) 443 { 444 atf_tc_set_md_var(tc, "descr", "Test setrlimit(2), RLIMIT_NTHR"); 445 atf_tc_set_md_var(tc, "require.user", "unprivileged"); 446 } 447 448 static void 449 func(lwpid_t *id) 450 { 451 printf("thread %d\n", *id); 452 fflush(stdout); 453 _lwp_exit(); 454 } 455 456 ATF_TC_BODY(setrlimit_nthr, tc) 457 { 458 struct rlimit res; 459 lwpid_t lwpid; 460 ucontext_t c; 461 462 /* 463 * Set RLIMIT_NTHR to zero and try to create a thread. 464 */ 465 res.rlim_cur = 0; 466 res.rlim_max = 0; 467 ATF_REQUIRE(setrlimit(RLIMIT_NTHR, &res) == 0); 468 ATF_REQUIRE(getcontext(&c) == 0); 469 c.uc_link = NULL; 470 sigemptyset(&c.uc_sigmask); 471 c.uc_stack.ss_flags = 0; 472 c.uc_stack.ss_size = 4096; 473 ATF_REQUIRE((c.uc_stack.ss_sp = malloc(c.uc_stack.ss_size)) != NULL); 474 makecontext(&c, func, 1, &lwpid); 475 ATF_CHECK_ERRNO(EAGAIN, _lwp_create(&c, 0, &lwpid) == -1); 476 } 477 478 ATF_TC(setrlimit_perm); 479 ATF_TC_HEAD(setrlimit_perm, tc) 480 { 481 atf_tc_set_md_var(tc, "descr", "Test setrlimit(2) for EPERM"); 482 atf_tc_set_md_var(tc, "require.user", "unprivileged"); 483 } 484 485 ATF_TC_BODY(setrlimit_perm, tc) 486 { 487 struct rlimit res; 488 size_t i; 489 490 /* 491 * Try to raise the maximum limits as an user. 492 */ 493 for (i = 0; i < __arraycount(rlimit); i++) { 494 495 ATF_REQUIRE(getrlimit(rlimit[i], &res) == 0); 496 497 if (res.rlim_max == UINT64_MAX) /* Overflow. */ 498 continue; 499 500 errno = 0; 501 res.rlim_max = res.rlim_max + 1; 502 503 ATF_CHECK_ERRNO(EPERM, setrlimit(rlimit[i], &res) != 0); 504 } 505 } 506 507 ATF_TP_ADD_TCS(tp) 508 { 509 510 ATF_TP_ADD_TC(tp, setrlimit_basic); 511 ATF_TP_ADD_TC(tp, setrlimit_current); 512 ATF_TP_ADD_TC(tp, setrlimit_err); 513 ATF_TP_ADD_TC(tp, setrlimit_fsize); 514 ATF_TP_ADD_TC(tp, setrlimit_memlock); 515 ATF_TP_ADD_TC(tp, setrlimit_nofile_1); 516 ATF_TP_ADD_TC(tp, setrlimit_nofile_2); 517 ATF_TP_ADD_TC(tp, setrlimit_nproc); 518 ATF_TP_ADD_TC(tp, setrlimit_perm); 519 ATF_TP_ADD_TC(tp, setrlimit_nthr); 520 521 return atf_no_error(); 522 } 523
Indexes created Wed Oct 01 19:09:53 GMT 2025