contrib/netbsd-tests/lib/libc/sys/t_mlock.c

   1 /* $NetBSD: t_mlock.c,v 1.6 2016/08/09 12:02:44 kre Exp $ */
   2
   3 /*-
   4  * Copyright (c) 2012 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_mlock.c,v 1.6 2016/08/09 12:02:44 kre Exp $");
  33
  34 #ifdef __FreeBSD__
  35 #include <sys/types.h>
  36 #endif
  37 #include <sys/mman.h>
  38 #include <sys/resource.h>
  39 #include <sys/sysctl.h>
  40 #include <sys/wait.h>
  41
  42 #include <errno.h>
  43 #include <atf-c.h>
  44 #include <stdint.h>
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <unistd.h>
  48
  49 #ifdef __FreeBSD__
  50 #include <limits.h>
  51 #define _KMEMUSER
  52 #include <machine/vmparam.h>
  53 #endif
  54
  55 static long page = 0;
  56
  57 #ifdef __FreeBSD__
  58 #define VM_MAX_WIRED "vm.max_wired"
  59
  60 static void
  61 vm_max_wired_sysctl(int *old_value, int *new_value)
  62 {
  63         size_t old_len;
  64         size_t new_len = (new_value == NULL ? 0 : sizeof(int));
  65
  66         if (old_value == NULL)
  67                 printf("Setting the new value to %d\n", *new_value);
  68         else {
  69                 ATF_REQUIRE_MSG(sysctlbyname(VM_MAX_WIRED, NULL, &old_len,
  70                     new_value, new_len) == 0,
  71                     "sysctlbyname(%s) failed: %s", VM_MAX_WIRED, strerror(errno));
  72         }
  73
  74         ATF_REQUIRE_MSG(sysctlbyname(VM_MAX_WIRED, old_value, &old_len,
  75             new_value, new_len) == 0,
  76             "sysctlbyname(%s) failed: %s", VM_MAX_WIRED, strerror(errno));
  77
  78         if (old_value != NULL)
  79                 printf("Saved the old value (%d)\n", *old_value);
  80 }
  81
  82 static void
  83 set_vm_max_wired(int new_value)
  84 {
  85         FILE *fp;
  86         int old_value;
  87
  88         fp = fopen(VM_MAX_WIRED, "w");
  89         if (fp == NULL) {
  90                 atf_tc_skip("could not open %s for writing: %s",
  91                     VM_MAX_WIRED, strerror(errno));
  92                 return;
  93         }
  94
  95         vm_max_wired_sysctl(&old_value, NULL);
  96
  97         ATF_REQUIRE_MSG(fprintf(fp, "%d", old_value) > 0,
  98             "saving %s failed", VM_MAX_WIRED);
  99
 100         fclose(fp);
 101
 102         vm_max_wired_sysctl(NULL, &new_value);
 103 }
 104
 105 static void
 106 restore_vm_max_wired(void)
 107 {
 108         FILE *fp;
 109         int saved_max_wired;
 110
 111         fp = fopen(VM_MAX_WIRED, "r");
 112         if (fp == NULL) {
 113                 perror("fopen failed\n");
 114                 return;
 115         }
 116
 117         if (fscanf(fp, "%d", &saved_max_wired) != 1) {
 118                 perror("fscanf failed\n");
 119                 fclose(fp);
 120                 return;
 121         }
 122
 123         fclose(fp);
 124         printf("old value in %s: %d\n", VM_MAX_WIRED, saved_max_wired);
 125
 126         if (saved_max_wired == 0) /* This will cripple the test host */
 127                 return;
 128
 129         vm_max_wired_sysctl(NULL, &saved_max_wired);
 130 }
 131 #endif
 132
 133 ATF_TC(mlock_clip);
 134 ATF_TC_HEAD(mlock_clip, tc)
 135 {
 136         atf_tc_set_md_var(tc, "descr", "Test with mlock(2) that UVM only "
 137             "clips if the clip address is within the entry (PR kern/44788)");
 138 }
 139
 140 ATF_TC_BODY(mlock_clip, tc)
 141 {
 142         void *buf;
 143
 144         buf = malloc(page);
 145         ATF_REQUIRE(buf != NULL);
 146
 147         if (page < 1024)
 148                 atf_tc_skip("page size too small");
 149
 150         for (size_t i = page; i >= 1; i = i - 1024) {
 151                 (void)mlock(buf, page - i);
 152                 (void)munlock(buf, page - i);
 153         }
 154
 155         free(buf);
 156 }
 157
 158 #ifdef __FreeBSD__
 159 ATF_TC_WITH_CLEANUP(mlock_err);
 160 #else
 161 ATF_TC(mlock_err);
 162 #endif
 163 ATF_TC_HEAD(mlock_err, tc)
 164 {
 165         atf_tc_set_md_var(tc, "descr",
 166             "Test error conditions in mlock(2) and munlock(2)");
 167 #ifdef __FreeBSD__
 168         atf_tc_set_md_var(tc, "require.config", "allow_sysctl_side_effects");
 169         atf_tc_set_md_var(tc, "require.user", "root");
 170 #endif
 171 }
 172
 173 ATF_TC_BODY(mlock_err, tc)
 174 {
 175 #ifdef __NetBSD__
 176         unsigned long vmin = 0;
 177         size_t len = sizeof(vmin);
 178 #endif
 179         void *invalid_ptr;
 180         int null_errno = ENOMEM;        /* error expected for NULL */
 181         void *buf;
 182
 183 #ifdef __FreeBSD__
 184 #ifdef VM_MIN_ADDRESS
 185         if ((uintptr_t)VM_MIN_ADDRESS > 0)
 186                 null_errno = EINVAL;    /* NULL is not inside user VM */
 187 #endif
 188         /* Set max_wired really really high to avoid EAGAIN */
 189         set_vm_max_wired(INT_MAX);
 190 #else
 191         if (sysctlbyname("vm.minaddress", &vmin, &len, NULL, 0) != 0)
 192                 atf_tc_fail("failed to read vm.minaddress");
 193         /*
 194          * Any bad address must return ENOMEM (for lock & unlock)
 195          */
 196         errno = 0;
 197         ATF_REQUIRE_ERRNO(ENOMEM, mlock(NULL, page) == -1);
 198
 199         if (vmin > 0)
 200                 null_errno = EINVAL;    /* NULL is not inside user VM */
 201 #endif
 202
 203         errno = 0;
 204         ATF_REQUIRE_ERRNO(ENOMEM, mlock((char *)0, page) == -1);
 205
 206         errno = 0;
 207         ATF_REQUIRE_ERRNO(ENOMEM, mlock((char *)-1, page) == -1);
 208
 209         errno = 0;
 210         ATF_REQUIRE_ERRNO(ENOMEM, munlock(NULL, page) == -1);
 211
 212         errno = 0;
 213         ATF_REQUIRE_ERRNO(ENOMEM, munlock((char *)0, page) == -1);
 214
 215         errno = 0;
 216         ATF_REQUIRE_ERRNO(ENOMEM, munlock((char *)-1, page) == -1);
 217
 218         buf = malloc(page);
 219         ATF_REQUIRE(buf != NULL);
 220
 221         /*
 222          * unlocking memory that is not locked is an error...
 223          */
 224
 225         errno = 0;
 226         ATF_REQUIRE_ERRNO(ENOMEM, munlock(buf, page) == -1);
 227
 228         /*
 229          * These are permitted to fail (EINVAL) but do not on NetBSD
 230          */
 231         ATF_REQUIRE(mlock((void *)(((uintptr_t)buf) + page/3), page/5) == 0);
 232         ATF_REQUIRE(munlock((void *)(((uintptr_t)buf) + page/3), page/5) == 0);
 233
 234         (void)free(buf);
 235
 236         /*
 237          * Try to create a pointer to an unmapped page - first after current
 238          * brk will likely do.
 239          */
 240         invalid_ptr = (void*)(((uintptr_t)sbrk(0)+page) & ~(page-1));
 241         printf("testing with (hopefully) invalid pointer %p\n", invalid_ptr);
 242
 243         errno = 0;
 244         ATF_REQUIRE_ERRNO(ENOMEM, mlock(invalid_ptr, page) == -1);
 245
 246         errno = 0;
 247         ATF_REQUIRE_ERRNO(ENOMEM, munlock(invalid_ptr, page) == -1);
 248 }
 249
 250 #ifdef __FreeBSD__
 251 ATF_TC_CLEANUP(mlock_err, tc)
 252 {
 253
 254         restore_vm_max_wired();
 255 }
 256 #endif
 257
 258 ATF_TC(mlock_limits);
 259 ATF_TC_HEAD(mlock_limits, tc)
 260 {
 261         atf_tc_set_md_var(tc, "descr", "Test system limits with mlock(2)");
 262 }
 263
 264 ATF_TC_BODY(mlock_limits, tc)
 265 {
 266         struct rlimit res;
 267         void *buf;
 268         pid_t pid;
 269         int sta;
 270
 271         buf = malloc(page);
 272         ATF_REQUIRE(buf != NULL);
 273
 274         pid = fork();
 275         ATF_REQUIRE(pid >= 0);
 276
 277         if (pid == 0) {
 278
 279                 for (ssize_t i = page; i >= 2; i -= 100) {
 280
 281                         res.rlim_cur = i - 1;
 282                         res.rlim_max = i - 1;
 283
 284                         (void)fprintf(stderr, "trying to lock %zd bytes "
 285                             "with %zu byte limit\n", i, (size_t)res.rlim_cur);
 286
 287                         if (setrlimit(RLIMIT_MEMLOCK, &res) != 0)
 288                                 _exit(EXIT_FAILURE);
 289
 290                         errno = 0;
 291
 292 #ifdef __FreeBSD__
 293                         /*
 294                          * NetBSD doesn't conform to POSIX with ENOMEM requirement;
 295                          * FreeBSD does.
 296                          *
 297                          * See: NetBSD PR # kern/48962 for more details.
 298                          */
 299                         if (mlock(buf, i) != -1 || errno != ENOMEM) {
 300 #else
 301                         if (mlock(buf, i) != -1 || errno != EAGAIN) {
 302 #endif
 303                                 (void)munlock(buf, i);
 304                                 _exit(EXIT_FAILURE);
 305                         }
 306                 }
 307
 308                 _exit(EXIT_SUCCESS);
 309         }
 310
 311         (void)wait(&sta);
 312
 313         if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS)
 314                 atf_tc_fail("mlock(2) locked beyond system limits");
 315
 316         free(buf);
 317 }
 318
 319 #ifdef __FreeBSD__
 320 ATF_TC_WITH_CLEANUP(mlock_mmap);
 321 #else
 322 ATF_TC(mlock_mmap);
 323 #endif
 324 ATF_TC_HEAD(mlock_mmap, tc)
 325 {
 326         atf_tc_set_md_var(tc, "descr", "Test mlock(2)-mmap(2) interaction");
 327 #ifdef __FreeBSD__
 328         atf_tc_set_md_var(tc, "require.config", "allow_sysctl_side_effects");
 329         atf_tc_set_md_var(tc, "require.user", "root");
 330 #endif
 331 }
 332
 333 ATF_TC_BODY(mlock_mmap, tc)
 334 {
 335 #ifdef __NetBSD__
 336         static const int flags = MAP_ANON | MAP_PRIVATE | MAP_WIRED;
 337 #else
 338         static const int flags = MAP_ANON | MAP_PRIVATE;
 339 #endif
 340         void *buf;
 341
 342 #ifdef __FreeBSD__
 343         /* Set max_wired really really high to avoid EAGAIN */
 344         set_vm_max_wired(INT_MAX);
 345 #endif
 346
 347         /*
 348          * Make a wired RW mapping and check that mlock(2)
 349          * does not fail for the (already locked) mapping.
 350          */
 351         buf = mmap(NULL, page, PROT_READ | PROT_WRITE, flags, -1, 0);
 352
 353         ATF_REQUIRE(buf != MAP_FAILED);
 354 #ifdef __FreeBSD__
 355         /*
 356          * The duplicate mlock call is added to ensure that the call works
 357          * as described above without MAP_WIRED support.
 358          */
 359         ATF_REQUIRE(mlock(buf, page) == 0);
 360 #endif
 361         ATF_REQUIRE(mlock(buf, page) == 0);
 362         ATF_REQUIRE(munlock(buf, page) == 0);
 363         ATF_REQUIRE(munmap(buf, page) == 0);
 364         ATF_REQUIRE(munlock(buf, page) != 0);
 365
 366         /*
 367          * But it should be impossible to mlock(2) a PROT_NONE mapping.
 368          */
 369         buf = mmap(NULL, page, PROT_NONE, flags, -1, 0);
 370
 371         ATF_REQUIRE(buf != MAP_FAILED);
 372 #ifdef __FreeBSD__
 373         ATF_REQUIRE_ERRNO(ENOMEM, mlock(buf, page) != 0);
 374 #else
 375         ATF_REQUIRE(mlock(buf, page) != 0);
 376 #endif
 377         ATF_REQUIRE(munmap(buf, page) == 0);
 378 }
 379
 380 #ifdef __FreeBSD__
 381 ATF_TC_CLEANUP(mlock_mmap, tc)
 382 {
 383
 384         restore_vm_max_wired();
 385 }
 386 #endif
 387
 388 #ifdef __FreeBSD__
 389 ATF_TC_WITH_CLEANUP(mlock_nested);
 390 #else
 391 ATF_TC(mlock_nested);
 392 #endif
 393 ATF_TC_HEAD(mlock_nested, tc)
 394 {
 395         atf_tc_set_md_var(tc, "descr",
 396             "Test that consecutive mlock(2) calls succeed");
 397 #ifdef __FreeBSD__
 398         atf_tc_set_md_var(tc, "require.config", "allow_sysctl_side_effects");
 399         atf_tc_set_md_var(tc, "require.user", "root");
 400 #endif
 401 }
 402
 403 ATF_TC_BODY(mlock_nested, tc)
 404 {
 405         const size_t maxiter = 100;
 406         void *buf;
 407
 408 #ifdef __FreeBSD__
 409         /* Set max_wired really really high to avoid EAGAIN */
 410         set_vm_max_wired(INT_MAX);
 411 #endif
 412
 413         buf = malloc(page);
 414         ATF_REQUIRE(buf != NULL);
 415
 416         for (size_t i = 0; i < maxiter; i++)
 417                 ATF_REQUIRE(mlock(buf, page) == 0);
 418
 419         ATF_REQUIRE(munlock(buf, page) == 0);
 420         free(buf);
 421 }
 422
 423 #ifdef __FreeBSD__
 424 ATF_TC_CLEANUP(mlock_nested, tc)
 425 {
 426
 427         restore_vm_max_wired();
 428 }
 429 #endif
 430
 431 ATF_TP_ADD_TCS(tp)
 432 {
 433
 434         page = sysconf(_SC_PAGESIZE);
 435         ATF_REQUIRE(page >= 0);
 436
 437         ATF_TP_ADD_TC(tp, mlock_clip);
 438         ATF_TP_ADD_TC(tp, mlock_err);
 439         ATF_TP_ADD_TC(tp, mlock_limits);
 440         ATF_TP_ADD_TC(tp, mlock_mmap);
 441         ATF_TP_ADD_TC(tp, mlock_nested);
 442
 443         return atf_no_error();
 444 }