1 /* $NetBSD: t_setrlimit.c,v 1.6 2017/01/13 21:16:38 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.6 2017/01/13 21:16:38 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 #ifdef __NetBSD__ 43 #include <lwp.h> 44 #endif 45 #include <signal.h> 46 #include <stdint.h> 47 #include <stdio.h> 48 #include <stdlib.h> 49 #include <string.h> 50 #include <ucontext.h> 51 #include <unistd.h> 52 53 #ifdef __FreeBSD__ 54 void set_vm_max_wired(int); 55 void restore_vm_max_wired(void); 56 #endif 57 58 static void sighandler(int); 59 static const char path[] = "setrlimit"; 60 61 static const int rlimit[] = { 62 RLIMIT_AS, 63 RLIMIT_CORE, 64 RLIMIT_CPU, 65 RLIMIT_DATA, 66 RLIMIT_FSIZE, 67 RLIMIT_MEMLOCK, 68 RLIMIT_NOFILE, 69 RLIMIT_NPROC, 70 RLIMIT_RSS, 71 RLIMIT_SBSIZE, 72 RLIMIT_STACK 73 }; 74 75 ATF_TC(setrlimit_basic); 76 ATF_TC_HEAD(setrlimit_basic, tc) 77 { 78 atf_tc_set_md_var(tc, "descr", "A basic soft limit test"); 79 } 80 81 ATF_TC_BODY(setrlimit_basic, tc) 82 { 83 struct rlimit res; 84 int *buf, lim; 85 size_t i; 86 87 buf = calloc(__arraycount(rlimit), sizeof(int)); 88 89 if (buf == NULL) 90 atf_tc_fail("initialization failed"); 91 92 for (i = lim = 0; i < __arraycount(rlimit); i++) { 93 94 (void)memset(&res, 0, sizeof(struct rlimit)); 95 96 if (getrlimit(rlimit[i], &res) != 0) 97 continue; 98 99 if (res.rlim_cur == RLIM_INFINITY || res.rlim_cur == 0) 100 continue; 101 102 if (res.rlim_cur == res.rlim_max) /* An unprivileged run. */ 103 continue; 104 105 buf[i] = res.rlim_cur; 106 res.rlim_cur = res.rlim_cur - 1; 107 108 if (setrlimit(rlimit[i], &res) != 0) { 109 lim = rlimit[i]; 110 goto out; 111 } 112 } 113 114 out: 115 for (i = 0; i < __arraycount(rlimit); i++) { 116 117 (void)memset(&res, 0, sizeof(struct rlimit)); 118 119 if (buf[i] == 0) 120 continue; 121 122 if (getrlimit(rlimit[i], &res) != 0) 123 continue; 124 125 res.rlim_cur = buf[i]; 126 127 (void)setrlimit(rlimit[i], &res); 128 } 129 130 if (lim != 0) 131 atf_tc_fail("failed to set limit (%d)", lim); 132 free(buf); 133 } 134 135 ATF_TC(setrlimit_current); 136 ATF_TC_HEAD(setrlimit_current, tc) 137 { 138 atf_tc_set_md_var(tc, "descr", "setrlimit(3) with current limits"); 139 } 140 141 ATF_TC_BODY(setrlimit_current, tc) 142 { 143 struct rlimit res; 144 size_t i; 145 146 for (i = 0; i < __arraycount(rlimit); i++) { 147 148 (void)memset(&res, 0, sizeof(struct rlimit)); 149 150 ATF_REQUIRE(getrlimit(rlimit[i], &res) == 0); 151 ATF_REQUIRE(setrlimit(rlimit[i], &res) == 0); 152 } 153 } 154 155 ATF_TC(setrlimit_err); 156 ATF_TC_HEAD(setrlimit_err, tc) 157 { 158 atf_tc_set_md_var(tc, "descr", "Test error conditions"); 159 } 160 161 ATF_TC_BODY(setrlimit_err, tc) 162 { 163 struct rlimit res; 164 size_t i; 165 166 for (i = 0; i < __arraycount(rlimit); i++) { 167 168 errno = 0; 169 170 ATF_REQUIRE(getrlimit(rlimit[i], (void *)0) != 0); 171 ATF_REQUIRE(errno == EFAULT); 172 } 173 174 errno = 0; 175 176 ATF_REQUIRE(getrlimit(INT_MAX, &res) != 0); 177 ATF_REQUIRE(errno == EINVAL); 178 } 179 180 ATF_TC_WITH_CLEANUP(setrlimit_fsize); 181 ATF_TC_HEAD(setrlimit_fsize, tc) 182 { 183 atf_tc_set_md_var(tc, "descr", "Test setrlimit(2), RLIMIT_FSIZE"); 184 } 185 186 ATF_TC_BODY(setrlimit_fsize, tc) 187 { 188 struct rlimit res; 189 int fd, sta; 190 pid_t pid; 191 192 fd = open(path, O_RDWR | O_CREAT, 0700); 193 194 if (fd < 0) 195 atf_tc_fail("initialization failed"); 196 197 pid = fork(); 198 ATF_REQUIRE(pid >= 0); 199 200 if (pid == 0) { 201 202 res.rlim_cur = 2; 203 res.rlim_max = 2; 204 205 if (setrlimit(RLIMIT_FSIZE, &res) != 0) 206 _exit(EXIT_FAILURE); 207 208 if (signal(SIGXFSZ, sighandler) == SIG_ERR) 209 _exit(EXIT_FAILURE); 210 211 /* 212 * The third call should generate a SIGXFSZ. 213 */ 214 (void)write(fd, "X", 1); 215 (void)write(fd, "X", 1); 216 (void)write(fd, "X", 1); 217 218 _exit(EXIT_FAILURE); 219 } 220 221 (void)close(fd); 222 (void)wait(&sta); 223 (void)unlink(path); 224 225 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) 226 atf_tc_fail("RLIMIT_FSIZE not enforced"); 227 } 228 229 ATF_TC_CLEANUP(setrlimit_fsize, tc) 230 { 231 (void)unlink(path); 232 } 233 234 static void 235 sighandler(int signo) 236 { 237 238 if (signo != SIGXFSZ) 239 _exit(EXIT_FAILURE); 240 241 _exit(EXIT_SUCCESS); 242 } 243 244 #ifdef __FreeBSD__ 245 ATF_TC_WITH_CLEANUP(setrlimit_memlock); 246 #else 247 ATF_TC(setrlimit_memlock); 248 #endif 249 ATF_TC_HEAD(setrlimit_memlock, tc) 250 { 251 atf_tc_set_md_var(tc, "descr", "Test setrlimit(2), RLIMIT_MEMLOCK"); 252 #ifdef __FreeBSD__ 253 atf_tc_set_md_var(tc, "require.config", "allow_sysctl_side_effects"); 254 atf_tc_set_md_var(tc, "require.user", "root"); 255 #endif 256 } 257 258 ATF_TC_BODY(setrlimit_memlock, tc) 259 { 260 struct rlimit res; 261 void *buf; 262 long page; 263 pid_t pid; 264 int sta; 265 266 #ifdef __FreeBSD__ 267 /* Set max_wired really really high to avoid EAGAIN */ 268 set_vm_max_wired(INT_MAX); 269 #endif 270 271 page = sysconf(_SC_PAGESIZE); 272 ATF_REQUIRE(page >= 0); 273 274 buf = malloc(page); 275 pid = fork(); 276 277 if (buf == NULL || pid < 0) 278 atf_tc_fail("initialization failed"); 279 280 if (pid == 0) { 281 282 /* 283 * Try to lock a page while 284 * RLIMIT_MEMLOCK is zero. 285 */ 286 if (mlock(buf, page) != 0) 287 _exit(EXIT_FAILURE); 288 289 if (munlock(buf, page) != 0) 290 _exit(EXIT_FAILURE); 291 292 res.rlim_cur = 0; 293 res.rlim_max = 0; 294 295 if (setrlimit(RLIMIT_MEMLOCK, &res) != 0) 296 _exit(EXIT_FAILURE); 297 298 if (mlock(buf, page) != 0) 299 _exit(EXIT_SUCCESS); 300 301 (void)munlock(buf, page); 302 303 _exit(EXIT_FAILURE); 304 } 305 306 free(buf); 307 308 (void)wait(&sta); 309 310 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) 311 atf_tc_fail("RLIMIT_MEMLOCK not enforced"); 312 } 313 314 #ifdef __FreeBSD__ 315 ATF_TC_CLEANUP(setrlimit_memlock, tc) 316 { 317 318 restore_vm_max_wired(); 319 } 320 #endif 321 322 ATF_TC(setrlimit_nofile_1); 323 ATF_TC_HEAD(setrlimit_nofile_1, tc) 324 { 325 atf_tc_set_md_var(tc, "descr", "Test setrlimit(2), RLIMIT_NOFILE, #1"); 326 } 327 328 ATF_TC_BODY(setrlimit_nofile_1, tc) 329 { 330 struct rlimit res; 331 int fd, i, rv, sta; 332 pid_t pid; 333 334 res.rlim_cur = 0; 335 res.rlim_max = 0; 336 337 pid = fork(); 338 ATF_REQUIRE(pid >= 0); 339 340 if (pid == 0) { 341 342 /* 343 * Close all descriptors, set RLIMIT_NOFILE 344 * to zero, and try to open a random file. 345 * This should fail with EMFILE. 346 */ 347 for (i = 0; i < 1024; i++) 348 (void)close(i); 349 350 rv = setrlimit(RLIMIT_NOFILE, &res); 351 352 if (rv != 0) 353 _exit(EXIT_FAILURE); 354 355 errno = 0; 356 fd = open("/etc/passwd", O_RDONLY); 357 358 if (fd >= 0 || errno != EMFILE) 359 _exit(EXIT_FAILURE); 360 361 _exit(EXIT_SUCCESS); 362 } 363 364 (void)wait(&sta); 365 366 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) 367 atf_tc_fail("RLIMIT_NOFILE not enforced"); 368 } 369 370 ATF_TC(setrlimit_nofile_2); 371 ATF_TC_HEAD(setrlimit_nofile_2, tc) 372 { 373 atf_tc_set_md_var(tc, "descr", "Test setrlimit(2), RLIMIT_NOFILE, #2"); 374 } 375 376 ATF_TC_BODY(setrlimit_nofile_2, tc) 377 { 378 static const rlim_t lim = 12; 379 struct rlimit res; 380 int fd, i, rv, sta; 381 pid_t pid; 382 383 /* 384 * See that an arbitrary limit on 385 * open files is being enforced. 386 */ 387 res.rlim_cur = lim; 388 res.rlim_max = lim; 389 390 pid = fork(); 391 ATF_REQUIRE(pid >= 0); 392 393 if (pid == 0) { 394 395 for (i = 0; i < 1024; i++) 396 (void)close(i); 397 398 rv = setrlimit(RLIMIT_NOFILE, &res); 399 400 if (rv != 0) 401 _exit(EXIT_FAILURE); 402 403 for (i = 0; i < (int)lim; i++) { 404 405 fd = open("/etc/passwd", O_RDONLY); 406 407 if (fd < 0) 408 _exit(EXIT_FAILURE); 409 } 410 411 /* 412 * After the limit has been reached, 413 * EMFILE should again follow. 414 */ 415 fd = open("/etc/passwd", O_RDONLY); 416 417 if (fd >= 0 || errno != EMFILE) 418 _exit(EXIT_FAILURE); 419 420 _exit(EXIT_SUCCESS); 421 } 422 423 (void)wait(&sta); 424 425 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) 426 atf_tc_fail("RLIMIT_NOFILE not enforced"); 427 } 428 429 ATF_TC(setrlimit_nproc); 430 ATF_TC_HEAD(setrlimit_nproc, tc) 431 { 432 atf_tc_set_md_var(tc, "descr", "Test setrlimit(2), RLIMIT_NPROC"); 433 atf_tc_set_md_var(tc, "require.user", "unprivileged"); 434 } 435 436 ATF_TC_BODY(setrlimit_nproc, tc) 437 { 438 struct rlimit res; 439 pid_t pid, cpid; 440 int sta; 441 442 pid = fork(); 443 ATF_REQUIRE(pid >= 0); 444 445 if (pid == 0) { 446 447 /* 448 * Set RLIMIT_NPROC to zero and try to fork. 449 */ 450 res.rlim_cur = 0; 451 res.rlim_max = 0; 452 453 if (setrlimit(RLIMIT_NPROC, &res) != 0) 454 _exit(EXIT_FAILURE); 455 456 cpid = fork(); 457 458 if (cpid < 0) 459 _exit(EXIT_SUCCESS); 460 461 _exit(EXIT_FAILURE); 462 } 463 464 (void)waitpid(pid, &sta, 0); 465 466 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) 467 atf_tc_fail("RLIMIT_NPROC not enforced"); 468 } 469 470 #ifdef __NetBSD__ 471 ATF_TC(setrlimit_nthr); 472 ATF_TC_HEAD(setrlimit_nthr, tc) 473 { 474 atf_tc_set_md_var(tc, "descr", "Test setrlimit(2), RLIMIT_NTHR"); 475 atf_tc_set_md_var(tc, "require.user", "unprivileged"); 476 } 477 478 static void 479 func(lwpid_t *id) 480 { 481 printf("thread %d\n", *id); 482 fflush(stdout); 483 _lwp_exit(); 484 } 485 486 ATF_TC_BODY(setrlimit_nthr, tc) 487 { 488 struct rlimit res; 489 lwpid_t lwpid; 490 ucontext_t c; 491 492 /* 493 * Set RLIMIT_NTHR to zero and try to create a thread. 494 */ 495 res.rlim_cur = 0; 496 res.rlim_max = 0; 497 ATF_REQUIRE(setrlimit(RLIMIT_NTHR, &res) == 0); 498 ATF_REQUIRE(getcontext(&c) == 0); 499 c.uc_link = NULL; 500 sigemptyset(&c.uc_sigmask); 501 c.uc_stack.ss_flags = 0; 502 c.uc_stack.ss_size = 4096; 503 ATF_REQUIRE((c.uc_stack.ss_sp = malloc(c.uc_stack.ss_size)) != NULL); 504 makecontext(&c, func, 1, &lwpid); 505 ATF_CHECK_ERRNO(EAGAIN, _lwp_create(&c, 0, &lwpid) == -1); 506 } 507 #endif 508 509 ATF_TC(setrlimit_perm); 510 ATF_TC_HEAD(setrlimit_perm, tc) 511 { 512 atf_tc_set_md_var(tc, "descr", "Test setrlimit(2) for EPERM"); 513 atf_tc_set_md_var(tc, "require.user", "unprivileged"); 514 } 515 516 ATF_TC_BODY(setrlimit_perm, tc) 517 { 518 struct rlimit res; 519 size_t i; 520 521 /* 522 * Try to raise the maximum limits as an user. 523 */ 524 for (i = 0; i < __arraycount(rlimit); i++) { 525 526 ATF_REQUIRE(getrlimit(rlimit[i], &res) == 0); 527 528 #ifdef __FreeBSD__ 529 if (res.rlim_max == INT64_MAX) /* Overflow. */ 530 #else 531 if (res.rlim_max == UINT64_MAX) /* Overflow. */ 532 #endif 533 continue; 534 535 errno = 0; 536 res.rlim_max = res.rlim_max + 1; 537 538 ATF_CHECK_ERRNO(EPERM, setrlimit(rlimit[i], &res) != 0); 539 } 540 } 541 542 ATF_TC(setrlimit_stack); 543 ATF_TC_HEAD(setrlimit_stack, tc) 544 { 545 atf_tc_set_md_var(tc, "descr", "Test setrlimit(2), RLIMIT_STACK"); 546 atf_tc_set_md_var(tc, "require.user", "unprivileged"); 547 } 548 549 ATF_TC_BODY(setrlimit_stack, tc) 550 { 551 struct rlimit res; 552 553 /* Ensure soft limit is not bigger than hard limit */ 554 res.rlim_cur = res.rlim_max = 4192256; 555 ATF_REQUIRE(setrlimit(RLIMIT_STACK, &res) == 0); 556 ATF_REQUIRE(getrlimit(RLIMIT_STACK, &res) == 0); 557 ATF_CHECK(res.rlim_cur <= res.rlim_max); 558 559 } 560 561 ATF_TP_ADD_TCS(tp) 562 { 563 564 ATF_TP_ADD_TC(tp, setrlimit_basic); 565 ATF_TP_ADD_TC(tp, setrlimit_current); 566 ATF_TP_ADD_TC(tp, setrlimit_err); 567 ATF_TP_ADD_TC(tp, setrlimit_fsize); 568 ATF_TP_ADD_TC(tp, setrlimit_memlock); 569 ATF_TP_ADD_TC(tp, setrlimit_nofile_1); 570 ATF_TP_ADD_TC(tp, setrlimit_nofile_2); 571 ATF_TP_ADD_TC(tp, setrlimit_nproc); 572 ATF_TP_ADD_TC(tp, setrlimit_perm); 573 #ifdef __NetBSD__ 574 ATF_TP_ADD_TC(tp, setrlimit_nthr); 575 #endif 576 ATF_TP_ADD_TC(tp, setrlimit_stack); 577 578 return atf_no_error(); 579 } 580