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